fix: zod: generate patterns and improve plain schemas

.changeset/eight-phones-applaud.md

@@ -0,0 +1,5 @@
+---
+'@hey-api/openapi-ts': patch
+---
+
+fix: zod: generate patterns and improve plain schemas

packages/openapi-ts/src/compiler/index.ts

@@ -49,6 +49,7 @@ export const compiler = {
   propertyAccessExpression: types.createPropertyAccessExpression,
   propertyAccessExpressions: transform.createPropertyAccessExpressions,
   propertyAssignment: types.createPropertyAssignment,
+  regularExpressionLiteral: types.createRegularExpressionLiteral,
   returnFunctionCall: _return.createReturnFunctionCall,
   returnStatement: _return.createReturnStatement,
   returnVariable: _return.createReturnVariable,

packages/openapi-ts/src/compiler/types.ts

@@ -894,3 +894,11 @@ export const createPropertyAssignment = ({
   initializer: ts.Expression;
   name: string | ts.PropertyName;
 }) => ts.factory.createPropertyAssignment(name, initializer);
+
+export const createRegularExpressionLiteral = ({
+  flags = [],
+  text,
+}: {
+  flags?: ReadonlyArray<'g' | 'i' | 'm' | 's' | 'u' | 'y'>;
+  text: string;
+}) => ts.factory.createRegularExpressionLiteral(`/${text}/${flags.join('')}`);

packages/openapi-ts/src/ir/types.d.ts

@@ -133,6 +133,7 @@ interface IRSchemaObject
     | 'minimum'
     | 'minItems'
     | 'minLength'
+    | 'pattern'
     | 'required'
     | 'title'
   > {

packages/openapi-ts/src/openApi/3.0.x/parser/schema.ts

@@ -103,6 +103,10 @@ const parseSchemaMeta = ({
     irSchema.minLength = schema.minLength;
   }
 
+  if (schema.pattern) {
+    irSchema.pattern = schema.pattern;
+  }
+
   if (schema.readOnly) {
     irSchema.accessScope = 'read';
   } else if (schema.writeOnly) {
@@ -666,6 +670,12 @@ const parseNullableType = ({
     schema,
   });
 
+  if (typeIrSchema.default === null) {
+    // clear to avoid duplicate default inside the non-null schema.
+    // this would produce incorrect validator output
+    delete typeIrSchema.default;
+  }
+
   const schemaItems: Array<IR.SchemaObject> = [
     parseOneType({
       context,

packages/openapi-ts/src/openApi/3.1.x/parser/schema.ts

@@ -133,6 +133,10 @@ const parseSchemaMeta = ({
     irSchema.minLength = schema.minLength;
   }
 
+  if (schema.pattern) {
+    irSchema.pattern = schema.pattern;
+  }
+
   if (schema.readOnly) {
     irSchema.accessScope = 'read';
   } else if (schema.writeOnly) {
@@ -772,6 +776,12 @@ const parseManyTypes = ({
     schema,
   });
 
+  if (schema.type.includes('null') && typeIrSchema.default === null) {
+    // clear to avoid duplicate default inside the non-null schema.
+    // this would produce incorrect validator output
+    delete typeIrSchema.default;
+  }
+
   const schemaItems: Array<IR.SchemaObject> = [];
 
   for (const type of schema.type) {

packages/openapi-ts/src/plugins/zod/plugin.ts

@@ -25,9 +25,13 @@ export const zodId = 'zod';
 const defaultIdentifier = compiler.identifier({ text: 'default' });
 const intersectionIdentifier = compiler.identifier({ text: 'intersection' });
 const lazyIdentifier = compiler.identifier({ text: 'lazy' });
+const lengthIdentifier = compiler.identifier({ text: 'length' });
+const maxIdentifier = compiler.identifier({ text: 'max' });
 const mergeIdentifier = compiler.identifier({ text: 'merge' });
+const minIdentifier = compiler.identifier({ text: 'min' });
 const optionalIdentifier = compiler.identifier({ text: 'optional' });
 const readonlyIdentifier = compiler.identifier({ text: 'readonly' });
+const regexIdentifier = compiler.identifier({ text: 'regex' });
 const unionIdentifier = compiler.identifier({ text: 'union' });
 const zIdentifier = compiler.identifier({ text: 'z' });
 
@@ -107,7 +111,7 @@ const arrayTypeToZodSchema = ({
     arrayExpression = compiler.callExpression({
       functionName: compiler.propertyAccessExpression({
         expression: arrayExpression,
-        name: compiler.identifier({ text: 'length' }),
+        name: lengthIdentifier,
       }),
       parameters: [compiler.valueToExpression({ value: schema.minItems })],
     });
@@ -116,7 +120,7 @@ const arrayTypeToZodSchema = ({
       arrayExpression = compiler.callExpression({
         functionName: compiler.propertyAccessExpression({
           expression: arrayExpression,
-          name: compiler.identifier({ text: 'min' }),
+          name: minIdentifier,
         }),
         parameters: [compiler.valueToExpression({ value: schema.minItems })],
       });
@@ -126,7 +130,7 @@ const arrayTypeToZodSchema = ({
       arrayExpression = compiler.callExpression({
         functionName: compiler.propertyAccessExpression({
           expression: arrayExpression,
-          name: compiler.identifier({ text: 'max' }),
+          name: maxIdentifier,
         }),
         parameters: [compiler.valueToExpression({ value: schema.maxItems })],
       });
@@ -317,45 +321,13 @@ const objectTypeToZodSchema = ({
     const property = schema.properties[name]!;
     const isRequired = required.includes(name);
 
-    let propertyExpression = schemaToZodSchema({
+    const propertyExpression = schemaToZodSchema({
       context,
+      optional: !isRequired,
       result,
       schema: property,
     });
 
-    if (property.accessScope === 'read') {
-      propertyExpression = compiler.callExpression({
-        functionName: compiler.propertyAccessExpression({
-          expression: propertyExpression,
-          name: readonlyIdentifier,
-        }),
-      });
-    }
-
-    if (!isRequired) {
-      propertyExpression = compiler.callExpression({
-        functionName: compiler.propertyAccessExpression({
-          expression: propertyExpression,
-          name: optionalIdentifier,
-        }),
-      });
-    }
-
-    if (property.default !== undefined) {
-      const callParameter = compiler.valueToExpression({
-        value: property.default,
-      });
-      if (callParameter) {
-        propertyExpression = compiler.callExpression({
-          functionName: compiler.propertyAccessExpression({
-            expression: propertyExpression,
-            name: defaultIdentifier,
-          }),
-          parameters: [callParameter],
-        });
-      }
-    }
-
     digitsRegExp.lastIndex = 0;
     let propertyName = digitsRegExp.test(name)
       ? ts.factory.createNumericLiteral(name)
@@ -493,7 +465,7 @@ const stringTypeToZodSchema = ({
     stringExpression = compiler.callExpression({
       functionName: compiler.propertyAccessExpression({
         expression: stringExpression,
-        name: compiler.identifier({ text: 'length' }),
+        name: lengthIdentifier,
       }),
       parameters: [compiler.valueToExpression({ value: schema.minLength })],
     });
@@ -502,7 +474,7 @@ const stringTypeToZodSchema = ({
       stringExpression = compiler.callExpression({
         functionName: compiler.propertyAccessExpression({
           expression: stringExpression,
-          name: compiler.identifier({ text: 'min' }),
+          name: minIdentifier,
         }),
         parameters: [compiler.valueToExpression({ value: schema.minLength })],
       });
@@ -512,13 +484,32 @@ const stringTypeToZodSchema = ({
       stringExpression = compiler.callExpression({
         functionName: compiler.propertyAccessExpression({
           expression: stringExpression,
-          name: compiler.identifier({ text: 'max' }),
+          name: maxIdentifier,
         }),
         parameters: [compiler.valueToExpression({ value: schema.maxLength })],
       });
     }
   }
 
+  if (schema.pattern) {
+    const text = schema.pattern
+      .replace(/\\/g, '\\\\') // backslashes
+      .replace(/\n/g, '\\n') // newlines
+      .replace(/\r/g, '\\r') // carriage returns
+      .replace(/\t/g, '\\t') // tabs
+      .replace(/\f/g, '\\f') // form feeds
+      .replace(/\v/g, '\\v') // vertical tabs
+      .replace(/'/g, "\\'") // single quotes
+      .replace(/"/g, '\\"'); // double quotes
+    stringExpression = compiler.callExpression({
+      functionName: compiler.propertyAccessExpression({
+        expression: stringExpression,
+        name: regexIdentifier,
+      }),
+      parameters: [compiler.regularExpressionLiteral({ text })],
+    });
+  }
+
   return stringExpression;
 };
 
@@ -680,6 +671,7 @@ const operationToZodSchema = ({
 const schemaToZodSchema = ({
   $ref,
   context,
+  optional,
   result,
   schema,
 }: {
@@ -688,6 +680,12 @@ const schemaToZodSchema = ({
    */
   $ref?: string;
   context: IR.Context;
+  /**
+   * Accept `optional` to handle optional object properties. We can't handle
+   * this inside the object function because `.optional()` must come before
+   * `.default()` which is handled in this function.
+   */
+  optional?: boolean;
   result: Result;
   schema: IR.SchemaObject;
 }): ts.Expression => {
@@ -841,6 +839,41 @@ const schemaToZodSchema = ({
     result.circularReferenceTracker.delete($ref);
   }
 
+  if (expression) {
+    if (schema.accessScope === 'read') {
+      expression = compiler.callExpression({
+        functionName: compiler.propertyAccessExpression({
+          expression,
+          name: readonlyIdentifier,
+        }),
+      });
+    }
+
+    if (optional) {
+      expression = compiler.callExpression({
+        functionName: compiler.propertyAccessExpression({
+          expression,
+          name: optionalIdentifier,
+        }),
+      });
+    }
+
+    if (schema.default !== undefined) {
+      const callParameter = compiler.valueToExpression({
+        value: schema.default,
+      });
+      if (callParameter) {
+        expression = compiler.callExpression({
+          functionName: compiler.propertyAccessExpression({
+            expression,
+            name: defaultIdentifier,
+          }),
+          parameters: [callParameter],
+        });
+      }
+    }
+  }
+
   // emit nodes only if $ref points to a reusable component
   if (identifier?.name) {
     const statement = compiler.constVariable({

packages/openapi-ts/test/3.0.x.test.ts

@@ -479,6 +479,14 @@ describe(`OpenAPI ${VERSION}`, () => {
       }),
       description: 'gracefully handles invalid type',
     },
+    {
+      config: createConfig({
+        input: 'validators.json',
+        output: 'validators',
+        plugins: ['zod'],
+      }),
+      description: 'generates Zod schemas',
+    },
   ];
 
   it.each(scenarios)('$description', async ({ config }) => {

packages/openapi-ts/test/3.1.x.test.ts

@@ -470,14 +470,6 @@ describe(`OpenAPI ${VERSION}`, () => {
       description:
         'does not set oneOf composition ref model properties as required',
     },
-    {
-      config: createConfig({
-        input: 'schema-recursive.json',
-        output: 'schema-recursive',
-        plugins: ['zod'],
-      }),
-      description: 'generates Zod schemas with from recursive schemas',
-    },
     {
       config: createConfig({
         input: 'security-api-key.json',
@@ -548,6 +540,14 @@ describe(`OpenAPI ${VERSION}`, () => {
       }),
       description: 'gracefully handles invalid type',
     },
+    {
+      config: createConfig({
+        input: 'validators.json',
+        output: 'validators',
+        plugins: ['zod'],
+      }),
+      description: 'generates Zod schemas',
+    },
   ];
 
   it.each(scenarios)('$description', async ({ config }) => {

packages/openapi-ts/test/__snapshots__/3.0.x/plugins/zod/default/zod.gen.ts

@@ -35,7 +35,7 @@ export const zSimpleReference = z.object({
 });
 
 export const zSimpleStringWithPattern = z.union([
-    z.string().max(64),
+    z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
     z.null()
 ]);
 
@@ -67,7 +67,7 @@ export const zArrayWithNumbers = z.array(z.number());
 
 export const zArrayWithBooleans = z.array(z.boolean());
 
-export const zArrayWithStrings = z.array(z.string());
+export const zArrayWithStrings = z.array(z.string()).default(['test']);
 
 export const zArrayWithReferences = z.array(z.object({
     prop: z.string().optional()
@@ -420,13 +420,13 @@ export const zModelWithNestedProperties = z.object({
             second: z.union([
                 z.object({
                     third: z.union([
-                        z.string(),
+                        z.string().readonly(),
                         z.null()
                     ]).readonly()
-                }),
+                }).readonly(),
                 z.null()
             ]).readonly()
-        }),
+        }).readonly(),
         z.null()
     ]).readonly()
 });
@@ -458,15 +458,15 @@ export const zModelThatExtendsExtends = zModelWithString.merge(zModelThatExtends
 }));
 
 export const zModelWithPattern = z.object({
-    key: z.string().max(64),
+    key: z.string().max(64).regex(/^[a-zA-Z0-9_]*$/),
     name: z.string().max(255),
     enabled: z.boolean().readonly().optional(),
     modified: z.string().datetime().readonly().optional(),
-    id: z.string().optional(),
-    text: z.string().optional(),
-    patternWithSingleQuotes: z.string().optional(),
-    patternWithNewline: z.string().optional(),
-    patternWithBacktick: z.string().optional()
+    id: z.string().regex(/^\\d{2}-\\d{3}-\\d{4}$/).optional(),
+    text: z.string().regex(/^\\w+$/).optional(),
+    patternWithSingleQuotes: z.string().regex(/^[a-zA-Z0-9\']*$/).optional(),
+    patternWithNewline: z.string().regex(/aaa\nbbb/).optional(),
+    patternWithBacktick: z.string().regex(/aaa`bbb/).optional()
 });
 
 export const zFile = z.object({
@@ -535,7 +535,7 @@ export const zNullableObject = z.union([
         foo: z.string().optional()
     }),
     z.null()
-]);
+]).default(null);
 
 export const zCharactersInDescription = z.string();