zod-codegen 1.0.0

package/dist/src/services/import-builder.service.js

@@ -0,0 +1,45 @@
+import * as ts from 'typescript';
+import { z } from 'zod';
+const IsTypeImport = z.boolean();
+const ImportedElement = z.record(z.string(), IsTypeImport);
+const ImportOptions = z.object({
+    defaultImport: ImportedElement.optional(),
+    namedImports: ImportedElement.optional(),
+});
+export class TypeScriptImportBuilderService {
+    buildImports() {
+        return [
+            this.createImport('zod', {
+                defaultImport: { z: false },
+            }),
+            this.createImport('path-to-regexp', {
+                namedImports: { compile: false },
+            }),
+        ];
+    }
+    createImport(target, options) {
+        const safeOptions = ImportOptions.parse(options);
+        const [defaultImport] = Object.entries(safeOptions.defaultImport ?? {})[0] ?? [undefined, false];
+        const { success: hasDefaultImport } = z.string().safeParse(defaultImport);
+        const safeNameImports = ImportedElement.safeParse(safeOptions.namedImports);
+        const namedImportList = safeNameImports.success ? Object.entries(safeNameImports.data) : [];
+        // Create import specifiers for named imports
+        const namedImports = namedImportList.length > 0
+            ? ts.factory.createNamedImports(namedImportList.map(([name, isTypeImport = false]) => {
+                return ts.factory.createImportSpecifier(isTypeImport, undefined, ts.factory.createIdentifier(name));
+            }))
+            : undefined;
+        // Check if we have any imports at all
+        const hasAnyImports = hasDefaultImport || namedImports;
+        // For side effects imports, we can pass undefined as the import clause
+        // For imports with bindings, we need to create the clause differently
+        return ts.factory.createImportDeclaration(undefined, hasAnyImports
+            ? {
+                kind: ts.SyntaxKind.ImportClause,
+                isTypeOnly: false,
+                name: hasDefaultImport && defaultImport ? ts.factory.createIdentifier(defaultImport) : undefined,
+                namedBindings: namedImports,
+            }
+            : undefined, ts.factory.createStringLiteral(target, true), undefined);
+    }
+}

package/dist/src/services/type-builder.service.js

@@ -0,0 +1,42 @@
+import * as ts from 'typescript';
+export class TypeScriptTypeBuilderService {
+    buildType(type) {
+        switch (type) {
+            case 'string':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.StringKeyword);
+            case 'number':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.NumberKeyword);
+            case 'boolean':
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
+            case 'unknown':
+            default:
+                return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+    }
+    createProperty(name, type, isReadonly = false) {
+        const createIdentifier = name.startsWith('#') ? 'createPrivateIdentifier' : 'createIdentifier';
+        return ts.factory.createPropertyDeclaration(isReadonly ? [ts.factory.createToken(ts.SyntaxKind.ReadonlyKeyword)] : undefined, ts.factory[createIdentifier](name), undefined, this.buildType(type), undefined);
+    }
+    createParameter(name, type, defaultValue, isOptional = false) {
+        return ts.factory.createParameterDeclaration(undefined, undefined, ts.factory.createIdentifier(this.sanitizeIdentifier(name)), isOptional ? ts.factory.createToken(ts.SyntaxKind.QuestionToken) : undefined, typeof type === 'string' ? this.buildType(type) : type, defaultValue);
+    }
+    createGenericType(name) {
+        return ts.factory.createTypeParameterDeclaration(undefined, ts.factory.createIdentifier(name), undefined, undefined);
+    }
+    sanitizeIdentifier(name) {
+        let sanitized = name.replace(/[^a-zA-Z0-9_]/g, '_');
+        if (/^[0-9]/.test(sanitized)) {
+            sanitized = '_' + sanitized;
+        }
+        if (sanitized.length === 0) {
+            sanitized = '_';
+        }
+        return sanitized;
+    }
+    toCamelCase(word) {
+        return word.charAt(0).toLowerCase() + word.slice(1);
+    }
+    toPascalCase(word) {
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    }
+}

package/dist/src/types/http.js

@@ -0,0 +1,10 @@
+export class HttpError extends Error {
+    status;
+    response;
+    constructor(message, status, response) {
+        super(message);
+        this.status = status;
+        this.response = response;
+        this.name = 'HttpError';
+    }
+}

package/dist/src/types/openapi.js

@@ -0,0 +1,173 @@
+import { z } from 'zod';
+export const Reference = z.object({
+    $ref: z.string().optional(),
+});
+const BaseSchemaProperties = z.object({
+    $ref: z.string().optional(),
+    title: z.string().optional(),
+    multipleOf: z.number().positive().optional(),
+    maximum: z.number().optional(),
+    exclusiveMaximum: z.boolean().optional(),
+    minimum: z.number().optional(),
+    exclusiveMinimum: z.boolean().optional(),
+    maxLength: z.number().int().nonnegative().optional(),
+    minLength: z.number().int().nonnegative().optional(),
+    pattern: z.string().optional(),
+    maxItems: z.number().int().nonnegative().optional(),
+    minItems: z.number().int().nonnegative().optional(),
+    uniqueItems: z.boolean().optional(),
+    maxProperties: z.number().int().nonnegative().optional(),
+    minProperties: z.number().int().nonnegative().optional(),
+    required: z.array(z.string()).optional(),
+    enum: z.array(z.unknown()).optional(),
+    type: z.string().optional(),
+    allOf: z.array(z.unknown()).optional(),
+    oneOf: z.array(z.unknown()).optional(),
+    anyOf: z.array(z.unknown()).optional(),
+    not: z.unknown().optional(),
+    additionalProperties: z.unknown().optional(),
+    description: z.string().optional(),
+    format: z.string().optional(),
+    default: z.unknown().optional(),
+    nullable: z.boolean().optional(),
+    discriminator: Reference.optional(),
+    readOnly: z.boolean().optional(),
+    writeOnly: z.boolean().optional(),
+    xml: z
+        .object({
+        name: z.string().optional(),
+        wrapped: z.boolean().optional(),
+    })
+        .optional(),
+    externalDocs: Reference.optional(),
+    example: z.unknown().optional(),
+    deprecated: z.boolean().optional(),
+});
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const SchemaProperties = z.lazy(() => BaseSchemaProperties.extend({
+    properties: z.record(z.string(), SchemaProperties).optional(),
+    items: SchemaProperties.optional(),
+}));
+const ServerVariable = z.object({
+    default: z.string(),
+    description: z.string().optional(),
+    enum: z.array(z.string()).optional(),
+});
+const Server = z.object({
+    url: z.string().url(),
+    description: z.string().optional(),
+    variables: z.record(z.string(), ServerVariable).optional(),
+});
+export const Parameter = z.object({
+    $ref: z.string().optional(),
+    name: z.string(),
+    in: z.enum(['query', 'header', 'path', 'cookie']),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    deprecated: z.boolean().optional(),
+    allowEmptyValue: z.boolean().optional(),
+    style: z.string().optional(),
+    explode: z.boolean().optional(),
+    allowReserved: z.boolean().optional(),
+    schema: SchemaProperties.optional(),
+});
+const ResponseHeader = z.object({
+    $ref: z.string().optional(),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    deprecated: z.boolean().optional(),
+    allowEmptyValue: z.boolean().optional(),
+    style: z.string().optional(),
+    explode: z.boolean().optional(),
+    allowReserved: z.boolean().optional(),
+    schema: Reference.optional(),
+});
+const MediaType = z.object({
+    schema: z.unknown().optional(),
+});
+export const Response = z.object({
+    $ref: z.string().optional(),
+    description: z.string(),
+    headers: z.record(z.string(), ResponseHeader).optional(),
+    content: z.record(z.string(), MediaType).optional(),
+});
+export const RequestBody = z.object({
+    $ref: z.string().optional(),
+    description: z.string().optional(),
+    required: z.boolean().optional(),
+    content: z.record(z.string(), MediaType).optional(),
+});
+export const MethodSchema = z.object({
+    summary: z.string().optional(),
+    description: z.string().optional(),
+    operationId: z.string().optional(),
+    parameters: z.array(Parameter).optional(),
+    requestBody: RequestBody.optional(),
+    responses: z.record(z.string(), Response).optional(),
+    tags: z.array(z.string()).optional(),
+    deprecated: z.boolean().optional(),
+});
+export const PathItem = z.object({
+    $ref: z.string().optional(),
+    summary: z.string().optional(),
+    description: z.string().optional(),
+    get: MethodSchema.optional(),
+    post: MethodSchema.optional(),
+    put: MethodSchema.optional(),
+    patch: MethodSchema.optional(),
+    delete: MethodSchema.optional(),
+    head: MethodSchema.optional(),
+    options: MethodSchema.optional(),
+    trace: MethodSchema.optional(),
+    parameters: z.array(Parameter).optional(),
+});
+const Info = z.object({
+    title: z.string().min(1),
+    version: z.string().min(1),
+    description: z.string().optional(),
+    termsOfService: z.string().url().optional(),
+    contact: z
+        .object({
+        name: z.string().optional(),
+        email: z.string().email().optional(),
+        url: z.string().url().optional(),
+    })
+        .optional(),
+    license: z
+        .object({
+        name: z.string().min(1),
+        url: z.string().url().optional(),
+    })
+        .optional(),
+});
+const SecurityRequirement = z.record(z.string(), z.array(z.string()));
+const Tag = z.object({
+    name: z.string().min(1),
+    description: z.string().optional(),
+    externalDocs: Reference.optional(),
+});
+const ExternalDocumentation = z.object({
+    description: z.string().optional(),
+    url: z.string().url(),
+});
+const Components = z.object({
+    schemas: z.record(z.string(), SchemaProperties).optional(),
+    responses: z.record(z.string(), Response).optional(),
+    parameters: z.record(z.string(), Parameter).optional(),
+    examples: z.record(z.string(), Reference).optional(),
+    requestBodies: z.record(z.string(), RequestBody).optional(),
+    headers: z.record(z.string(), ResponseHeader).optional(),
+    securitySchemes: z.record(z.string(), Reference).optional(),
+    links: z.record(z.string(), Reference).optional(),
+    callbacks: z.record(z.string(), Reference).optional(),
+});
+export const OpenApiSpec = z.object({
+    openapi: z.string().regex(/^3\.\d+\.\d+$/, 'OpenAPI version must be in format 3.x.x'),
+    info: Info,
+    servers: z.array(Server).optional(),
+    paths: z.record(z.string(), PathItem),
+    components: Components.optional(),
+    security: z.array(SecurityRequirement).optional(),
+    tags: z.array(Tag).optional(),
+    externalDocs: ExternalDocumentation.optional(),
+});

package/dist/src/utils/error-handler.js

@@ -0,0 +1,11 @@
+import { getExecutionTime } from './execution-time.js';
+export const errorReceived = (process, startTime) => () => {
+    console.log(`Done after ${String(getExecutionTime(startTime))}s`);
+    process.exit(1);
+};
+export const handleErrors = (process, startTime) => {
+    const catchErrors = ['unhandledRejection', 'uncaughtException'];
+    catchErrors.map((event) => {
+        return process.on(event, errorReceived(process, startTime));
+    });
+};

package/dist/src/utils/execution-time.js

@@ -0,0 +1,3 @@
+export function getExecutionTime(startTime) {
+    return Number(process.hrtime.bigint() - startTime) / 1000000000;
+}

package/dist/src/utils/manifest.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+const ManifestSchema = z.object({
+    name: z.string().min(1),
+    version: z.string().min(1),
+    description: z.string().min(1),
+});
+export function isManifest(input) {
+    return ManifestSchema.safeParse(input).success;
+}

package/dist/src/utils/reporter.js

@@ -0,0 +1,15 @@
+import { format } from 'node:util';
+export class Reporter {
+    _stdout;
+    constructor(_stdout) {
+        this._stdout = _stdout;
+        this.log = this.log.bind(this);
+        this.error = this.error.bind(this);
+    }
+    log(...args) {
+        this._stdout.write(format(...args) + '\n');
+    }
+    error(...args) {
+        this._stdout.write(format(...args) + '\n');
+    }
+}

package/dist/src/utils/signal-handler.js

@@ -0,0 +1,12 @@
+import { getExecutionTime } from './execution-time.js';
+export const signalReceived = (process, startTime, event) => () => {
+    console.log(`Done after ${String(getExecutionTime(startTime))}s`);
+    process.kill(process.pid, event);
+    process.exit(1);
+};
+export const handleSignals = (process, startTime) => {
+    const catchSignals = ['SIGTERM', 'SIGINT', 'SIGUSR2'];
+    catchSignals.map((event) => {
+        return process.once(event, signalReceived(process, startTime, event));
+    });
+};

package/dist/src/utils/tty.js

@@ -0,0 +1,3 @@
+export function isTTY(process) {
+    return process.stdout.isTTY || false;
+}

package/dist/tests/integration/cli.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
+describe('CLI Integration', () => {
+    describe('--help', () => {
+        it('should display help information', () => {
+            const result = execSync('npm run build && node ./dist/src/cli.js --help', {
+                encoding: 'utf-8',
+                cwd: resolve(__dirname, '../..'),
+            });
+            expect(result).toContain('Usage:');
+            expect(result).toContain('--input');
+            expect(result).toContain('--output');
+        });
+    });
+    describe('--version', () => {
+        it('should display version information', () => {
+            const result = execSync('npm run build && node ./dist/src/cli.js --version', {
+                encoding: 'utf-8',
+                cwd: resolve(__dirname, '../..'),
+            });
+            expect(result).toMatch(/\d+\.\d+\.\d+/);
+        });
+    });
+});

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

@@ -0,0 +1,29 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Generator } from '../../src/generator.js';
+describe('Generator', () => {
+    let generator;
+    let mockReporter;
+    beforeEach(() => {
+        // Create a mock reporter
+        mockReporter = {
+            info: vi.fn(),
+            error: vi.fn(),
+            warn: vi.fn(),
+            success: vi.fn(),
+        };
+        generator = new Generator('test-app', '1.0.0', mockReporter, './test-input.json', './test-output');
+    });
+    describe('constructor', () => {
+        it('should create a new Generator instance', () => {
+            expect(generator).toBeInstanceOf(Generator);
+        });
+    });
+    describe('run', () => {
+        it('should be a function', () => {
+            expect(typeof generator.run).toBe('function');
+        });
+        it('should have the run method defined', () => {
+            expect(generator).toHaveProperty('run');
+        });
+    });
+});

package/dist/vitest.config.js

@@ -0,0 +1,38 @@
+import { defineConfig } from 'vitest/config';
+import { resolve } from 'node:path';
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+        exclude: ['node_modules', 'dist', 'coverage'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'json', 'html', 'lcov'],
+            exclude: [
+                'coverage/**',
+                'dist/**',
+                'node_modules/**',
+                '**/*.d.ts',
+                '**/*.config.*',
+                '**/*.test.*',
+                '**/*.spec.*',
+                'scripts/**',
+                'samples/**',
+            ],
+            thresholds: {
+                global: {
+                    branches: 80,
+                    functions: 80,
+                    lines: 80,
+                    statements: 80,
+                },
+            },
+        },
+    },
+    resolve: {
+        alias: {
+            '@': resolve(__dirname, 'src'),
+        },
+    },
+});

package/eslint.config.mjs

@@ -0,0 +1,33 @@
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+
+export default defineConfig([
+  {
+    ignores: [
+      '**/*.mjs',
+      'dist/**/*',
+      'node_modules/**/*',
+    ],
+  },
+  eslint.configs.recommended,
+  tseslint.configs.strictTypeChecked,
+  tseslint.configs.stylisticTypeChecked,
+  {
+    languageOptions: {
+      parserOptions: {
+        projectService: true,
+      },
+    },
+    rules: {
+      quotes: ['error', 'single', { avoidEscape: true }],
+      'sort-imports': [
+        'error',
+        {
+          ignoreCase: true,
+          ignoreDeclarationSort: true,
+        },
+      ],
+    },
+  },
+]);

package/package.json

@@ -0,0 +1,102 @@
+{
+  "author": "Julien Andreu <julienandreu@me.com>",
+  "bin": {
+    "zod-codegen": "dist/src/cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/julienandreu/zod-codegen/issues"
+  },
+  "dependencies": {
+    "@apidevtools/swagger-parser": "^10.1.0",
+    "debug": "^4.3.7",
+    "js-yaml": "^4.1.0",
+    "jsonpath": "^1.1.1",
+    "loud-rejection": "^2.2.0",
+    "openapi-types": "^12.1.3",
+    "openapi-typescript": "^7.4.0",
+    "path-to-regexp": "^8.2.0",
+    "prettier": "^3.3.3",
+    "typescript": "^5.7.2",
+    "url-pattern": "^1.0.3",
+    "yargs": "^18.0.0",
+    "zod": "^3.23.8"
+  },
+  "description": "A powerful TypeScript code generator that creates Zod schemas and type-safe clients from OpenAPI specifications",
+  "keywords": [
+    "zod",
+    "openapi",
+    "swagger",
+    "codegen",
+    "typescript",
+    "type-safe",
+    "api",
+    "schema",
+    "validation"
+  ],
+  "devDependencies": {
+    "@commitlint/cli": "^19.8.1",
+    "@commitlint/config-conventional": "^19.8.1",
+    "@eslint/js": "^9.17.0",
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
+    "@types/debug": "^4.1.12",
+    "@types/jest": "^30.0.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/jsonpath": "^0.2.4",
+    "@types/node": "^22.10.2",
+    "@types/yargs": "^17.0.33",
+    "@vitest/coverage-v8": "^3.2.4",
+    "eslint": "^9.17.0",
+    "eslint-config-prettier": "^9.1.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.6",
+    "semantic-release": "^24.2.8",
+    "ts-node": "^10.9.2",
+    "typescript-eslint": "^8.18.1",
+    "undici": "^6.21.0",
+    "vitest": "^3.2.4"
+  },
+  "optionalDependencies": {
+    "undici": "^6.21.0"
+  },
+  "homepage": "https://github.com/julienandreu/zod-codegen",
+  "license": "MIT",
+  "name": "zod-codegen",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/src/generator-v2.d.ts",
+      "import": "./dist/src/generator-v2.js",
+      "require": "./dist/src/generator-v2.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/julienandreu/zod-codegen.git"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc --project tsconfig.json && cp -r src/assets dist/src/ && chmod +x ./dist/src/cli.js",
+    "build:watch": "tsc --project tsconfig.json --watch",
+    "dev": "npm run build && node ./dist/src/cli.js --input ./samples/saris-openapi.json && npm run format && npm run lint",
+    "lint": "eslint src --fix",
+    "lint:check": "eslint src",
+    "format": "prettier src --write --log-level error",
+    "format:check": "prettier src --check",
+    "type-check": "tsc -p ./tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
+    "manifest:update": "ts-node scripts/update-manifest.ts",
+    "prepare": "husky",
+    "prepublishOnly": "npm run build && npm run test && npm run lint:check && npm run type-check",
+    "clean": "rm -rf dist coverage node_modules/.cache",
+    "validate": "npm run type-check && npm run lint:check && npm run format:check && npm run test",
+    "release": "semantic-release",
+    "release:dry": "semantic-release --dry-run"
+  },
+  "version": "1.0.0"
+}