zod-codegen 1.0.0

package/src/services/file-reader.service.ts

@@ -0,0 +1,29 @@
+import {readFileSync} from 'node:fs';
+import {load} from 'js-yaml';
+import type {OpenApiFileParser, OpenApiFileReader} from '../interfaces/file-reader.js';
+import type {OpenApiSpecType} from '../types/openapi.js';
+import {OpenApiSpec} from '../types/openapi.js';
+
+export class SyncFileReaderService implements OpenApiFileReader {
+  readFile(path: string): string {
+    return readFileSync(path, 'utf8');
+  }
+}
+
+export class OpenApiFileParserService implements OpenApiFileParser<OpenApiSpecType> {
+  parse(input: unknown): OpenApiSpecType {
+    let parsedInput: unknown;
+
+    if (typeof input === 'string') {
+      try {
+        parsedInput = JSON.parse(input);
+      } catch {
+        parsedInput = load(input);
+      }
+    } else {
+      parsedInput = input;
+    }
+
+    return OpenApiSpec.parse(parsedInput);
+  }
+}

package/src/services/file-writer.service.ts

@@ -0,0 +1,36 @@
+import {existsSync, mkdirSync, writeFileSync} from 'node:fs';
+import {dirname, resolve} from 'node:path';
+import type {FileWriter} from '../interfaces/code-generator.js';
+
+export class SyncFileWriterService implements FileWriter {
+  constructor(
+    private readonly name: string,
+    private readonly version: string,
+    private readonly inputPath: string,
+  ) {}
+
+  writeFile(filePath: string, content: string): void {
+    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: string, fileName = 'type.ts'): string {
+    return resolve(outputDir, fileName);
+  }
+}

package/src/services/import-builder.service.ts

@@ -0,0 +1,64 @@
+import * as ts from 'typescript';
+import {z} from 'zod';
+import type {ImportBuilder} from '../interfaces/code-generator.js';
+
+const IsTypeImport = z.boolean();
+const ImportedElement = z.record(z.string(), IsTypeImport);
+
+const ImportOptions = z.object({
+  defaultImport: ImportedElement.optional(),
+  namedImports: ImportedElement.optional(),
+});
+
+type ImportOptionsType = z.infer<typeof ImportOptions>;
+
+export class TypeScriptImportBuilderService implements ImportBuilder {
+  buildImports(): ts.ImportDeclaration[] {
+    return [
+      this.createImport('zod', {
+        defaultImport: {z: false},
+      }),
+      this.createImport('path-to-regexp', {
+        namedImports: {compile: false},
+      }),
+    ];
+  }
+
+  createImport(target: string, options: ImportOptionsType): ts.ImportDeclaration {
+    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,
+          } as ts.ImportClause)
+        : undefined,
+      ts.factory.createStringLiteral(target, true),
+      undefined,
+    );
+  }
+}

package/src/services/type-builder.service.ts

@@ -0,0 +1,77 @@
+import * as ts from 'typescript';
+import type {TypeBuilder} from '../interfaces/code-generator.js';
+
+export class TypeScriptTypeBuilderService implements TypeBuilder {
+  buildType(type: string): ts.TypeNode {
+    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: string, type: string, isReadonly = false): ts.PropertyDeclaration {
+    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: string,
+    type?: string | ts.TypeNode,
+    defaultValue?: ts.Expression,
+    isOptional = false,
+  ): ts.ParameterDeclaration {
+    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: string): ts.TypeParameterDeclaration {
+    return ts.factory.createTypeParameterDeclaration(
+      undefined,
+      ts.factory.createIdentifier(name),
+      undefined,
+      undefined,
+    );
+  }
+
+  sanitizeIdentifier(name: string): string {
+    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: string): string {
+    return word.charAt(0).toLowerCase() + word.slice(1);
+  }
+
+  toPascalCase(word: string): string {
+    return word.charAt(0).toUpperCase() + word.slice(1);
+  }
+}

package/src/types/http.ts

@@ -0,0 +1,35 @@
+export interface HttpRequestConfig<TData = unknown> {
+  readonly url: string;
+  readonly method: HttpMethod;
+  readonly headers?: Record<string, string>;
+  readonly params?: Record<string, string | number | boolean>;
+  readonly data?: TData;
+  readonly timeout?: number;
+}
+
+export interface HttpResponse<TData = unknown> {
+  readonly data: TData;
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Record<string, string>;
+  readonly url: string;
+}
+
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+
+export interface HttpClient {
+  request<TResponse = unknown, TRequest = unknown>(
+    config: HttpRequestConfig<TRequest>,
+  ): Promise<HttpResponse<TResponse>>;
+}
+
+export class HttpError extends Error {
+  constructor(
+    message: string,
+    public readonly status: number,
+    public readonly response?: HttpResponse,
+  ) {
+    super(message);
+    this.name = 'HttpError';
+  }
+}

package/src/types/openapi.ts

@@ -0,0 +1,202 @@
+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.ZodLazy<z.ZodObject<any>> = 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(),
+});
+
+export type OpenApiSpecType = z.infer<typeof OpenApiSpec>;
+export type SchemaPropertiesType = z.infer<typeof SchemaProperties>;
+export type ParameterType = z.infer<typeof Parameter>;
+export type ResponseType = z.infer<typeof Response>;
+export type RequestBodyType = z.infer<typeof RequestBody>;
+export type MethodSchemaType = z.infer<typeof MethodSchema>;
+export type PathItemType = z.infer<typeof PathItem>;
+export type ReferenceType = z.infer<typeof Reference>;

package/src/utils/error-handler.ts

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

package/src/utils/execution-time.ts

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

package/src/utils/manifest.ts

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

package/src/utils/reporter.ts

@@ -0,0 +1,16 @@
+import {format} from 'node:util';
+
+export class Reporter {
+  constructor(private readonly _stdout: NodeJS.WriteStream) {
+    this.log = this.log.bind(this);
+    this.error = this.error.bind(this);
+  }
+
+  log(...args: readonly unknown[]): void {
+    this._stdout.write(format(...args) + '\n');
+  }
+
+  error(...args: readonly unknown[]): void {
+    this._stdout.write(format(...args) + '\n');
+  }
+}

package/src/utils/signal-handler.ts

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

package/src/utils/tty.ts

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

package/tests/integration/cli.test.ts

@@ -0,0 +1,29 @@
+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/tests/unit/generator.test.ts

@@ -0,0 +1,36 @@
+import {beforeEach, describe, expect, it, vi} from 'vitest';
+import {Generator} from '../../src/generator.js';
+import {Reporter} from '../../src/utils/reporter.js';
+
+describe('Generator', () => {
+  let generator: Generator;
+  let mockReporter: Reporter;
+
+  beforeEach(() => {
+    // Create a mock reporter
+    mockReporter = {
+      info: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      success: vi.fn(),
+    } as unknown as Reporter;
+
+    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/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "alwaysStrict": true,
+    "baseUrl": ".",
+    "checkJs": false,
+    "downlevelIteration": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "incremental": true,
+    "isolatedModules": true,
+    "lib": ["ES2022", "DOM"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "noEmit": false,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noImplicitThis": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "outDir": "dist",
+    "removeComments": false,
+    "resolveJsonModule": true,
+    "rootDir": ".",
+    "skipLibCheck": true,
+    "sourceMap": false,
+    "strict": true,
+    "strictBindCallApply": true,
+    "strictFunctionTypes": true,
+    "strictNullChecks": true,
+    "strictPropertyInitialization": true,
+    "target": "ES2022",
+    "typeRoots": ["./node_modules/@types"],
+    "useUnknownInCatchVariables": true,
+    "verbatimModuleSyntax": false
+  },
+  "exclude": ["node_modules", "dist", "build"],
+  "include": ["src/**/*.ts", "generated/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,39 @@
+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'),
+    },
+  },
+});