zod-codegen 1.1.0 → 1.1.1

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+## <small>1.1.1 (2025-11-13)</small>
+
+- Merge pull request #29 from julienandreu/feat/server-configuration-and-examples ([c598b5a](https://github.com/julienandreu/zod-codegen/commit/c598b5a)), closes [#29](https://github.com/julienandreu/zod-codegen/issues/29)
+- fix: clarify getBaseRequestOptions merging behavior ([13379fd](https://github.com/julienandreu/zod-codegen/commit/13379fd))
+- fix: use z.union with z.literal for numeric enums instead of z.enum ([5e0c7ea](https://github.com/julienandreu/zod-codegen/commit/5e0c7ea))
+
 ## 1.1.0 (2025-11-13)
 
 - Merge pull request #27 from julienandreu/docs/update-readme-reflect-changes ([3f6745e](https://github.com/julienandreu/zod-codegen/commit/3f6745e)), closes [#27](https://github.com/julienandreu/zod-codegen/issues/27)

package/EXAMPLES.md

@@ -405,10 +405,17 @@ The generated client uses a layered approach to request configuration:
 
 When a request is made, options are merged in this order (later values override earlier ones):
 
-1. **Base Options** from `getBaseRequestOptions()` (headers, signal, credentials, etc.)
-2. **Content-Type Header** (automatically set based on request body: `application/json` or `application/x-www-form-urlencoded`)
-3. **Request-Specific Headers** from `options.headers` parameter (if provided)
-4. **Method and Body** (always set by generated code, cannot be overridden)
+1. **Base Options** from `getBaseRequestOptions()` - All RequestInit options (headers, signal, credentials, mode, cache, etc.)
+2. **Content-Type Header** - Automatically set based on request body (`application/json` or `application/x-www-form-urlencoded`)
+3. **Request-Specific Headers** - From `options.headers` parameter (if provided)
+4. **Method and Body** - Always set by generated code (cannot be overridden)
+
+**Important**: `getBaseRequestOptions()` returns **base options that are merged with**, not replaced by, request-specific options. This means:
+
+- ✅ Base options like `mode`, `credentials`, `signal` are preserved
+- ✅ Headers are merged (base headers + Content-Type + request headers)
+- ✅ Request-specific headers override base headers
+- ✅ Method and body always come from the request (not from baseOptions)
 
 ### Type Safety
 
@@ -419,20 +426,39 @@ The `getBaseRequestOptions()` method returns `Partial<Omit<RequestInit, 'method'
 
 This ensures type safety while preventing accidental overrides of critical request properties.
 
-### Header Merging Details
+### Complete Options Merging Details
 
-Headers are merged using `Object.assign()` with this priority:
+The final fetch request uses `Object.assign()` to merge options:
 
 ```typescript
+// Headers are merged first:
 const finalHeaders = Object.assign(
   {}, // Start with empty object
   baseOptions.headers || {}, // 1. Base headers from getBaseRequestOptions()
   {'Content-Type': contentType}, // 2. Content-Type (may override base)
   options.headers || {}, // 3. Request-specific headers (highest priority)
 );
+
+// Then all options are merged:
+const finalOptions = Object.assign(
+  {}, // Start with empty object
+  baseOptions, // 1. All base options (mode, credentials, signal, cache, etc.)
+  {
+    // 2. Request-specific options (override base)
+    method, // Always from endpoint
+    headers: finalHeaders, // Merged headers
+    body, // Always from request data
+  },
+);
+
+fetch(url, finalOptions);
 ```
 
-**Important**: Always return `Record<string, string>` for headers in `getBaseRequestOptions()` for predictable merging behavior.
+**Important**:
+
+- Always return `Record<string, string>` for headers in `getBaseRequestOptions()` for predictable merging behavior
+- Base options (like `mode`, `credentials`, `signal`) are preserved unless explicitly overridden
+- Headers are merged, not replaced - base headers + Content-Type + request headers
 
 ### Request Flow
 

package/README.md

@@ -253,6 +253,8 @@ The generated client includes a protected `getBaseRequestOptions()` method that
 - **CORS**: `mode`, `credentials` for cross-origin requests
 - **Request Options**: `signal` (AbortController), `cache`, `redirect`, `referrer`, etc.
 
+**Important**: Options from `getBaseRequestOptions()` are **merged with** (not replaced by) request-specific options. Base options like `mode`, `credentials`, and `signal` are preserved, while headers are merged (base headers + Content-Type + request headers). See [EXAMPLES.md](EXAMPLES.md) for detailed merging behavior.
+
 #### Basic Authentication Example
 
 ```typescript

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

@@ -708,26 +708,45 @@ export class TypeScriptCodeGeneratorService {
         }
         // Handle enum
         if (prop['enum'] && Array.isArray(prop['enum']) && prop['enum'].length > 0) {
-            const enumValues = prop['enum'].map((val) => {
-                if (typeof val === 'string') {
-                    return ts.factory.createStringLiteral(val, true);
-                }
-                if (typeof val === 'number') {
-                    // Handle negative numbers correctly
-                    if (val < 0) {
-                        return ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(String(Math.abs(val))));
+            // Check if all enum values are strings (z.enum only works with strings)
+            const allStrings = prop['enum'].every((val) => typeof val === 'string');
+            if (allStrings) {
+                // Use z.enum() for string enums
+                const enumValues = prop['enum'].map((val) => ts.factory.createStringLiteral(val, true));
+                const enumExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('enum')), undefined, [ts.factory.createArrayLiteralExpression(enumValues, false)]);
+                return required
+                    ? enumExpression
+                    : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(enumExpression, ts.factory.createIdentifier('optional')), undefined, []);
+            }
+            else {
+                // Use z.union([z.literal(...), ...]) for numeric/boolean/mixed enums
+                const literalSchemas = prop['enum'].map((val) => {
+                    let literalValue;
+                    if (typeof val === 'string') {
+                        literalValue = ts.factory.createStringLiteral(val, true);
                     }
-                    return ts.factory.createNumericLiteral(String(val));
-                }
-                if (typeof val === 'boolean') {
-                    return val ? ts.factory.createTrue() : ts.factory.createFalse();
-                }
-                return ts.factory.createStringLiteral(String(val), true);
-            });
-            const enumExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('enum')), undefined, [ts.factory.createArrayLiteralExpression(enumValues, false)]);
-            return required
-                ? enumExpression
-                : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(enumExpression, ts.factory.createIdentifier('optional')), undefined, []);
+                    else if (typeof val === 'number') {
+                        // Handle negative numbers correctly
+                        if (val < 0) {
+                            literalValue = ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.MinusToken, ts.factory.createNumericLiteral(String(Math.abs(val))));
+                        }
+                        else {
+                            literalValue = ts.factory.createNumericLiteral(String(val));
+                        }
+                    }
+                    else if (typeof val === 'boolean') {
+                        literalValue = val ? ts.factory.createTrue() : ts.factory.createFalse();
+                    }
+                    else {
+                        literalValue = ts.factory.createStringLiteral(String(val), true);
+                    }
+                    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('literal')), undefined, [literalValue]);
+                });
+                const unionExpression = ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('union')), undefined, [ts.factory.createArrayLiteralExpression(literalSchemas, false)]);
+                return required
+                    ? unionExpression
+                    : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(unionExpression, ts.factory.createIdentifier('optional')), undefined, []);
+            }
         }
         switch (prop['type']) {
             case 'array': {

package/dist/tests/unit/code-generator.test.js

@@ -167,6 +167,77 @@ describe('TypeScriptCodeGeneratorService', () => {
             expect(code).toContain('inactive');
             expect(code).toContain('pending');
         });
+        it('should handle numeric enum types with z.union and z.literal', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        Status: {
+                            type: 'integer',
+                            enum: [-99, 0, 1, 2],
+                        },
+                        ExecutionMode: {
+                            type: 'integer',
+                            enum: [1, 2],
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            // Numeric enums should use z.union([z.literal(...), ...])
+            expect(code).toContain('z.union');
+            expect(code).toContain('z.literal');
+            expect(code).toContain('-99');
+            expect(code).toContain('0');
+            expect(code).toContain('1');
+            expect(code).toContain('2');
+            // Should not use z.enum for numeric enums
+            expect(code).not.toContain('Status: z.enum');
+            expect(code).not.toContain('ExecutionMode: z.enum');
+        });
+        it('should merge baseOptions with request-specific options in #makeRequest', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/test': {
+                        get: {
+                            operationId: 'testEndpoint',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: { type: 'string' },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            // Should call getBaseRequestOptions()
+            expect(code).toContain('getBaseRequestOptions()');
+            // Should merge headers: baseHeaders + Content-Type + request headers
+            expect(code).toContain('Object.assign');
+            expect(code).toContain('baseHeaders');
+            expect(code).toContain('Content-Type');
+            // Should merge all options: baseOptions + {method, headers, body}
+            expect(code).toMatch(/Object\.assign\s*\(\s*\{\s*\}\s*,\s*baseOptions/);
+            expect(code).toContain('method');
+            expect(code).toContain('headers');
+            expect(code).toContain('body');
+        });
         it('should handle array types', () => {
             const spec = {
                 openapi: '3.0.0',

package/package.json

@@ -100,5 +100,5 @@
     "release": "semantic-release",
     "release:dry": "semantic-release --dry-run"
   },
-  "version": "1.1.0"
+  "version": "1.1.1"
 }

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

@@ -1750,42 +1750,77 @@ export class TypeScriptCodeGeneratorService implements CodeGenerator, SchemaBuil
 
     // Handle enum
     if (prop['enum'] && Array.isArray(prop['enum']) && prop['enum'].length > 0) {
-      const enumValues = prop['enum'].map((val) => {
-        if (typeof val === 'string') {
-          return ts.factory.createStringLiteral(val, true);
-        }
-        if (typeof val === 'number') {
-          // Handle negative numbers correctly
-          if (val < 0) {
-            return ts.factory.createPrefixUnaryExpression(
-              ts.SyntaxKind.MinusToken,
-              ts.factory.createNumericLiteral(String(Math.abs(val))),
+      // Check if all enum values are strings (z.enum only works with strings)
+      const allStrings = prop['enum'].every((val) => typeof val === 'string');
+
+      if (allStrings) {
+        // Use z.enum() for string enums
+        const enumValues = prop['enum'].map((val) => ts.factory.createStringLiteral(val as string, true));
+        const enumExpression = ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createIdentifier('z'),
+            ts.factory.createIdentifier('enum'),
+          ),
+          undefined,
+          [ts.factory.createArrayLiteralExpression(enumValues, false)],
+        );
+
+        return required
+          ? enumExpression
+          : ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(enumExpression, ts.factory.createIdentifier('optional')),
+              undefined,
+              [],
             );
+      } else {
+        // Use z.union([z.literal(...), ...]) for numeric/boolean/mixed enums
+        const literalSchemas = prop['enum'].map((val) => {
+          let literalValue: ts.Expression;
+          if (typeof val === 'string') {
+            literalValue = ts.factory.createStringLiteral(val, true);
+          } else if (typeof val === 'number') {
+            // Handle negative numbers correctly
+            if (val < 0) {
+              literalValue = ts.factory.createPrefixUnaryExpression(
+                ts.SyntaxKind.MinusToken,
+                ts.factory.createNumericLiteral(String(Math.abs(val))),
+              );
+            } else {
+              literalValue = ts.factory.createNumericLiteral(String(val));
+            }
+          } else if (typeof val === 'boolean') {
+            literalValue = val ? ts.factory.createTrue() : ts.factory.createFalse();
+          } else {
+            literalValue = ts.factory.createStringLiteral(String(val), true);
           }
-          return ts.factory.createNumericLiteral(String(val));
-        }
-        if (typeof val === 'boolean') {
-          return val ? ts.factory.createTrue() : ts.factory.createFalse();
-        }
-        return ts.factory.createStringLiteral(String(val), true);
-      });
 
-      const enumExpression = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
-          ts.factory.createIdentifier('z'),
-          ts.factory.createIdentifier('enum'),
-        ),
-        undefined,
-        [ts.factory.createArrayLiteralExpression(enumValues, false)],
-      );
-
-      return required
-        ? enumExpression
-        : ts.factory.createCallExpression(
-            ts.factory.createPropertyAccessExpression(enumExpression, ts.factory.createIdentifier('optional')),
+          return ts.factory.createCallExpression(
+            ts.factory.createPropertyAccessExpression(
+              ts.factory.createIdentifier('z'),
+              ts.factory.createIdentifier('literal'),
+            ),
             undefined,
-            [],
+            [literalValue],
           );
+        });
+
+        const unionExpression = ts.factory.createCallExpression(
+          ts.factory.createPropertyAccessExpression(
+            ts.factory.createIdentifier('z'),
+            ts.factory.createIdentifier('union'),
+          ),
+          undefined,
+          [ts.factory.createArrayLiteralExpression(literalSchemas, false)],
+        );
+
+        return required
+          ? unionExpression
+          : ts.factory.createCallExpression(
+              ts.factory.createPropertyAccessExpression(unionExpression, ts.factory.createIdentifier('optional')),
+              undefined,
+              [],
+            );
+      }
     }
 
     switch (prop['type']) {

package/tests/unit/code-generator.test.ts

@@ -185,6 +185,84 @@ describe('TypeScriptCodeGeneratorService', () => {
       expect(code).toContain('pending');
     });
 
+    it('should handle numeric enum types with z.union and z.literal', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {},
+        components: {
+          schemas: {
+            Status: {
+              type: 'integer',
+              enum: [-99, 0, 1, 2],
+            },
+            ExecutionMode: {
+              type: 'integer',
+              enum: [1, 2],
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+      // Numeric enums should use z.union([z.literal(...), ...])
+      expect(code).toContain('z.union');
+      expect(code).toContain('z.literal');
+      expect(code).toContain('-99');
+      expect(code).toContain('0');
+      expect(code).toContain('1');
+      expect(code).toContain('2');
+      // Should not use z.enum for numeric enums
+      expect(code).not.toContain('Status: z.enum');
+      expect(code).not.toContain('ExecutionMode: z.enum');
+    });
+
+    it('should merge baseOptions with request-specific options in #makeRequest', () => {
+      const spec: OpenApiSpecType = {
+        openapi: '3.0.0',
+        info: {
+          title: 'Test API',
+          version: '1.0.0',
+        },
+        paths: {
+          '/test': {
+            get: {
+              operationId: 'testEndpoint',
+              responses: {
+                '200': {
+                  description: 'Success',
+                  content: {
+                    'application/json': {
+                      schema: {type: 'string'},
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+
+      const code = generator.generate(spec);
+
+      // Should call getBaseRequestOptions()
+      expect(code).toContain('getBaseRequestOptions()');
+
+      // Should merge headers: baseHeaders + Content-Type + request headers
+      expect(code).toContain('Object.assign');
+      expect(code).toContain('baseHeaders');
+      expect(code).toContain('Content-Type');
+
+      // Should merge all options: baseOptions + {method, headers, body}
+      expect(code).toMatch(/Object\.assign\s*\(\s*\{\s*\}\s*,\s*baseOptions/);
+      expect(code).toContain('method');
+      expect(code).toContain('headers');
+      expect(code).toContain('body');
+    });
+
     it('should handle array types', () => {
       const spec: OpenApiSpecType = {
         openapi: '3.0.0',