zod-codegen 1.0.0 → 1.0.2

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

@@ -5,24 +5,37 @@ 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');
+  async readFile(path: string): Promise<string> {
+    // Check if path is a URL
+    try {
+      const url = new URL(path);
+      // If it's a valid URL, fetch it
+      const response = await fetch(url.toString());
+      if (!response.ok) {
+        throw new Error(`Failed to fetch ${path}: ${String(response.status)} ${response.statusText}`);
+      }
+      return await response.text();
+    } catch {
+      // If URL parsing fails, treat it as a local file path
+      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;
-    }
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const parsedInput =
+      typeof input === 'string'
+        ? (() => {
+            try {
+              // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+              return JSON.parse(input);
+            } catch {
+              return load(input);
+            }
+          })()
+        : input;
 
     return OpenApiSpec.parse(parsedInput);
   }

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

@@ -16,10 +16,7 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
   buildImports(): ts.ImportDeclaration[] {
     return [
       this.createImport('zod', {
-        defaultImport: {z: false},
-      }),
-      this.createImport('path-to-regexp', {
-        namedImports: {compile: false},
+        namedImports: {z: false},
       }),
     ];
   }
@@ -46,16 +43,16 @@ export class TypeScriptImportBuilderService implements ImportBuilder {
     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
+    // For imports with bindings, we need to create the clause using the factory
     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)
+        ? // eslint-disable-next-line @typescript-eslint/no-deprecated
+          ts.factory.createImportClause(
+            false,
+            hasDefaultImport && defaultImport ? ts.factory.createIdentifier(defaultImport) : undefined,
+            namedImports ?? undefined,
+          )
         : undefined,
       ts.factory.createStringLiteral(target, true),
       undefined,

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

@@ -11,8 +11,23 @@ export class TypeScriptTypeBuilderService implements TypeBuilder {
       case 'boolean':
         return ts.factory.createKeywordTypeNode(ts.SyntaxKind.BooleanKeyword);
       case 'unknown':
-      default:
         return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+      default:
+        // Handle custom types (like Pet, Order, User, etc.) and array types
+        if (type.endsWith('[]')) {
+          const itemType = type.slice(0, -2);
+          return ts.factory.createArrayTypeNode(this.buildType(itemType));
+        }
+        // Handle Record types
+        if (type.startsWith('Record<')) {
+          // For now, return unknown for complex Record types
+          return ts.factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword);
+        }
+        // Custom type name - create a type reference
+        return ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier(this.sanitizeIdentifier(type)),
+          undefined,
+        );
     }
   }
 
@@ -54,17 +69,9 @@ export class TypeScriptTypeBuilderService implements TypeBuilder {
   }
 
   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;
+    const sanitized = name.replace(/[^a-zA-Z0-9_]/g, '_');
+    const withPrefix = /^[0-9]/.test(sanitized) ? '_' + sanitized : sanitized;
+    return withPrefix.length === 0 ? '_' : withPrefix;
   }
 
   toCamelCase(word: string): string {

package/src/types/openapi.ts

@@ -61,7 +61,7 @@ const ServerVariable = z.object({
 });
 
 const Server = z.object({
-  url: z.string().url(),
+  url: z.url(),
   description: z.string().optional(),
   variables: z.record(z.string(), ServerVariable).optional(),
 });
@@ -140,18 +140,18 @@ const Info = z.object({
   title: z.string().min(1),
   version: z.string().min(1),
   description: z.string().optional(),
-  termsOfService: z.string().url().optional(),
+  termsOfService: z.url().optional(),
   contact: z
     .object({
       name: z.string().optional(),
-      email: z.string().email().optional(),
-      url: z.string().url().optional(),
+      email: z.email().optional(),
+      url: z.url().optional(),
     })
     .optional(),
   license: z
     .object({
       name: z.string().min(1),
-      url: z.string().url().optional(),
+      url: z.url().optional(),
     })
     .optional(),
 });
@@ -166,7 +166,7 @@ const Tag = z.object({
 
 const ExternalDocumentation = z.object({
   description: z.string().optional(),
-  url: z.string().url(),
+  url: z.url(),
 });
 
 const Components = z.object({

package/tsconfig.json

@@ -6,7 +6,7 @@
     "checkJs": false,
     "downlevelIteration": true,
     "esModuleInterop": true,
-    "exactOptionalPropertyTypes": false,
+    "exactOptionalPropertyTypes": true,
     "forceConsistentCasingInFileNames": true,
     "incremental": true,
     "isolatedModules": true,
@@ -19,7 +19,7 @@
     "noImplicitOverride": true,
     "noImplicitReturns": true,
     "noImplicitThis": true,
-    "noPropertyAccessFromIndexSignature": false,
+    "noPropertyAccessFromIndexSignature": true,
     "noUncheckedIndexedAccess": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
@@ -37,8 +37,8 @@
     "target": "ES2022",
     "typeRoots": ["./node_modules/@types"],
     "useUnknownInCatchVariables": true,
-    "verbatimModuleSyntax": false
+    "verbatimModuleSyntax": true
   },
   "exclude": ["node_modules", "dist", "build"],
-  "include": ["src/**/*.ts", "generated/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
+  "include": ["src/**/*.ts", "scripts/**/*.ts", "tests/**/*.ts", "vitest.config.ts"]
 }

package/scripts/update-manifest.js

@@ -1,31 +0,0 @@
-import {readFileSync, writeFileSync} from 'fs';
-import {resolve} from 'path';
-import {z} from 'zod';
-/**
- * Type guard for the package.json object
- *
- * @param input Unknown input
- * @returns true if the input is an event object
- */
-export function isPackageJson(input) {
-  const event = z
-    .object({
-      name: z.string(),
-      version: z.string(),
-      description: z.string(),
-    })
-    .strict()
-    .catchall(z.any())
-    .required();
-  const {success} = event.safeParse(input);
-  return success;
-}
-const sourcePath = resolve(__dirname, '..', 'package.json');
-const data = JSON.parse(readFileSync(sourcePath, 'utf8'));
-if (!isPackageJson(data)) {
-  process.exit(1);
-}
-const {name, version, description} = data;
-const targetPath = resolve(__dirname, '..', 'src', 'assets', 'manifest.json');
-writeFileSync(targetPath, JSON.stringify({name, version, description}, null, 2));
-process.exit(0);