zod-codegen 1.2.0 → 1.2.1

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## <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

@@ -516,9 +516,36 @@ export class TypeScriptCodeGeneratorService {
         }
         const responseSchema = response.content['application/json'].schema;
         const typeName = this.getSchemaTypeName(responseSchema, schemas);
-        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
-            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
-        ]);
+        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
+            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);
+            }
+            // If it's a primitive array, return as-is
+            return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+        }
+        // Handle custom schema types
+        const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+        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)]);
+        }
+        // Fallback: return as-is if we can't determine
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
     }
     buildServerConfiguration(openapi) {
         const servers = openapi.servers;

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.1"
 }

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

@@ -1264,10 +1264,48 @@ 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'), [
-      ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
-    ]);
+    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
+      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);
+      }
+      // If it's a primitive array, return as-is
+      return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
+    }
+
+    // Handle custom schema types
+    const sanitizedTypeName = this.typeBuilder.sanitizeIdentifier(typeName);
+    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)],
+      );
+    }
+
+    // Fallback: return as-is if we can't determine
+    return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined);
   }
 
   private buildServerConfiguration(openapi: OpenApiSpecType): ts.Statement[] {