[zod-openapi] a quick take on removing "nullable" and solving nullability of z.custom()

packages/zod-openapi/src/lib/zod-openapi.spec.ts

@@ -53,7 +53,7 @@
       type: 'object',
       properties: {
         aUndefined: {},
-        aNull: { type: 'string', format: 'null', nullable: true },
+        aNull: { type: 'null' },
         aVoid: {},
       },
       required: ['aNull'],
@@ -239,7 +239,7 @@
         aArrayNonempty: {
           type: 'array',
           minItems: 1,
-          items: { type: 'string', format: 'null', nullable: true },
+          items: { type: 'null' },
         },
         aArrayMinAndMax: {
           type: 'array',
@@ -624,9 +624,9 @@
         literals: {
           type: 'object',
           properties: {
-            wordOne: { nullable: true, type: 'string', enum: ['One'] },
+            wordOne: { type: ['string', 'null'], enum: ['One'] },
             numberTwo: { type: 'number', enum: [2] },
-            isThisTheEnd: { nullable: true, type: 'boolean', enum: [false] },
+            isThisTheEnd: { type: ['boolean', 'null'], enum: [false] },
           },
           required: ['wordOne'],
         },
@@ -730,7 +730,7 @@
           oneOf: [{ type: 'string' }, { type: 'string' }],
           description: 'Odd pattern here',
         },
-        aNullish: { nullable: true, type: 'string' },
+        aNullish: { type: ['string', 'null'] },
         stringLengthOutput: { type: 'number' },
         favourites: {
           type: 'object',
@@ -961,6 +961,42 @@
       maximum: 10,
     } satisfies SchemaObject);
   });
+
+
+  it('should work with ZodTransform and correctly set nullable and optional', () => {
+    type Type = string;
+    const schema = z.object({
+      item: extendApi(
+        z.custom<Type>((data) => true),
+        generateSchema(z.string().nullable())
+      ),
+    });
+    expect(generateSchema(schema)).toEqual({
+      properties: {
+        item: {
+          type: ['string', 'null'],
+        },
+      },
+      type: 'object',
+    });
+    const schema2 = z.object({
+      item: extendApi(
+        z.custom<Type>((data) => !!data),
+        generateSchema(z.string())
+      ),
+    });
+    expect(generateSchema(schema2)).toEqual({
+      properties: {
+        item: {
+          type: 'string',
+        },
+      },
+      required: ['item'],
+      type: 'object',
+    });
+
+  });
+
   test('should work with ZodReadonly', () => {
     expect(generateSchema(z.object({ field: z.string() })))
       .toMatchInlineSnapshot(`
@@ -991,5 +1027,6 @@
         "type": "object",
       }
     `);
+
   });
 });

packages/zod-openapi/src/lib/zod-openapi.ts

@@ -299,29 +299,38 @@ function parseDate({ zodRef, schemas }: ParsingArgs<z.ZodDate>): SchemaObject {
 function parseNull({ zodRef, schemas }: ParsingArgs<z.ZodNull>): SchemaObject {
   return merge(
     {
-      type: 'string' as SchemaObjectType,
-      format: 'null',
-      nullable: true,
+      type: 'null' as SchemaObjectType,
     },
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
 
-function parseOptionalNullable({
+function parseOptional({
   schemas,
   zodRef,
   useOutput,
-}: ParsingArgs<
-  z.ZodOptional<OpenApiZodAny> | z.ZodNullable<OpenApiZodAny>
->): SchemaObject {
+}: ParsingArgs<z.ZodOptional<OpenApiZodAny>>): SchemaObject {
   return merge(
     generateSchema(zodRef.unwrap(), useOutput),
     zodRef.description ? { description: zodRef.description } : {},
     ...schemas
   );
 }
 
+function parseNullable({
+  schemas,
+  zodRef,
+  useOutput,
+}: ParsingArgs<z.ZodNullable<OpenApiZodAny>>): SchemaObject {
+  const schema = generateSchema(zodRef.unwrap(), useOutput);
+  return merge(
+    { ...schema, type: [schema.type, 'null'] as SchemaObjectType[] },
+    zodRef.description ? { description: zodRef.description } : {},
+    ...schemas
+  );
+}
+
 function parseDefault({
   schemas,
   zodRef,
@@ -542,8 +551,8 @@ const workerMap = {
   ZodBoolean: parseBoolean,
   ZodDate: parseDate,
   ZodNull: parseNull,
-  ZodOptional: parseOptionalNullable,
-  ZodNullable: parseOptionalNullable,
+  ZodOptional: parseOptional,
+  ZodNullable: parseNullable,
   ZodDefault: parseDefault,
   ZodArray: parseArray,
   ZodLiteral: parseLiteral,
@@ -577,11 +586,9 @@ export function generateSchema(
   useOutput?: boolean
 ): SchemaObject {
   const { metaOpenApi = {} } = zodRef;
-  const schemas = [
-    zodRef.isNullable && zodRef.isNullable() ? { nullable: true } : {},
+  const schemas: AnatineSchemaObject[] = [
     ...(Array.isArray(metaOpenApi) ? metaOpenApi : [metaOpenApi]),
   ];
-
   try {
     const typeName = zodRef._def.typeName as WorkerKeys;
     if (typeName in workerMap) {