zod-codegen 1.0.2 → 1.1.0

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

@@ -40,14 +40,14 @@ export class TypeScriptCodeGeneratorService {
     buildAST(openapi) {
         const imports = this.importBuilder.buildImports();
         const schemas = this.buildSchemas(openapi);
+        const serverConfig = this.buildServerConfiguration(openapi);
         const clientClass = this.buildClientClass(openapi, schemas);
-        const baseUrlConstant = this.buildBaseUrlConstant(openapi);
         return [
             this.createComment('Imports'),
             ...imports,
             this.createComment('Components schemas'),
             ...Object.values(schemas),
-            ...baseUrlConstant,
+            ...serverConfig,
             this.createComment('Client class'),
             clientClass,
         ];
@@ -73,24 +73,54 @@ export class TypeScriptCodeGeneratorService {
         const methods = this.buildClientMethods(openapi, schemas);
         return ts.factory.createClassDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier(clientName), undefined, undefined, [
             this.typeBuilder.createProperty('#baseUrl', 'string', true),
-            this.buildConstructor(),
+            this.buildConstructor(openapi),
+            this.buildGetBaseRequestOptionsMethod(),
             this.buildHttpRequestMethod(),
             ...methods,
         ]);
     }
-    buildConstructor() {
-        return ts.factory.createConstructorDeclaration(undefined, [
-            this.typeBuilder.createParameter('baseUrl', 'string', ts.factory.createIdentifier('defaultBaseUrl')),
-            this.typeBuilder.createParameter('_', 'unknown', undefined, true),
-        ], ts.factory.createBlock([
-            ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('baseUrl'))),
-        ], true));
+    buildConstructor(openapi) {
+        const hasServers = openapi.servers && openapi.servers.length > 0;
+        if (hasServers) {
+            // Options-based constructor
+            return ts.factory.createConstructorDeclaration(undefined, [
+                ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('options'), undefined, ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('ClientOptions'), undefined), undefined),
+            ], ts.factory.createBlock([
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                    ts.factory.createVariableDeclaration(ts.factory.createIdentifier('resolvedUrl'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('baseUrl')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createNull()), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('baseUrl')), ts.factory.createToken(ts.SyntaxKind.ColonToken), ts.factory.createCallExpression(ts.factory.createIdentifier('resolveServerUrl'), undefined, [
+                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('serverIndex')),
+                        ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('serverVariables')),
+                    ]))),
+                ], ts.NodeFlags.Const)),
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('resolvedUrl'))),
+            ], true));
+        }
+        else {
+            // Fallback: simple baseUrl parameter
+            return ts.factory.createConstructorDeclaration(undefined, [
+                this.typeBuilder.createParameter('baseUrl', 'string', ts.factory.createStringLiteral('/', true)),
+                this.typeBuilder.createParameter('_', 'unknown', undefined, true),
+            ], ts.factory.createBlock([
+                ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createIdentifier('baseUrl'))),
+            ], true));
+        }
+    }
+    buildGetBaseRequestOptionsMethod() {
+        return ts.factory.createMethodDeclaration([ts.factory.createToken(ts.SyntaxKind.ProtectedKeyword)], undefined, ts.factory.createIdentifier('getBaseRequestOptions'), undefined, undefined, [], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Partial'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Omit'), [
+                ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('RequestInit'), undefined),
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('method', true)),
+                    ts.factory.createLiteralTypeNode(ts.factory.createStringLiteral('body', true)),
+                ]),
+            ]),
+        ]), ts.factory.createBlock([ts.factory.createReturnStatement(ts.factory.createObjectLiteralExpression([], false))], true));
     }
     buildHttpRequestMethod() {
         return ts.factory.createMethodDeclaration([ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)], undefined, ts.factory.createPrivateIdentifier('#makeRequest'), undefined, [this.typeBuilder.createGenericType('T')], [
             this.typeBuilder.createParameter('method', 'string'),
             this.typeBuilder.createParameter('path', 'string'),
-            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string}', ts.factory.createObjectLiteralExpression([], false), false),
+            this.typeBuilder.createParameter('options', '{params?: Record<string, string | number | boolean>; data?: unknown; contentType?: string; headers?: Record<string, string>}', ts.factory.createObjectLiteralExpression([], false), false),
         ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
             ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('T'), undefined),
         ]), ts.factory.createBlock([
@@ -132,11 +162,27 @@ export class TypeScriptCodeGeneratorService {
                     ts.factory.createIdentifier('baseUrl'),
                 ]), ts.factory.createIdentifier('toString')), undefined, []))),
             ], ts.NodeFlags.Const)),
-            // Build headers with dynamic Content-Type
+            // Get base request options (headers, signal, credentials, etc.)
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('headers'), undefined, undefined, ts.factory.createObjectLiteralExpression([
-                    ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('Content-Type', true), ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('contentType')), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createStringLiteral('application/x-www-form-urlencoded', true)), undefined, ts.factory.createStringLiteral('application/x-www-form-urlencoded', true), undefined, ts.factory.createStringLiteral('application/json', true))),
-                ], true)),
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseOptions'), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createIdentifier('getBaseRequestOptions')), undefined, [])),
+            ], ts.NodeFlags.Const)),
+            // Build Content-Type header
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('contentType'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('contentType')), ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken), ts.factory.createStringLiteral('application/x-www-form-urlencoded', true)), undefined, ts.factory.createStringLiteral('application/x-www-form-urlencoded', true), undefined, ts.factory.createStringLiteral('application/json', true))),
+            ], ts.NodeFlags.Const)),
+            // Merge headers: base headers, Content-Type, and request-specific headers
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('baseHeaders'), undefined, undefined, ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('baseOptions'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false))),
+            ], ts.NodeFlags.Const)),
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('headers'), undefined, undefined, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('assign')), undefined, [
+                    ts.factory.createObjectLiteralExpression([], false),
+                    ts.factory.createIdentifier('baseHeaders'),
+                    ts.factory.createObjectLiteralExpression([
+                        ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('Content-Type', true), ts.factory.createIdentifier('contentType')),
+                    ], false),
+                    ts.factory.createConditionalExpression(ts.factory.createBinaryExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), ts.factory.createToken(ts.SyntaxKind.ExclamationEqualsEqualsToken), ts.factory.createIdentifier('undefined')), undefined, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('headers')), undefined, ts.factory.createObjectLiteralExpression([], false)),
+                ])),
             ], ts.NodeFlags.Const)),
             // Build body with form-urlencoded support
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
@@ -168,15 +214,19 @@ export class TypeScriptCodeGeneratorService {
                     ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('options'), ts.factory.createIdentifier('data')),
                 ])), undefined, ts.factory.createNull())),
             ], ts.NodeFlags.Const)),
-            // Make fetch request
+            // Make fetch request: merge base options with method, headers, and body
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
                 ts.factory.createVariableDeclaration(ts.factory.createIdentifier('response'), undefined, undefined, ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createIdentifier('fetch'), undefined, [
                     ts.factory.createIdentifier('url'),
-                    ts.factory.createObjectLiteralExpression([
-                        ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier('method'), undefined),
-                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('headers'), ts.factory.createIdentifier('headers')),
-                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('body'), ts.factory.createIdentifier('body')),
-                    ], true),
+                    ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('assign')), undefined, [
+                        ts.factory.createObjectLiteralExpression([], false),
+                        ts.factory.createIdentifier('baseOptions'),
+                        ts.factory.createObjectLiteralExpression([
+                            ts.factory.createShorthandPropertyAssignment(ts.factory.createIdentifier('method'), undefined),
+                            ts.factory.createPropertyAssignment(ts.factory.createIdentifier('headers'), ts.factory.createIdentifier('headers')),
+                            ts.factory.createPropertyAssignment(ts.factory.createIdentifier('body'), ts.factory.createIdentifier('body')),
+                        ], false),
+                    ]),
                 ]))),
             ], ts.NodeFlags.Const)),
             // Check response status
@@ -462,16 +512,151 @@ export class TypeScriptCodeGeneratorService {
             ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(typeName), undefined),
         ]);
     }
-    buildBaseUrlConstant(openapi) {
-        const baseUrl = openapi.servers?.[0]?.url;
-        if (!baseUrl) {
+    buildServerConfiguration(openapi) {
+        const servers = openapi.servers;
+        if (!servers || servers.length === 0) {
             return [];
         }
-        return [
+        const statements = [];
+        // Build server configuration array
+        const serverConfigElements = servers.map((server) => {
+            const properties = [
+                ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true)),
+            ];
+            if (server.description) {
+                properties.push(ts.factory.createPropertyAssignment('description', ts.factory.createStringLiteral(server.description, true)));
+            }
+            if (server.variables && Object.keys(server.variables).length > 0) {
+                const variableProperties = Object.entries(server.variables).map(([varName, varDef]) => {
+                    const varProps = [
+                        ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true)),
+                    ];
+                    if (varDef.enum && varDef.enum.length > 0) {
+                        varProps.push(ts.factory.createPropertyAssignment('enum', ts.factory.createArrayLiteralExpression(varDef.enum.map((val) => ts.factory.createStringLiteral(val, true)), false)));
+                    }
+                    if (varDef.description) {
+                        varProps.push(ts.factory.createPropertyAssignment('description', ts.factory.createStringLiteral(varDef.description, true)));
+                    }
+                    return ts.factory.createPropertyAssignment(varName, ts.factory.createObjectLiteralExpression(varProps, true));
+                });
+                properties.push(ts.factory.createPropertyAssignment('variables', ts.factory.createObjectLiteralExpression(variableProperties, true)));
+            }
+            return ts.factory.createObjectLiteralExpression(properties, true);
+        });
+        // Export server configuration
+        statements.push(ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('serverConfigurations'), undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false)),
+        ], ts.NodeFlags.Const)));
+        // Export default base URL (first server with default variables)
+        const firstServer = servers[0];
+        const defaultBaseUrl = firstServer ? this.resolveServerUrl(firstServer, {}) : '/';
+        statements.push(ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultBaseUrl'), undefined, undefined, ts.factory.createStringLiteral(defaultBaseUrl, true)),
+        ], ts.NodeFlags.Const)));
+        // Build ClientOptions type
+        const optionProperties = [
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('baseUrl'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword)),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword)),
+            ts.factory.createPropertySignature(undefined, ts.factory.createIdentifier('serverVariables'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+            ])),
+        ];
+        statements.push(ts.factory.createTypeAliasDeclaration([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createIdentifier('ClientOptions'), undefined, ts.factory.createTypeLiteralNode(optionProperties)));
+        // Build resolveServerUrl helper function
+        statements.push(this.buildResolveServerUrlFunction(servers));
+        return statements;
+    }
+    resolveServerUrl(server, variables) {
+        let url = server.url;
+        if (server.variables) {
+            for (const [varName, varDef] of Object.entries(server.variables)) {
+                const value = variables[varName] ?? varDef.default;
+                url = url.replace(`{${varName}}`, value);
+            }
+        }
+        return url;
+    }
+    buildResolveServerUrlFunction(servers) {
+        // Build server configs array inline
+        const serverConfigElements = servers.map((server) => {
+            const properties = [
+                ts.factory.createPropertyAssignment('url', ts.factory.createStringLiteral(server.url, true)),
+            ];
+            if (server.variables && Object.keys(server.variables).length > 0) {
+                const variableProperties = Object.entries(server.variables).map(([varName, varDef]) => {
+                    const varProps = [
+                        ts.factory.createPropertyAssignment('default', ts.factory.createStringLiteral(varDef.default, true)),
+                    ];
+                    if (varDef.enum && varDef.enum.length > 0) {
+                        varProps.push(ts.factory.createPropertyAssignment('enum', ts.factory.createArrayLiteralExpression(varDef.enum.map((val) => ts.factory.createStringLiteral(val, true)), false)));
+                    }
+                    return ts.factory.createPropertyAssignment(varName, ts.factory.createObjectLiteralExpression(varProps, true));
+                });
+                properties.push(ts.factory.createPropertyAssignment('variables', ts.factory.createObjectLiteralExpression(variableProperties, true)));
+            }
+            return ts.factory.createObjectLiteralExpression(properties, true);
+        });
+        // Build function body - simplified version
+        const idx = ts.factory.createIdentifier('idx');
+        const configs = ts.factory.createIdentifier('configs');
+        const config = ts.factory.createIdentifier('config');
+        const url = ts.factory.createIdentifier('url');
+        const key = ts.factory.createIdentifier('key');
+        const value = ts.factory.createIdentifier('value');
+        const bodyStatements = [
+            // const configs = [...]
             ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
-                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultBaseUrl'), undefined, undefined, ts.factory.createStringLiteral(baseUrl, true)),
+                ts.factory.createVariableDeclaration(configs, undefined, undefined, ts.factory.createArrayLiteralExpression(serverConfigElements, false)),
             ], ts.NodeFlags.Const)),
+            // const idx = serverIndex ?? 0
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(idx, undefined, undefined, ts.factory.createBinaryExpression(ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken), ts.factory.createNumericLiteral('0'))),
+            ], ts.NodeFlags.Const)),
+            // if (idx < configs.length) { ... }
+            ts.factory.createIfStatement(ts.factory.createBinaryExpression(idx, ts.factory.createToken(ts.SyntaxKind.LessThanToken), ts.factory.createPropertyAccessExpression(configs, ts.factory.createIdentifier('length'))), ts.factory.createBlock([
+                // const config = configs[idx]
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                    ts.factory.createVariableDeclaration(config, undefined, undefined, ts.factory.createElementAccessExpression(configs, idx)),
+                ], ts.NodeFlags.Const)),
+                // let url = config.url
+                ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                    ts.factory.createVariableDeclaration(url, undefined, undefined, ts.factory.createPropertyAccessExpression(config, ts.factory.createIdentifier('url'))),
+                ], ts.NodeFlags.Let)),
+                // if (config.variables && serverVariables) { ... }
+                ts.factory.createIfStatement(ts.factory.createLogicalAnd(ts.factory.createPropertyAccessExpression(config, ts.factory.createIdentifier('variables')), ts.factory.createIdentifier('serverVariables')), ts.factory.createBlock([
+                    // for (const [key, value] of Object.entries(serverVariables)) { url = url.replace(...) }
+                    ts.factory.createForOfStatement(undefined, ts.factory.createVariableDeclarationList([
+                        ts.factory.createVariableDeclaration(ts.factory.createArrayBindingPattern([
+                            ts.factory.createBindingElement(undefined, undefined, key),
+                            ts.factory.createBindingElement(undefined, undefined, value),
+                        ]), undefined, undefined),
+                    ], ts.NodeFlags.Const), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('Object'), ts.factory.createIdentifier('entries')), undefined, [ts.factory.createIdentifier('serverVariables')]), ts.factory.createBlock([
+                        ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(url, ts.factory.createToken(ts.SyntaxKind.EqualsToken), ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(url, ts.factory.createIdentifier('replace')), undefined, [
+                            ts.factory.createNewExpression(ts.factory.createIdentifier('RegExp'), undefined, [
+                                ts.factory.createBinaryExpression(ts.factory.createBinaryExpression(ts.factory.createStringLiteral('\\{'), ts.factory.createToken(ts.SyntaxKind.PlusToken), key), ts.factory.createToken(ts.SyntaxKind.PlusToken), ts.factory.createStringLiteral('\\}')),
+                                ts.factory.createStringLiteral('g'),
+                            ]),
+                            value,
+                        ]))),
+                    ], true)),
+                ], true)),
+                // return url
+                ts.factory.createReturnStatement(url),
+            ], true)),
+            // return default (first server with defaults)
+            ts.factory.createReturnStatement(ts.factory.createStringLiteral(servers[0] ? this.resolveServerUrl(servers[0], {}) : '/', true)),
         ];
+        return ts.factory.createFunctionDeclaration(undefined, undefined, ts.factory.createIdentifier('resolveServerUrl'), undefined, [
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('serverIndex'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createUnionTypeNode([
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword),
+            ]), undefined),
+            ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier('serverVariables'), ts.factory.createToken(ts.SyntaxKind.QuestionToken), ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Record'), [
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+                ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword),
+            ]), ts.factory.createObjectLiteralExpression([], false)),
+        ], ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword), ts.factory.createBlock(bodyStatements, true));
     }
     generateClientName(title) {
         return title

package/dist/src/types/openapi.js

@@ -54,7 +54,7 @@ const ServerVariable = z.object({
     enum: z.array(z.string()).optional(),
 });
 const Server = z.object({
-    url: z.url(),
+    url: z.string(), // Allow templated URLs with {variables}
     description: z.string().optional(),
     variables: z.record(z.string(), ServerVariable).optional(),
 });

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

@@ -0,0 +1,219 @@
+import { describe, expect, it } from 'vitest';
+import { TypeScriptCodeGeneratorService } from '../../src/services/code-generator.service.js';
+describe('TypeScriptCodeGeneratorService', () => {
+    let generator;
+    beforeEach(() => {
+        generator = new TypeScriptCodeGeneratorService();
+    });
+    describe('generate', () => {
+        it('should generate code for a minimal OpenAPI spec', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+            };
+            const code = generator.generate(spec);
+            expect(code).toBeTruthy();
+            expect(typeof code).toBe('string');
+            expect(code).toMatch(/import\s*{\s*z\s*}\s*from\s*['"]zod['"]/);
+            expect(code).toContain('export class');
+        });
+        it('should generate schemas for component schemas', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        User: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'integer' },
+                                name: { type: 'string' },
+                            },
+                            required: ['id', 'name'],
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('export const User');
+            expect(code).toContain('z.object');
+            expect(code).toContain('z.number().int()');
+            expect(code).toContain('z.string()');
+        });
+        it('should generate client methods for paths', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {
+                    '/users': {
+                        get: {
+                            operationId: 'getUsers',
+                            responses: {
+                                '200': {
+                                    description: 'Success',
+                                    content: {
+                                        'application/json': {
+                                            schema: {
+                                                type: 'array',
+                                                items: { type: 'string' },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('async getUsers');
+            expect(code).toContain('#makeRequest');
+        });
+        it('should generate getBaseRequestOptions method', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('protected getBaseRequestOptions');
+            expect(code).toContain('Partial<Omit<RequestInit');
+        });
+        it('should handle servers configuration', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                servers: [{ url: 'https://api.example.com' }],
+                paths: {},
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('defaultBaseUrl');
+            expect(code).toContain('https://api.example.com');
+        });
+        it('should handle complex schemas with references', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        User: {
+                            type: 'object',
+                            properties: {
+                                id: { type: 'integer' },
+                                profile: { $ref: '#/components/schemas/Profile' },
+                            },
+                            required: ['id'],
+                        },
+                        Profile: {
+                            type: 'object',
+                            properties: {
+                                name: { type: 'string' },
+                                email: { type: 'string', format: 'email' },
+                            },
+                            required: ['name', 'email'],
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('export const User');
+            expect(code).toContain('export const Profile');
+            // Profile should be defined before User (topological sort)
+            const profileIndex = code.indexOf('Profile');
+            const userIndex = code.indexOf('User');
+            expect(profileIndex).toBeLessThan(userIndex);
+        });
+        it('should handle enum types', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        Status: {
+                            type: 'string',
+                            enum: ['active', 'inactive', 'pending'],
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.enum');
+            expect(code).toContain('active');
+            expect(code).toContain('inactive');
+            expect(code).toContain('pending');
+        });
+        it('should handle array types', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: {
+                    title: 'Test API',
+                    version: '1.0.0',
+                },
+                paths: {},
+                components: {
+                    schemas: {
+                        Tags: {
+                            type: 'array',
+                            items: { type: 'string' },
+                        },
+                    },
+                },
+            };
+            const code = generator.generate(spec);
+            expect(code).toContain('z.array');
+            expect(code).toContain('z.string()');
+        });
+    });
+    describe('buildSchema', () => {
+        it('should build schema for string type', () => {
+            const schema = { type: 'string' };
+            const result = generator.buildSchema(schema, true);
+            expect(result).toBeDefined();
+        });
+        it('should build schema for number type', () => {
+            const schema = { type: 'number' };
+            const result = generator.buildSchema(schema, true);
+            expect(result).toBeDefined();
+        });
+        it('should build schema for boolean type', () => {
+            const schema = { type: 'boolean' };
+            const result = generator.buildSchema(schema, true);
+            expect(result).toBeDefined();
+        });
+        it('should handle optional fields', () => {
+            const schema = { type: 'string' };
+            const result = generator.buildSchema(schema, false);
+            expect(result).toBeDefined();
+        });
+        it('should handle string formats', () => {
+            const schema = { type: 'string', format: 'email' };
+            const result = generator.buildSchema(schema, true);
+            expect(result).toBeDefined();
+        });
+    });
+});

package/dist/tests/unit/file-reader.test.js

@@ -0,0 +1,110 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { SyncFileReaderService, OpenApiFileParserService } from '../../src/services/file-reader.service.js';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+describe('SyncFileReaderService', () => {
+    let reader;
+    beforeEach(() => {
+        reader = new SyncFileReaderService();
+    });
+    describe('readFile', () => {
+        it('should read local JSON files', async () => {
+            const content = await reader.readFile(join(__dirname, '../../samples/openapi.json'));
+            expect(content).toBeTruthy();
+            expect(typeof content).toBe('string');
+        });
+        it('should read local YAML files', async () => {
+            const content = await reader.readFile(join(__dirname, '../../samples/swagger-petstore.yaml'));
+            expect(content).toBeTruthy();
+            expect(typeof content).toBe('string');
+            expect(content).toContain('openapi:');
+        });
+        it('should handle non-existent files', async () => {
+            await expect(reader.readFile('./non-existent-file.json')).rejects.toThrow();
+        });
+        it('should handle URLs', async () => {
+            // Mock fetch for URL test
+            const originalFetch = global.fetch;
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                text: async () => '{"openapi": "3.0.0", "info": {"title": "Test", "version": "1.0.0"}, "paths": {}}',
+            });
+            const content = await reader.readFile('https://example.com/openapi.json');
+            expect(content).toBeTruthy();
+            global.fetch = originalFetch;
+        });
+        it('should handle URL fetch errors with non-ok responses', async () => {
+            const originalFetch = global.fetch;
+            const mockFetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 404,
+                statusText: 'Not Found',
+            });
+            global.fetch = mockFetch;
+            await expect(reader.readFile('https://example.com/not-found.json')).rejects.toThrow();
+            // Verify fetch was called
+            expect(mockFetch).toHaveBeenCalledWith('https://example.com/not-found.json');
+            global.fetch = originalFetch;
+        });
+    });
+});
+describe('OpenApiFileParserService', () => {
+    let parser;
+    beforeEach(() => {
+        parser = new OpenApiFileParserService();
+    });
+    describe('parse', () => {
+        it('should parse valid JSON OpenAPI spec', () => {
+            const jsonSpec = JSON.stringify({
+                openapi: '3.0.0',
+                info: { title: 'Test API', version: '1.0.0' },
+                paths: {},
+            });
+            const result = parser.parse(jsonSpec);
+            expect(result).toBeDefined();
+            expect(result.openapi).toBe('3.0.0');
+            expect(result.info.title).toBe('Test API');
+        });
+        it('should parse valid YAML OpenAPI spec', () => {
+            const yamlSpec = `
+openapi: 3.0.0
+info:
+  title: Test API
+  version: 1.0.0
+paths: {}
+`;
+            const result = parser.parse(yamlSpec);
+            expect(result).toBeDefined();
+            expect(result.openapi).toBe('3.0.0');
+            expect(result.info.title).toBe('Test API');
+        });
+        it('should parse already parsed objects', () => {
+            const spec = {
+                openapi: '3.0.0',
+                info: { title: 'Test API', version: '1.0.0' },
+                paths: {},
+            };
+            const result = parser.parse(spec);
+            expect(result).toBeDefined();
+            expect(result.openapi).toBe('3.0.0');
+        });
+        it('should validate OpenAPI structure', () => {
+            const invalidSpec = {
+                openapi: '2.0.0', // Wrong version format
+                info: { title: 'Test API', version: '1.0.0' },
+                paths: {},
+            };
+            expect(() => parser.parse(invalidSpec)).toThrow();
+        });
+        it('should handle missing required fields', () => {
+            const invalidSpec = {
+                openapi: '3.0.0',
+                // Missing info
+                paths: {},
+            };
+            expect(() => parser.parse(invalidSpec)).toThrow();
+        });
+    });
+});