zod-codegen 1.2.0 → 1.2.2

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## <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)
+- fix: add z.infer to response types in generated methods ([c45ac77](https://github.com/julienandreu/zod-codegen/commit/c45ac77))
+
 ## 1.2.0 (2025-11-19)
 
 - Merge pull request #31 from julienandreu/dependabot/npm_and_yarn/dev-dependencies-1dd8918b9f ([97ebb65](https://github.com/julienandreu/zod-codegen/commit/97ebb65)), closes [#31](https://github.com/julienandreu/zod-codegen/issues/31)

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,6 +524,31 @@ export class TypeScriptCodeGeneratorService {
         }
         const responseSchema = response.content['application/json'].schema;
         const typeName = this.getSchemaTypeName(responseSchema, schemas);
+        // 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 (we have a type alias for it)
+            if (schemas[sanitizedItemTypeName]) {
+                // 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, use the type name as-is
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+            ]);
+        }
+        const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+        // Check if it's a custom schema type (we have a type alias for it)
+        if (schemas[sanitizedTypeName]) {
+            // 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),
+            ]);
+        }
+        // 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),
         ]);

package/examples/petstore/type.ts

@@ -1,6 +1,6 @@
 // THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
-// Built with zod-codegen@1.0.1
-// Latest edit: Thu, 13 Nov 2025 13:36:35 GMT
+// Built with zod-codegen@1.1.2
+// Latest edit: Wed, 19 Nov 2025 16:26:25 GMT
 // Source file: ./samples/swagger-petstore.yaml
 /* eslint-disable */
 // @ts-nocheck
@@ -144,73 +144,209 @@ export class SwaggerPetstoreOpenAPI30 {
     if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
     return await response.json();
   }
-  async addPet(body: Pet): Promise<Pet> {
+  /**
+   * Add a new pet to the store
+   * @param body Create a new pet in the store
+   * @returns {z.infer<typeof Pet>}
+   */
+  async addPet(body: Pet): Promise<z.infer<typeof Pet>> {
     return Pet.parse(
       await this.#makeRequest('POST', '/pet', {data: body, contentType: 'application/x-www-form-urlencoded'}),
     );
   }
-  async updatePet(body: Pet): Promise<Pet> {
+  /**
+   * Update an existing pet
+   *
+   * Update an existing pet by Id
+   * @param body Update an existent pet in the store
+   * @returns {z.infer<typeof Pet>}
+   */
+  async updatePet(body: Pet): Promise<z.infer<typeof Pet>> {
     return Pet.parse(
       await this.#makeRequest('PUT', '/pet', {data: body, contentType: 'application/x-www-form-urlencoded'}),
     );
   }
-  async findPetsByStatus(status?: string): Promise<Pet[]> {
+  /**
+   * Finds Pets by status
+   *
+   * Multiple status values can be provided with comma separated strings
+   *
+   * @param status Status values that need to be considered for filter
+   * @returns {z.infer<typeof Pet>[]}
+   */
+  async findPetsByStatus(status?: string): Promise<z.infer<typeof Pet>[]> {
     return await this.#makeRequest('GET', '/pet/findByStatus', {params: {status: status}});
   }
-  async findPetsByTags(tags?: string[]): Promise<Pet[]> {
+  /**
+   * Finds Pets by tags
+   *
+   * Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
+   *
+   * @param tags Tags to filter by
+   * @returns {z.infer<typeof Pet>[]}
+   */
+  async findPetsByTags(tags?: string[]): Promise<z.infer<typeof Pet>[]> {
     return await this.#makeRequest('GET', '/pet/findByTags', {params: {tags: tags}});
   }
-  async getPetById(petId: number): Promise<Pet> {
+  /**
+   * Find pet by ID
+   *
+   * Returns a single pet
+   *
+   * @param petId ID of pet to return
+   * @returns {z.infer<typeof Pet>}
+   */
+  async getPetById(petId: number): Promise<z.infer<typeof Pet>> {
     return Pet.parse(await this.#makeRequest('GET', `/pet/${petId}`, {}));
   }
+  /**
+   * Updates a pet in the store with form data
+   *
+   * @param petId ID of pet that needs to be updated
+   * @param name Name of pet that needs to be updated
+   * @param status Status of pet that needs to be updated
+   * @returns {void}
+   */
   async updatePetWithForm(petId: number, name?: string, status?: string): Promise<void> {
     return await this.#makeRequest('POST', `/pet/${petId}`, {params: {name: name, status: status}});
   }
+  /**
+   * Deletes a pet
+   *
+   * delete a pet
+   *
+   * @param api_key
+   * @param petId Pet id to delete
+   * @returns {void}
+   */
   async deletePet(petId: number): Promise<void> {
     return await this.#makeRequest('DELETE', `/pet/${petId}`, {});
   }
-  async uploadFile(petId: number, additionalMetadata?: string): Promise<ApiResponse> {
+  /**
+   * uploads an image
+   *
+   * @param petId ID of pet to update
+   * @param additionalMetadata Additional Metadata
+   * @param body
+   * @returns {z.infer<typeof ApiResponse>}
+   */
+  async uploadFile(petId: number, additionalMetadata?: string): Promise<z.infer<typeof ApiResponse>> {
     return ApiResponse.parse(
       await this.#makeRequest('POST', `/pet/${petId}/uploadImage`, {params: {additionalMetadata: additionalMetadata}}),
     );
   }
+  /**
+   * Returns pet inventories by status
+   *
+   * Returns a map of status codes to quantities
+   * @returns {Record<string, unknown>}
+   */
   async getInventory(): Promise<Record<string, unknown>> {
     return await this.#makeRequest('GET', '/store/inventory', {});
   }
-  async placeOrder(body?: Order): Promise<Order> {
+  /**
+   * Place an order for a pet
+   *
+   * Place a new order in the store
+   * @param body
+   * @returns {z.infer<typeof Order>}
+   */
+  async placeOrder(body?: Order): Promise<z.infer<typeof Order>> {
     return Order.parse(
       await this.#makeRequest('POST', '/store/order', {data: body, contentType: 'application/x-www-form-urlencoded'}),
     );
   }
-  async getOrderById(orderId: number): Promise<Order> {
+  /**
+   * Find purchase order by ID
+   *
+   * For valid response try integer IDs with value <= 5 or > 10. Other values will generate exceptions.
+   *
+   * @param orderId ID of order that needs to be fetched
+   * @returns {z.infer<typeof Order>}
+   */
+  async getOrderById(orderId: number): Promise<z.infer<typeof Order>> {
     return Order.parse(await this.#makeRequest('GET', `/store/order/${orderId}`, {}));
   }
+  /**
+   * Delete purchase order by ID
+   *
+   * For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
+   *
+   * @param orderId ID of the order that needs to be deleted
+   * @returns {void}
+   */
   async deleteOrder(orderId: number): Promise<void> {
     return await this.#makeRequest('DELETE', `/store/order/${orderId}`, {});
   }
-  async createUser(body?: User): Promise<User> {
+  /**
+   * Create user
+   *
+   * This can only be done by the logged in user.
+   * @param body Created user object
+   * @returns {z.infer<typeof User>}
+   */
+  async createUser(body?: User): Promise<z.infer<typeof User>> {
     return User.parse(
       await this.#makeRequest('POST', '/user', {data: body, contentType: 'application/x-www-form-urlencoded'}),
     );
   }
-  async createUsersWithListInput(body?: User[]): Promise<User> {
+  /**
+   * Creates list of users with given input array
+   * @param body
+   * @returns {z.infer<typeof User>}
+   */
+  async createUsersWithListInput(body?: User[]): Promise<z.infer<typeof User>> {
     return User.parse(await this.#makeRequest('POST', '/user/createWithList', {data: body}));
   }
+  /**
+   * Logs user into the system
+   *
+   * @param username The user name for login
+   * @param password The password for login in clear text
+   * @returns {string}
+   */
   async loginUser(username?: string, password?: string): Promise<string> {
     return await this.#makeRequest('GET', '/user/login', {params: {username: username, password: password}});
   }
+  /**
+   * Logs out current logged in user session
+   * @returns {void}
+   */
   async logoutUser(): Promise<void> {
     return await this.#makeRequest('GET', '/user/logout', {});
   }
-  async getUserByName(username: string): Promise<User> {
+  /**
+   * Get user by user name
+   *
+   * @param username The name that needs to be fetched. Use user1 for testing.
+   * @returns {z.infer<typeof User>}
+   */
+  async getUserByName(username: string): Promise<z.infer<typeof User>> {
     return User.parse(await this.#makeRequest('GET', `/user/${username}`, {}));
   }
+  /**
+   * Update user
+   *
+   * This can only be done by the logged in user.
+   *
+   * @param username name that need to be deleted
+   * @param body Update an existent user in the store
+   * @returns {void}
+   */
   async updateUser(username: string, body?: User): Promise<void> {
     return await this.#makeRequest('PUT', `/user/${username}`, {
       data: body,
       contentType: 'application/x-www-form-urlencoded',
     });
   }
+  /**
+   * Delete user
+   *
+   * This can only be done by the logged in user.
+   *
+   * @param username The name that needs to be deleted
+   * @returns {void}
+   */
   async deleteUser(username: string): Promise<void> {
     return await this.#makeRequest('DELETE', `/user/${username}`, {});
   }

package/package.json

@@ -110,5 +110,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.2.0"
+  "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>,
@@ -1265,6 +1282,37 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
     const responseSchema = response.content['application/json'].schema;
     const typeName = this.getSchemaTypeName(responseSchema, schemas);
 
+    // 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 (we have a type alias for it)
+      if (schemas[sanitizedItemTypeName]) {
+        // 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, use the type name as-is
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
+      ]);
+    }
+
+    const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+
+    // Check if it's a custom schema type (we have a type alias for it)
+    if (schemas[sanitizedTypeName]) {
+      // 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),
+      ]);
+    }
+
+    // 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),
     ]);