zod-codegen 1.0.0

package/dist/src/http/fetch-client.js

@@ -0,0 +1,141 @@
+import { HttpError } from '../types/http.js';
+export class FetchHttpClient {
+    baseUrl;
+    defaultHeaders;
+    fetch;
+    Headers;
+    constructor(baseUrl = '', defaultHeaders = {}) {
+        this.baseUrl = baseUrl;
+        this.defaultHeaders = defaultHeaders;
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        if (typeof globalThis.fetch === 'function' && globalThis.Headers) {
+            this.fetch = globalThis.fetch.bind(globalThis);
+            this.Headers = globalThis.Headers;
+            return;
+        }
+        if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+            this.fetch = window.fetch.bind(window);
+            this.Headers = window.Headers;
+            return;
+        }
+        throw new Error("Fetch API is not available. Please ensure you're running in a compatible environment or polyfill fetch.");
+    }
+    async request(config) {
+        const url = this.buildUrl(config.url, config.params);
+        const headers = this.buildHeaders(config.headers);
+        const body = this.buildBody(config.data, headers);
+        const controller = new AbortController();
+        const timeoutId = config.timeout
+            ? setTimeout(() => {
+                controller.abort();
+            }, config.timeout)
+            : undefined;
+        try {
+            const response = await this.fetch(url, {
+                method: config.method,
+                headers,
+                body,
+                signal: controller.signal,
+            });
+            const responseHeaders = this.extractHeaders(response.headers);
+            const data = await this.parseResponse(response);
+            if (!response.ok) {
+                throw new HttpError(`HTTP ${String(response.status)}: ${response.statusText}`, response.status, {
+                    data,
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: responseHeaders,
+                    url: response.url,
+                });
+            }
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: responseHeaders,
+                url: response.url,
+            };
+        }
+        catch (error) {
+            if (error instanceof HttpError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new HttpError('Request timeout', 408);
+                }
+                throw new HttpError(`Network error: ${error.message}`, 0);
+            }
+            throw new HttpError('Unknown network error', 0);
+        }
+        finally {
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+            }
+        }
+    }
+    buildUrl(path, params) {
+        const url = new URL(path, this.baseUrl || 'http://localhost');
+        if (params) {
+            Object.entries(params).forEach(([key, value]) => {
+                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+                if (value !== undefined && value !== null) {
+                    url.searchParams.set(key, String(value));
+                }
+            });
+        }
+        return url.toString();
+    }
+    buildHeaders(customHeaders) {
+        const headers = new this.Headers();
+        Object.entries(this.defaultHeaders).forEach(([key, value]) => {
+            headers.set(key, value);
+        });
+        if (customHeaders) {
+            Object.entries(customHeaders).forEach(([key, value]) => {
+                headers.set(key, value);
+            });
+        }
+        return headers;
+    }
+    buildBody(data, headers) {
+        if (!data) {
+            return null;
+        }
+        const contentType = headers?.get('content-type') ?? 'application/json';
+        if (contentType.includes('application/json')) {
+            if (!headers?.has('content-type')) {
+                headers?.set('content-type', 'application/json');
+            }
+            return JSON.stringify(data);
+        }
+        if (typeof data === 'string') {
+            return data;
+        }
+        return JSON.stringify(data);
+    }
+    extractHeaders(headers) {
+        const result = {};
+        headers.forEach((value, key) => {
+            result[key.toLowerCase()] = value;
+        });
+        return result;
+    }
+    async parseResponse(response) {
+        const contentType = response.headers.get('content-type') ?? '';
+        if (contentType.includes('application/json')) {
+            return (await response.json());
+        }
+        if (contentType.includes('text/')) {
+            return (await response.text());
+        }
+        try {
+            const text = await response.text();
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return text ? JSON.parse(text) : {};
+        }
+        catch {
+            return {};
+        }
+    }
+}

package/dist/src/interfaces/code-generator.js

@@ -0,0 +1 @@
+export {};

package/dist/src/interfaces/file-reader.js

@@ -0,0 +1 @@
+export {};

package/dist/src/polyfills/fetch.js

@@ -0,0 +1,18 @@
+export async function setupFetchPolyfill(options = {}) {
+    if (typeof fetch === 'function') {
+        return;
+    }
+    if (typeof window !== 'undefined' && typeof window.fetch === 'function') {
+        return;
+    }
+    if (options.enableNodejsPolyfill && typeof process !== 'undefined' && process.versions.node) {
+        try {
+            await import('undici');
+            return;
+        }
+        catch {
+            // Fall through to error
+        }
+    }
+    throw new Error('Fetch API is not available. ' + 'For Node.js environments, please install undici: npm install undici');
+}

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

@@ -0,0 +1,419 @@
+import jp from 'jsonpath';
+import * as ts from 'typescript';
+import { z } from 'zod';
+import { MethodSchema, Reference, SchemaProperties } from '../types/openapi.js';
+import { TypeScriptImportBuilderService } from './import-builder.service.js';
+import { TypeScriptTypeBuilderService } from './type-builder.service.js';
+export class TypeScriptCodeGeneratorService {
+    typeBuilder = new TypeScriptTypeBuilderService();
+    importBuilder = new TypeScriptImportBuilderService();
+    printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+    ZodAST = z.object({
+        type: z.enum(['string', 'number', 'boolean', 'object', 'array', 'unknown', 'record']),
+        args: z.array(z.unknown()).optional(),
+    });
+    generate(spec) {
+        const file = ts.createSourceFile('generated.ts', '', ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
+        const nodes = this.buildAST(spec);
+        return this.printer.printList(ts.ListFormat.MultiLine, ts.factory.createNodeArray(nodes), file);
+    }
+    buildSchema(schema, required = true) {
+        const safeCategorySchema = SchemaProperties.safeParse(schema);
+        if (safeCategorySchema.success) {
+            const safeCategory = safeCategorySchema.data;
+            if (safeCategory.anyOf && Array.isArray(safeCategory.anyOf) && safeCategory.anyOf.length > 0) {
+                return this.handleLogicalOperator('anyOf', safeCategory.anyOf, required);
+            }
+            if (safeCategory.oneOf && Array.isArray(safeCategory.oneOf) && safeCategory.oneOf.length > 0) {
+                return this.handleLogicalOperator('oneOf', safeCategory.oneOf, required);
+            }
+            if (safeCategory.allOf && Array.isArray(safeCategory.allOf) && safeCategory.allOf.length > 0) {
+                return this.handleLogicalOperator('allOf', safeCategory.allOf, required);
+            }
+            if (safeCategory.not) {
+                return this.handleLogicalOperator('not', [safeCategory.not], required);
+            }
+            return this.buildProperty(safeCategory, required);
+        }
+        throw safeCategorySchema.error;
+    }
+    buildAST(openapi) {
+        const imports = this.importBuilder.buildImports();
+        const schemas = this.buildSchemas(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,
+            this.createComment('Client class'),
+            clientClass,
+        ];
+    }
+    buildSchemas(openapi) {
+        const schemasEntries = Object.entries(openapi.components?.schemas ?? {});
+        const sortedSchemaNames = this.topologicalSort(Object.fromEntries(schemasEntries));
+        return sortedSchemaNames.reduce((schemaRegistered, name) => {
+            const schema = openapi.components?.schemas?.[name];
+            if (!schema)
+                return schemaRegistered;
+            const variableStatement = ts.factory.createVariableStatement([ts.factory.createToken(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier(this.typeBuilder.sanitizeIdentifier(name)), undefined, undefined, this.buildSchema(schema)),
+            ], ts.NodeFlags.Const));
+            return {
+                ...schemaRegistered,
+                [name]: variableStatement,
+            };
+        }, {});
+    }
+    buildClientClass(openapi, schemas) {
+        const clientName = this.generateClientName(openapi.info.title);
+        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.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));
+    }
+    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', 'unknown', ts.factory.createObjectLiteralExpression([], false), true),
+        ], ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+            ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('T'), undefined),
+        ]), ts.factory.createBlock([
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('url'), undefined, undefined, ts.factory.createTemplateExpression(ts.factory.createTemplateHead('', ''), [
+                    ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#baseUrl')), ts.factory.createTemplateMiddle('', '')),
+                    ts.factory.createTemplateSpan(ts.factory.createIdentifier('path'), ts.factory.createTemplateTail('', '')),
+                ])),
+            ], ts.NodeFlags.Const)),
+            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.createObjectLiteralExpression([
+                            ts.factory.createPropertyAssignment(ts.factory.createStringLiteral('Content-Type', true), ts.factory.createStringLiteral('application/json', true)),
+                        ], true)),
+                    ], true),
+                ]))),
+            ], ts.NodeFlags.Const)),
+            ts.factory.createIfStatement(ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('ok'))), ts.factory.createThrowStatement(ts.factory.createNewExpression(ts.factory.createIdentifier('Error'), undefined, [
+                ts.factory.createTemplateExpression(ts.factory.createTemplateHead('HTTP ', 'HTTP '), [
+                    ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('status')), ts.factory.createTemplateMiddle(': ', ': ')),
+                    ts.factory.createTemplateSpan(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('statusText')), ts.factory.createTemplateTail('', '')),
+                ]),
+            ])), undefined),
+            ts.factory.createReturnStatement(ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('response'), ts.factory.createIdentifier('json')), undefined, []))),
+        ], true));
+    }
+    buildClientMethods(openapi, schemas) {
+        return Object.entries(openapi.paths).reduce((endpoints, [path, pathItem]) => {
+            const methods = Object.entries(pathItem)
+                .filter(([method]) => ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'].includes(method))
+                .map(([method, methodSchema]) => {
+                const safeMethodSchema = MethodSchema.parse(methodSchema);
+                if (!safeMethodSchema.operationId) {
+                    return null;
+                }
+                return this.buildEndpointMethod(method, path, safeMethodSchema, schemas);
+            })
+                .filter((method) => method !== null);
+            return [...endpoints, ...methods];
+        }, []);
+    }
+    buildEndpointMethod(method, path, schema, schemas) {
+        const parameters = this.buildMethodParameters(schema, schemas);
+        const responseType = this.getResponseType(schema, schemas);
+        return ts.factory.createMethodDeclaration([ts.factory.createToken(ts.SyntaxKind.AsyncKeyword)], undefined, ts.factory.createIdentifier(String(schema.operationId)), undefined, undefined, parameters, responseType, ts.factory.createBlock([
+            ts.factory.createReturnStatement(ts.factory.createAwaitExpression(ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createThis(), ts.factory.createPrivateIdentifier('#makeRequest')), undefined, [
+                ts.factory.createStringLiteral(method.toUpperCase(), true),
+                ts.factory.createStringLiteral(path, true),
+            ]))),
+        ], true));
+    }
+    buildMethodParameters(schema, schemas) {
+        void schemas; // Mark as intentionally unused
+        const parameters = [];
+        if (schema.parameters) {
+            schema.parameters.forEach((param) => {
+                if (param.in === 'path' && param.required) {
+                    parameters.push(this.typeBuilder.createParameter(this.typeBuilder.sanitizeIdentifier(param.name), 'string', undefined, false));
+                }
+            });
+        }
+        parameters.push(this.typeBuilder.createParameter('_', 'unknown', undefined, true));
+        return parameters;
+    }
+    getResponseType(schema, schemas) {
+        void schemas; // Mark as intentionally unused
+        const response200 = schema.responses?.['200'];
+        if (!response200?.content?.['application/json']?.schema) {
+            return undefined;
+        }
+        return ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+        ]);
+    }
+    buildBaseUrlConstant(openapi) {
+        const baseUrl = openapi.servers?.[0]?.url;
+        if (!baseUrl) {
+            return [];
+        }
+        return [
+            ts.factory.createVariableStatement(undefined, ts.factory.createVariableDeclarationList([
+                ts.factory.createVariableDeclaration(ts.factory.createIdentifier('defaultBaseUrl'), undefined, undefined, ts.factory.createStringLiteral(baseUrl, true)),
+            ], ts.NodeFlags.Const)),
+        ];
+    }
+    generateClientName(title) {
+        return title
+            .split(/[^a-zA-Z0-9]/g)
+            .map((word) => this.typeBuilder.toPascalCase(word))
+            .join('');
+    }
+    createComment(text) {
+        const commentNode = ts.factory.createIdentifier('\n');
+        ts.addSyntheticTrailingComment(commentNode, ts.SyntaxKind.SingleLineCommentTrivia, ` ${text}`, true);
+        return ts.factory.createExpressionStatement(commentNode);
+    }
+    buildZodAST(input) {
+        const [initial, ...rest] = input;
+        const safeInitial = this.ZodAST.safeParse(initial);
+        const initialExpression = !safeInitial.success
+            ? ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier(this.ZodAST.shape.type.parse(initial))), undefined, [])
+            : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier(safeInitial.data.type)), undefined, (safeInitial.data.args ?? []));
+        return rest.reduce((expression, exp) => {
+            const safeExp = this.ZodAST.safeParse(exp);
+            return !safeExp.success
+                ? ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(expression, ts.factory.createIdentifier(typeof exp === 'string' ? exp : String(exp))), undefined, [])
+                : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(expression, ts.factory.createIdentifier(safeExp.data.type)), undefined, (safeExp.data.args ?? []));
+        }, initialExpression);
+    }
+    buildProperty(property, required = false) {
+        const safeProperty = SchemaProperties.safeParse(property);
+        if (!safeProperty.success) {
+            return this.buildZodAST(['unknown']);
+        }
+        const prop = safeProperty.data;
+        if (this.isReference(prop)) {
+            return this.buildFromReference(prop);
+        }
+        const methodsToApply = [];
+        if (prop.anyOf && Array.isArray(prop.anyOf) && prop.anyOf.length > 0) {
+            return this.handleLogicalOperator('anyOf', prop.anyOf, required);
+        }
+        if (prop.oneOf && Array.isArray(prop.oneOf) && prop.oneOf.length > 0) {
+            return this.handleLogicalOperator('oneOf', prop.oneOf, required);
+        }
+        if (prop.allOf && Array.isArray(prop.allOf) && prop.allOf.length > 0) {
+            return this.handleLogicalOperator('allOf', prop.allOf, required);
+        }
+        if (prop.not) {
+            return this.handleLogicalOperator('not', [prop.not], required);
+        }
+        switch (prop.type) {
+            case 'array':
+                return this.buildZodAST([
+                    {
+                        type: 'array',
+                        args: prop.items ? [this.buildProperty(prop.items, true)] : [],
+                    },
+                    ...(!required ? ['optional'] : []),
+                ]);
+            case 'object': {
+                const { properties = {}, required: propRequired = [] } = prop;
+                const propertiesEntries = Object.entries(properties);
+                if (propertiesEntries.length > 0) {
+                    return this.buildZodAST([
+                        {
+                            type: 'object',
+                            args: [
+                                ts.factory.createObjectLiteralExpression(propertiesEntries.map(([name, propValue]) => {
+                                    return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(name), this.buildProperty(propValue, propRequired.includes(name)));
+                                }), true),
+                            ],
+                        },
+                        ...(!required ? ['optional'] : []),
+                    ]);
+                }
+                return this.buildZodAST([
+                    {
+                        type: 'record',
+                        args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])],
+                    },
+                ]);
+            }
+            case 'integer':
+                methodsToApply.push('int');
+                return this.buildZodAST(['number', ...methodsToApply, ...(!required ? ['optional'] : [])]);
+            case 'number':
+                return this.buildZodAST(['number', ...(!required ? ['optional'] : [])]);
+            case 'string':
+                return this.buildZodAST(['string', ...(!required ? ['optional'] : [])]);
+            case 'boolean':
+                return this.buildZodAST(['boolean', ...(!required ? ['optional'] : [])]);
+            case 'unknown':
+            default:
+                return this.buildZodAST(['unknown', ...(!required ? ['optional'] : [])]);
+        }
+    }
+    handleLogicalOperator(operator, schemas, required) {
+        const logicalExpression = this.buildLogicalOperator(operator, schemas);
+        return required
+            ? logicalExpression
+            : ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(logicalExpression, ts.factory.createIdentifier('optional')), undefined, []);
+    }
+    buildLogicalOperator(operator, schemas) {
+        switch (operator) {
+            case 'anyOf':
+            case 'oneOf': {
+                const unionSchemas = schemas.map((schema) => this.buildSchemaFromLogicalOperator(schema));
+                return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('union')), undefined, [ts.factory.createArrayLiteralExpression(unionSchemas, false)]);
+            }
+            case 'allOf': {
+                if (schemas.length === 0) {
+                    throw new Error('allOf requires at least one schema');
+                }
+                const firstSchema = this.buildSchemaFromLogicalOperator(schemas[0]);
+                return schemas.slice(1).reduce((acc, schema) => {
+                    const schemaExpression = this.buildSchemaFromLogicalOperator(schema);
+                    return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('intersection')), undefined, [acc, schemaExpression]);
+                }, firstSchema);
+            }
+            case 'not': {
+                const notSchema = this.buildSchemaFromLogicalOperator(schemas[0]);
+                return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('z'), ts.factory.createIdentifier('any')), ts.factory.createIdentifier('refine')), undefined, [
+                    ts.factory.createArrowFunction(undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, 'val', undefined, undefined, undefined)], undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken), ts.factory.createPrefixUnaryExpression(ts.SyntaxKind.ExclamationToken, ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(notSchema, ts.factory.createIdentifier('safeParse')), undefined, [ts.factory.createIdentifier('val')]))),
+                    ts.factory.createObjectLiteralExpression([
+                        ts.factory.createPropertyAssignment(ts.factory.createIdentifier('message'), ts.factory.createStringLiteral('Value must not match the excluded schema')),
+                    ]),
+                ]);
+            }
+            default:
+                throw new Error(`Unsupported logical operator: ${String(operator)}`);
+        }
+    }
+    buildSchemaFromLogicalOperator(schema) {
+        if (this.isReference(schema)) {
+            return this.buildFromReference(schema);
+        }
+        const safeSchema = SchemaProperties.safeParse(schema);
+        if (safeSchema.success) {
+            return this.buildProperty(safeSchema.data, true);
+        }
+        return this.buildBasicTypeFromSchema(schema);
+    }
+    buildBasicTypeFromSchema(schema) {
+        if (typeof schema === 'object' && schema !== null && 'type' in schema) {
+            const schemaObj = schema;
+            switch (schemaObj.type) {
+                case 'string':
+                    return this.buildZodAST(['string']);
+                case 'number':
+                    return this.buildZodAST(['number']);
+                case 'integer':
+                    return this.buildZodAST(['number', 'int']);
+                case 'boolean':
+                    return this.buildZodAST(['boolean']);
+                case 'object':
+                    return this.buildObjectTypeFromSchema(schemaObj);
+                case 'array':
+                    return this.buildArrayTypeFromSchema(schemaObj);
+                default:
+                    return this.buildZodAST(['unknown']);
+            }
+        }
+        return this.buildZodAST(['unknown']);
+    }
+    buildObjectTypeFromSchema(schemaObj) {
+        const properties = Object.entries(schemaObj.properties ?? {});
+        if (properties.length > 0) {
+            return this.buildZodAST([
+                {
+                    type: 'object',
+                    args: [
+                        ts.factory.createObjectLiteralExpression(properties.map(([name, property]) => {
+                            return ts.factory.createPropertyAssignment(ts.factory.createIdentifier(name), this.buildSchemaFromLogicalOperator(property));
+                        }), true),
+                    ],
+                },
+            ]);
+        }
+        return this.buildZodAST([
+            {
+                type: 'record',
+                args: [this.buildZodAST(['string']), this.buildZodAST(['unknown'])],
+            },
+        ]);
+    }
+    buildArrayTypeFromSchema(schemaObj) {
+        if (schemaObj.items) {
+            return this.buildZodAST([
+                {
+                    type: 'array',
+                    args: [this.buildSchemaFromLogicalOperator(schemaObj.items)],
+                },
+            ]);
+        }
+        return this.buildZodAST(['array']);
+    }
+    isReference(reference) {
+        if (typeof reference === 'object' && reference !== null && '$ref' in reference) {
+            const ref = reference;
+            return typeof ref.$ref === 'string' && ref.$ref.length > 0;
+        }
+        return false;
+    }
+    buildFromReference(reference) {
+        const { $ref = '' } = Reference.parse(reference);
+        const refName = $ref.split('/').pop() ?? 'never';
+        return ts.factory.createIdentifier(this.typeBuilder.sanitizeIdentifier(refName));
+    }
+    topologicalSort(schemas) {
+        const visited = new Set();
+        const visiting = new Set();
+        const result = [];
+        const visit = (name) => {
+            if (visiting.has(name)) {
+                return;
+            }
+            if (visited.has(name)) {
+                return;
+            }
+            visiting.add(name);
+            const schema = schemas[name];
+            const dependencies = jp
+                .query(schema, '$..["$ref"]')
+                .filter((ref) => ref.startsWith('#/components/schemas/'))
+                .map((ref) => ref.replace('#/components/schemas/', ''));
+            for (const dep of dependencies) {
+                if (schemas[dep]) {
+                    visit(dep);
+                }
+            }
+            visiting.delete(name);
+            visited.add(name);
+            result.push(name);
+        };
+        for (const name of Object.keys(schemas)) {
+            if (!visited.has(name)) {
+                visit(name);
+            }
+        }
+        return result;
+    }
+}

package/dist/src/services/file-reader.service.js

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { load } from 'js-yaml';
+import { OpenApiSpec } from '../types/openapi.js';
+export class SyncFileReaderService {
+    readFile(path) {
+        return readFileSync(path, 'utf8');
+    }
+}
+export class OpenApiFileParserService {
+    parse(input) {
+        let parsedInput;
+        if (typeof input === 'string') {
+            try {
+                parsedInput = JSON.parse(input);
+            }
+            catch {
+                parsedInput = load(input);
+            }
+        }
+        else {
+            parsedInput = input;
+        }
+        return OpenApiSpec.parse(parsedInput);
+    }
+}

package/dist/src/services/file-writer.service.js

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+export class SyncFileWriterService {
+    name;
+    version;
+    inputPath;
+    constructor(name, version, inputPath) {
+        this.name = name;
+        this.version = version;
+        this.inputPath = inputPath;
+    }
+    writeFile(filePath, content) {
+        const generatedContent = [
+            '// THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.',
+            `// Built with ${this.name}@${this.version}`,
+            `// Latest edit: ${new Date().toUTCString()}`,
+            `// Source file: ${this.inputPath}`,
+            '/* eslint-disable */',
+            '// @ts-nocheck',
+            '',
+            content,
+        ].join('\n');
+        const dirPath = dirname(filePath);
+        if (!existsSync(dirPath)) {
+            mkdirSync(dirPath, { recursive: true });
+        }
+        writeFileSync(filePath, generatedContent);
+    }
+    resolveOutputPath(outputDir, fileName = 'type.ts') {
+        return resolve(outputDir, fileName);
+    }
+}