zod-codegen 1.2.1 → 1.2.2

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## <small>1.2.2 (2025-11-19)</small>
+
+- Merge pull request #35 from julienandreu/fix/generate-typescript-type-aliases ([b8d9250](https://github.com/julienandreu/zod-codegen/commit/b8d9250)), closes [#35](https://github.com/julienandreu/zod-codegen/issues/35)
+- fix: generate TypeScript type aliases alongside Zod schemas ([7032a69](https://github.com/julienandreu/zod-codegen/commit/7032a69))
+
 ## <small>1.2.1 (2025-11-19)</small>
 
 - Merge pull request #33 from julienandreu/fix/add-z-infer-to-response-types ([a14d81c](https://github.com/julienandreu/zod-codegen/commit/a14d81c)), closes [#33](https://github.com/julienandreu/zod-codegen/issues/33)

package/dist/src/services/code-generator.service.js

@@ -40,6 +40,7 @@ export class TypeScriptCodeGeneratorService {
     buildAST(openapi) {
         const imports = this.importBuilder.buildImports();
         const schemas = this.buildSchemas(openapi);
+        const schemaTypeAliases = this.buildSchemaTypeAliases(schemas);
         const serverConfig = this.buildServerConfiguration(openapi);
         const clientClass = this.buildClientClass(openapi, schemas);
         return [
@@ -47,6 +48,7 @@ export class TypeScriptCodeGeneratorService {
             ...imports,
             this.createComment('Components schemas'),
             ...Object.values(schemas),
+            ...schemaTypeAliases,
             ...serverConfig,
             this.createComment('Client class'),
             clientClass,
@@ -68,6 +70,12 @@ export class TypeScriptCodeGeneratorService {
             };
         }, {});
     }
+    buildSchemaTypeAliases(schemas) {
+        return Object.keys(schemas).map((name) => {
+            const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
+            return ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(sanitizedName), undefined, ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedName), undefined)]));
+        });
+    }
     buildClientClass(openapi, schemas) {
         const clientName = this.generateClientName(openapi.info.title);
         const methods = this.buildClientMethods(openapi, schemas);
@@ -516,36 +524,34 @@ export class TypeScriptCodeGeneratorService {
         }
         const responseSchema = response.content['application/json'].schema;
         const typeName = this.getSchemaTypeName(responseSchema, schemas);
-        const inferredType = this.wrapTypeWithZInfer(typeName, schemas);
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [inferredType]);
-    }
-    wrapTypeWithZInfer(typeName, schemas) {
-        // Primitive types and Record types don't need z.infer
-        const primitiveTypes = ['string', 'number', 'boolean', 'unknown'];
-        if (primitiveTypes.includes(typeName) || typeName.startsWith('Record<')) {
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
-        }
         // Handle array types like "Pet[]"
         if (typeName.endsWith('[]')) {
             const itemTypeName = typeName.slice(0, -2);
             const sanitizedItemTypeName = this.typeBuilder.sanitizeIdentifier(itemTypeName);
-            // Check if the item type is a custom schema
+            // Check if the item type is a custom schema (we have a type alias for it)
             if (schemas[sanitizedItemTypeName]) {
-                // Return z.infer<typeof ItemType>[]
-                const zInferType = ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)]);
-                return ts.factory.createArrayTypeNode(zInferType);
+                // Use the type alias directly (it already uses z.infer)
+                return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                    ts.factory.createArrayTypeNode(ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)),
+                ]);
             }
-            // If it's a primitive array, return as-is
-            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+            // If it's a primitive array, use the type name as-is
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+            ]);
         }
-        // Handle custom schema types
         const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+        // Check if it's a custom schema type (we have a type alias for it)
         if (schemas[sanitizedTypeName]) {
-            // Return z.infer<typeof TypeName>
-            return ts.factory.createTypeReferenceNode(ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')), [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedTypeName), undefined)]);
+            // Use the type name directly (we have a type alias that already uses z.infer)
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined),
+            ]);
         }
-        // Fallback: return as-is if we can't determine
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+        // For primitive types and Record types, use the type name directly
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+        ]);
     }
     buildServerConfiguration(openapi) {
         const servers = openapi.servers;

package/package.json

@@ -110,5 +110,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.2.1"
+  "version": "1.2.2"
 }

package/src/services/code-generator.service.ts

@@ -53,6 +53,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
   private buildAST(openapi: OpenApiSpecType): ts.Statement[] {
     const imports = this.importBuilder.buildImports();
     const schemas = this.buildSchemas(openapi);
+    const schemaTypeAliases = this.buildSchemaTypeAliases(schemas);
     const serverConfig = this.buildServerConfiguration(openapi);
     const clientClass = this.buildClientClass(openapi, schemas);
 
@@ -61,6 +62,7 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
       ...imports,
       this.createComment('Components schemas'),
       ...Object.values(schemas),
+      ...schemaTypeAliases,
       ...serverConfig,
       this.createComment('Client class'),
       clientClass,
@@ -97,6 +99,21 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     }, {});
   }
 
+  private buildSchemaTypeAliases(schemas: Record<string, ts.VariableStatement>): ts.TypeAliasDeclaration[] {
+    return Object.keys(schemas).map((name) => {
+      const sanitizedName = this.typeBuilder.sanitizeIdentifier(name);
+      return ts.factory.createTypeAliasDeclaration(
+        [ts.factory.createToken(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createIdentifier(sanitizedName),
+        undefined,
+        ts.factory.createTypeReferenceNode(
+          ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
+          [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedName), undefined)],
+        ),
+      );
+    });
+  }
+
   private buildClientClass(
     openapi: OpenApiSpecType,
     schemas: Record<string, ts.VariableStatement>,
@@ -1264,48 +1281,41 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
 
     const responseSchema = response.content['application/json'].schema;
     const typeName = this.getSchemaTypeName(responseSchema, schemas);
-    const inferredType = this.wrapTypeWithZInfer(typeName, schemas);
-
-    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [inferredType]);
-  }
-
-  private wrapTypeWithZInfer(typeName: string, schemas: Record<string, ts.VariableStatement>): ts.TypeNode {
-    // Primitive types and Record types don't need z.infer
-    const primitiveTypes = ['string', 'number', 'boolean', 'unknown'];
-    if (primitiveTypes.includes(typeName) || typeName.startsWith('Record<')) {
-      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
-    }
 
     // Handle array types like "Pet[]"
     if (typeName.endsWith('[]')) {
       const itemTypeName = typeName.slice(0, -2);
       const sanitizedItemTypeName = this.typeBuilder.sanitizeIdentifier(itemTypeName);
 
-      // Check if the item type is a custom schema
+      // Check if the item type is a custom schema (we have a type alias for it)
       if (schemas[sanitizedItemTypeName]) {
-        // Return z.infer<typeof ItemType>[]
-        const zInferType = ts.factory.createTypeReferenceNode(
-          ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
-          [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined)],
-        );
-        return ts.factory.createArrayTypeNode(zInferType);
+        // Use the type alias directly (it already uses z.infer)
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+          ts.factory.createArrayTypeNode(
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedItemTypeName), undefined),
+          ),
+        ]);
       }
-      // If it's a primitive array, return as-is
-      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+      // If it's a primitive array, use the type name as-is
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+      ]);
     }
 
-    // Handle custom schema types
     const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+
+    // Check if it's a custom schema type (we have a type alias for it)
     if (schemas[sanitizedTypeName]) {
-      // Return z.infer<typeof TypeName>
-      return ts.factory.createTypeReferenceNode(
-        ts.factory.createQualifiedName(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('infer')),
-        [ts.factory.createTypeQueryNode(ts.factory.createIdentifier(sanitizedTypeName), undefined)],
-      );
+      // Use the type name directly (we have a type alias that already uses z.infer)
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(sanitizedTypeName), undefined),
+      ]);
     }
 
-    // Fallback: return as-is if we can't determine
-    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+    // For primitive types and Record types, use the type name directly
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+      ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+    ]);
   }
 
   private buildServerConfiguration(openapi: OpenApiSpecType): ts.Statement[] {