Optimise Optional Determining Logic

README.md

@@ -469,7 +469,7 @@ createDocument({
 
 ##### Zod Effects
 
-`.transform()`, `.default()` and `.pipe()` are complicated because they technically comprise of two types (input & output). This means that we need to understand which type you are creating. In particular with transform it is very difficult to infer the output type. This library will automatically select which _type_ to use by checking how the schema is used based on the following rules:
+`.transform()`, `.catch()`, `.default()` and `.pipe()` are complicated because they technically comprise of two types (input & output). This means that we need to understand which type you are creating. In particular with transform it is very difficult to infer the output type. This library will automatically select which _type_ to use by checking how the schema is used based on the following rules:
 
 _Input_: Request Bodies, Request Parameters, Headers
 
@@ -694,6 +694,7 @@ For example in `z.string().nullable()` will be rendered differently
 - ZodBoolean
 - ZodBranded
 - ZodCatch
+  - Treated as ZodDefault
 - ZodDate
   - `type` is mapped as `string` by default
 - ZodDefault

src/create/parameters.ts

@@ -10,7 +10,6 @@ import type {
   ZodOpenApiParameters,
 } from './document';
 import { type SchemaState, createSchema } from './schema';
-import { isOptionalSchema } from './schema/parsers/optional';
 
 export const createComponentParamRef = (ref: string) =>
   `#/components/parameters/${ref}`;
@@ -30,7 +29,8 @@ export const createBaseParameter = (
     documentOptions,
   };
   const schemaObject = createSchema(schema, state, [...subpath, 'schema']);
-  const required = !isOptionalSchema(schema, state)?.optional;
+  const required = !schema.isOptional();
+
   const description =
     schema._def.openapi?.description ?? schema._def.description;
 

src/create/responses.ts

@@ -14,7 +14,6 @@ import type {
   ZodOpenApiResponsesObject,
 } from './document';
 import { type SchemaState, createSchema } from './schema';
-import { isOptionalSchema } from './schema/parsers/optional';
 import { isISpecificationExtension } from './specificationExtension';
 
 export const createResponseHeaders = (
@@ -90,7 +89,9 @@ export const createBaseHeader = (
     documentOptions,
   };
   const schemaObject = createSchema(schema, state, ['header']);
-  const required = !isOptionalSchema(schema, state)?.optional;
+  const optionalResult = schema.safeParse(undefined);
+
+  const required = !optionalResult.success || optionalResult !== undefined;
   return {
     ...rest,
     ...(schema && { schema: schemaObject }),

src/create/schema/index.test.ts

@@ -191,6 +191,7 @@ const expectedZodUnion: Schema['schema'] = {
 const zodCatch = z.string().catch('bob');
 const expectedZodCatch: Schema['schema'] = {
   type: 'string',
+  default: 'bob',
 };
 
 const zodPipeline = z

src/create/schema/parsers/catch.test.ts

@@ -7,11 +7,12 @@ import { createOutputState } from '../../../testing/state';
 import { createCatchSchema } from './catch';
 
 describe('createCatchSchema', () => {
-  it('creates a simple string schema for a string with a catch', () => {
+  it('creates a default string schema for a string with a catch', () => {
     const expected: Schema = {
       type: 'schema',
       schema: {
         type: 'string',
+        default: 'bob',
       },
     };
     const schema = z.string().catch('bob');

src/create/schema/parsers/catch.ts

@@ -1,12 +1,31 @@
 import type { ZodCatch, ZodTypeAny } from 'zod';
 
+import type { oas31 } from '../../../../dist';
 import {
   type Schema,
   type SchemaState,
   createSchemaObject,
 } from '../../schema';
+import { enhanceWithMetadata } from '../metadata';
 
 export const createCatchSchema = <T extends ZodTypeAny>(
   zodCatch: ZodCatch<T>,
   state: SchemaState,
-): Schema => createSchemaObject(zodCatch._def.innerType, state, ['catch']);
+): Schema => {
+  const schemaObject = createSchemaObject(zodCatch._def.innerType, state, [
+    'default',
+  ]);
+
+  const catchResult = zodCatch.safeParse(undefined);
+
+  const maybeDefaultValue: Pick<oas31.SchemaObject, 'default'> | undefined =
+    catchResult.success
+      ? {
+          default: catchResult.data,
+        }
+      : undefined;
+
+  return enhanceWithMetadata(schemaObject, {
+    ...maybeDefaultValue,
+  });
+};

src/create/schema/parsers/discriminatedUnion.test.ts

@@ -443,7 +443,22 @@ describe('createDiscriminatedUnionSchema', () => {
   });
 
   it('handles a discriminated union with a catch type', () => {
-    const expected: Schema = {
+    const schema = z.discriminatedUnion('type', [
+      z
+        .object({
+          type: z.literal('a').catch('a'),
+        })
+        .openapi({ ref: 'a' }),
+      z
+        .object({
+          type: z.literal('b'),
+        })
+        .openapi({ ref: 'b' }),
+    ]);
+
+    const result = createDiscriminatedUnionSchema(schema, createOutputState());
+
+    expect(result).toEqual<Schema>({
       type: 'schema',
       schema: {
         discriminator: {
@@ -462,22 +477,13 @@ describe('createDiscriminatedUnionSchema', () => {
           },
         ],
       },
-    };
-    const schema = z.discriminatedUnion('type', [
-      z
-        .object({
-          type: z.literal('a').catch('a'),
-        })
-        .openapi({ ref: 'a' }),
-      z
-        .object({
-          type: z.literal('b'),
-        })
-        .openapi({ ref: 'b' }),
-    ]);
-
-    const result = createDiscriminatedUnionSchema(schema, createOutputState());
-
-    expect(result).toEqual(expected);
+      effects: [
+        {
+          type: 'component',
+          path: ['discriminated union option 0'],
+          zodType: schema.options[0],
+        },
+      ],
+    });
   });
 });