@cerios/openapi-to-zod 0.1.1 → 0.2.0

package/dist/index.d.mts

@@ -243,16 +243,6 @@ interface OpenAPISpec {
  * - 'sequential': Process specs one at a time (safer for resource constraints)
  */
 type ExecutionMode = "parallel" | "sequential";
-/**
- * Configuration for a single OpenAPI spec
- * Extends GeneratorOptions with all the same properties
- */
-interface SpecConfig extends GeneratorOptions {
-    /**
-     * Optional name/identifier for this spec (for logging purposes)
-     */
-    name?: string;
-}
 /**
  * Root configuration file structure
  */
@@ -266,7 +256,7 @@ interface ConfigFile {
      * Array of OpenAPI specifications to process
      * Each spec must have input and output paths
      */
-    specs: SpecConfig[];
+    specs: GeneratorOptions[];
     /**
      * Execution mode for batch processing
      * @default "parallel"
@@ -315,6 +305,10 @@ declare class ZodSchemaGenerator {
      * @returns The generated TypeScript code as a string
      */
     generateString(): string;
+    /**
+     * Ensure directory exists for a file path
+     */
+    private ensureDirectoryExists;
     /**
      * Generate the complete output file
      */
@@ -367,6 +361,14 @@ declare class ZodSchemaGenerator {
      * Generate schema for a component
      */
     private generateComponentSchema;
+    /**
+     * Generate query parameter schemas for each operation
+     */
+    private generateQueryParameterSchemas;
+    /**
+     * Generate Zod type for a query parameter schema
+     */
+    private generateQueryParamType;
     /**
      * Generate native TypeScript enum
      */
@@ -398,4 +400,4 @@ declare class ZodSchemaGenerator {
     private generateStats;
 }
 
-export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type GeneratorOptions, type OpenAPISpec, SchemaGenerationError, type SpecConfig, SpecValidationError, ZodSchemaGenerator, defineConfig };
+export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type GeneratorOptions, type OpenAPISpec, SchemaGenerationError, SpecValidationError, ZodSchemaGenerator, defineConfig };

package/dist/index.d.ts

@@ -243,16 +243,6 @@ interface OpenAPISpec {
  * - 'sequential': Process specs one at a time (safer for resource constraints)
  */
 type ExecutionMode = "parallel" | "sequential";
-/**
- * Configuration for a single OpenAPI spec
- * Extends GeneratorOptions with all the same properties
- */
-interface SpecConfig extends GeneratorOptions {
-    /**
-     * Optional name/identifier for this spec (for logging purposes)
-     */
-    name?: string;
-}
 /**
  * Root configuration file structure
  */
@@ -266,7 +256,7 @@ interface ConfigFile {
      * Array of OpenAPI specifications to process
      * Each spec must have input and output paths
      */
-    specs: SpecConfig[];
+    specs: GeneratorOptions[];
     /**
      * Execution mode for batch processing
      * @default "parallel"
@@ -315,6 +305,10 @@ declare class ZodSchemaGenerator {
      * @returns The generated TypeScript code as a string
      */
     generateString(): string;
+    /**
+     * Ensure directory exists for a file path
+     */
+    private ensureDirectoryExists;
     /**
      * Generate the complete output file
      */
@@ -367,6 +361,14 @@ declare class ZodSchemaGenerator {
      * Generate schema for a component
      */
     private generateComponentSchema;
+    /**
+     * Generate query parameter schemas for each operation
+     */
+    private generateQueryParameterSchemas;
+    /**
+     * Generate Zod type for a query parameter schema
+     */
+    private generateQueryParamType;
     /**
      * Generate native TypeScript enum
      */
@@ -398,4 +400,4 @@ declare class ZodSchemaGenerator {
     private generateStats;
 }
 
-export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type GeneratorOptions, type OpenAPISpec, SchemaGenerationError, type SpecConfig, SpecValidationError, ZodSchemaGenerator, defineConfig };
+export { CircularReferenceError, CliOptionsError, type ConfigFile, ConfigValidationError, type ExecutionMode, FileOperationError, GeneratorError, type GeneratorOptions, type OpenAPISpec, SchemaGenerationError, SpecValidationError, ZodSchemaGenerator, defineConfig };

package/dist/index.js

@@ -93,6 +93,7 @@ var ConfigurationError = class extends GeneratorError {
 
 // src/generator.ts
 var import_node_fs = require("fs");
+var import_node_path = require("path");
 var import_yaml = require("yaml");
 
 // src/utils/name-utils.ts
@@ -146,7 +147,7 @@ function generateEnum(name, values, options) {
     const enumCode = `export enum ${enumName} {
 ${enumEntries}
 }`;
-    const schemaCode2 = `export const ${schemaName} = z.enum(${enumName});`;
+    const schemaCode2 = `export const ${schemaName} = z.nativeEnum(${enumName});`;
     const typeCode2 = `export type ${name} = z.infer<typeof ${schemaName}>;`;
     return { enumCode, schemaCode: schemaCode2, typeCode: typeCode2 };
   }
@@ -329,20 +330,20 @@ function generateArrayValidation(schema, context) {
 }
 
 // src/validators/composition-validator.ts
-function generateUnion(schemas, discriminator, isNullable2, context, options) {
+function generateUnion(schemas, discriminator, isNullable2, context, options, currentSchema) {
   if (discriminator) {
     let resolvedSchemas = schemas;
     if ((options == null ? void 0 : options.discriminatorMapping) && context.resolveDiscriminatorMapping) {
       resolvedSchemas = context.resolveDiscriminatorMapping(options.discriminatorMapping, schemas);
     }
-    let schemaStrings2 = resolvedSchemas.map((s) => context.generatePropertySchema(s));
+    let schemaStrings2 = resolvedSchemas.map((s) => context.generatePropertySchema(s, currentSchema));
     if (options == null ? void 0 : options.passthrough) {
       schemaStrings2 = schemaStrings2.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
     }
     const union2 = `z.discriminatedUnion("${discriminator}", [${schemaStrings2.join(", ")}])`;
     return wrapNullable(union2, isNullable2);
   }
-  let schemaStrings = schemas.map((s) => context.generatePropertySchema(s));
+  let schemaStrings = schemas.map((s) => context.generatePropertySchema(s, currentSchema));
   if (options == null ? void 0 : options.passthrough) {
     schemaStrings = schemaStrings.map((s) => s.includes(".catchall(") ? s : `${s}.catchall(z.unknown())`);
   }
@@ -1175,7 +1176,8 @@ var _PropertyGenerator = class _PropertyGenerator {
         {
           passthrough: needsPassthrough,
           discriminatorMapping: (_c = schema.discriminator) == null ? void 0 : _c.mapping
-        }
+        },
+        currentSchema
       );
       if (schema.unevaluatedProperties !== void 0) {
         composition = this.applyUnevaluatedProperties(composition, schema);
@@ -1195,7 +1197,8 @@ var _PropertyGenerator = class _PropertyGenerator {
         {
           passthrough: needsPassthrough,
           discriminatorMapping: (_e = schema.discriminator) == null ? void 0 : _e.mapping
-        }
+        },
+        currentSchema
       );
       if (schema.unevaluatedProperties !== void 0) {
         composition = this.applyUnevaluatedProperties(composition, schema);
@@ -1366,10 +1369,13 @@ var ZodSchemaGenerator = class {
     }
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
       if (schema.enum) {
-        const typeMode = this.schemaTypeModeMap.get(name) || "inferred";
-        if (typeMode === "inferred") {
+        const context = this.schemaUsageMap.get(name);
+        const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
+        if (resolvedOptions.enumType === "typescript") {
+          this.generateNativeEnum(name, schema);
+        } else {
           const { enumCode } = generateEnum(name, schema.enum, {
-            enumType: this.options.enumType || "zod",
+            enumType: "zod",
             prefix: this.options.prefix,
             suffix: this.options.suffix
           });
@@ -1377,14 +1383,13 @@ var ZodSchemaGenerator = class {
             this.enums.set(name, enumCode);
             this.needsZodImport = true;
           }
-        } else {
-          this.generateNativeEnum(name, schema);
         }
       }
     }
     for (const [name, schema] of Object.entries(this.spec.components.schemas)) {
       this.generateComponentSchema(name, schema);
     }
+    this.generateQueryParameterSchemas();
     const orderedSchemaNames = this.topologicalSort();
     const output = ["// Auto-generated by @cerios/openapi-to-zod", "// Do not edit this file manually", ""];
     if (this.options.showStats === true) {
@@ -1395,12 +1400,8 @@ var ZodSchemaGenerator = class {
       output.push('import { z } from "zod";');
       output.push("");
     }
-    if (this.enums.size > 0 || this.nativeEnums.size > 0) {
-      output.push("// Enums");
-      for (const enumCode of this.enums.values()) {
-        output.push(enumCode);
-        output.push("");
-      }
+    if (this.nativeEnums.size > 0) {
+      output.push("// Native Enums");
       for (const enumCode of this.nativeEnums.values()) {
         output.push(enumCode);
         output.push("");
@@ -1408,9 +1409,13 @@ var ZodSchemaGenerator = class {
     }
     output.push("// Schemas and Types");
     for (const name of orderedSchemaNames) {
+      const enumCode = this.enums.get(name);
       const schemaCode = this.schemas.get(name);
       const typeCode = this.types.get(name);
-      if (schemaCode) {
+      if (enumCode) {
+        output.push(enumCode);
+        output.push("");
+      } else if (schemaCode) {
         output.push(schemaCode);
         if (!schemaCode.includes(`export type ${name}`)) {
           const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
@@ -1424,6 +1429,15 @@ var ZodSchemaGenerator = class {
     }
     return output.join("\n");
   }
+  /**
+   * Ensure directory exists for a file path
+   */
+  ensureDirectoryExists(filePath) {
+    const dir = (0, import_node_path.dirname)(filePath);
+    if (!(0, import_node_fs.existsSync)(dir)) {
+      (0, import_node_fs.mkdirSync)(dir, { recursive: true });
+    }
+  }
   /**
    * Generate the complete output file
    */
@@ -1435,6 +1449,7 @@ var ZodSchemaGenerator = class {
       );
     }
     const output = this.generateString();
+    this.ensureDirectoryExists(this.options.output);
     (0, import_node_fs.writeFileSync)(this.options.output, output);
   }
   /**
@@ -1738,10 +1753,19 @@ var ZodSchemaGenerator = class {
     const context = this.schemaUsageMap.get(name);
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
-      if (typeMode === "inferred") {
-        const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
+      const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
+      if (resolvedOptions.enumType === "typescript") {
+        const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
+          enumType: "typescript",
+          prefix: this.options.prefix,
+          suffix: this.options.suffix
+        });
+        const enumSchemaCode = `${jsdoc}${schemaCode}
+${typeCode}`;
+        this.schemas.set(name, enumSchemaCode);
+      } else {
         const { enumCode, schemaCode, typeCode } = generateEnum(name, schema.enum, {
-          enumType: resolvedOptions.enumType,
+          enumType: "zod",
           prefix: this.options.prefix,
           suffix: this.options.suffix
         });
@@ -1800,6 +1824,133 @@ ${typeCode}`;
       this.schemas.set(name, zodSchemaCode);
     }
   }
+  /**
+   * Generate query parameter schemas for each operation
+   */
+  generateQueryParameterSchemas() {
+    var _a;
+    if (!this.spec.paths) {
+      return;
+    }
+    for (const [_path, pathItem] of Object.entries(this.spec.paths)) {
+      if (!pathItem || typeof pathItem !== "object") continue;
+      const methods = ["get", "post", "put", "patch", "delete", "head", "options"];
+      for (const method of methods) {
+        const operation = pathItem[method];
+        if (!operation) continue;
+        if (!operation.operationId || !operation.parameters || !Array.isArray(operation.parameters)) {
+          continue;
+        }
+        const queryParams = operation.parameters.filter(
+          (param) => param && typeof param === "object" && param.in === "query"
+        );
+        if (queryParams.length === 0) {
+          continue;
+        }
+        const pascalOperationId = operation.operationId.includes("-") ? toPascalCase(operation.operationId) : operation.operationId.charAt(0).toUpperCase() + operation.operationId.slice(1);
+        const schemaName = `${pascalOperationId}QueryParams`;
+        if (!this.schemaDependencies.has(schemaName)) {
+          this.schemaDependencies.set(schemaName, /* @__PURE__ */ new Set());
+        }
+        const properties = {};
+        const required = [];
+        for (const param of queryParams) {
+          const paramName = param.name;
+          const isRequired = param.required === true;
+          const paramSchema = param.schema;
+          if (!paramSchema) continue;
+          let zodType = this.generateQueryParamType(paramSchema, param);
+          if (paramSchema.type === "array" && paramSchema.items) {
+            const itemType = this.generateQueryParamType(paramSchema.items, param);
+            zodType = `z.array(${itemType})`;
+          }
+          if (param.description && this.requestOptions.includeDescriptions) {
+            if (this.requestOptions.useDescribe) {
+              zodType = `${zodType}.describe(${JSON.stringify(param.description)})`;
+            }
+          }
+          if (!isRequired) {
+            zodType = `${zodType}.optional()`;
+          }
+          properties[paramName] = zodType;
+          if (isRequired) {
+            required.push(paramName);
+          }
+          if (paramSchema.$ref) {
+            const refName = resolveRef(paramSchema.$ref);
+            (_a = this.schemaDependencies.get(schemaName)) == null ? void 0 : _a.add(refName);
+          }
+        }
+        const objectMode = this.requestOptions.mode;
+        const zodMethod = objectMode === "strict" ? "strictObject" : objectMode === "loose" ? "looseObject" : "object";
+        const propsCode = Object.entries(properties).map(([key, value]) => {
+          const needsQuotes = !/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key);
+          const quotedKey = needsQuotes ? `"${key}"` : key;
+          return `  ${quotedKey}: ${value}`;
+        }).join(",\n");
+        const schemaCode = `z.${zodMethod}({
+${propsCode}
+})`;
+        const operationName = pascalOperationId;
+        const prefixedName = this.options.prefix ? `${toPascalCase(this.options.prefix)}${operationName}` : operationName;
+        const suffixedName = this.options.suffix ? `${prefixedName}${toPascalCase(this.options.suffix)}` : prefixedName;
+        const camelCaseSchemaName = `${suffixedName.charAt(0).toLowerCase() + suffixedName.slice(1)}QueryParamsSchema`;
+        const jsdoc = `/**
+ * Query parameters for ${operation.operationId}
+ */
+`;
+        const fullSchemaCode = `${jsdoc}export const ${camelCaseSchemaName} = ${schemaCode};`;
+        this.schemas.set(schemaName, fullSchemaCode);
+        this.needsZodImport = true;
+      }
+    }
+  }
+  /**
+   * Generate Zod type for a query parameter schema
+   */
+  generateQueryParamType(schema, param) {
+    if (schema.$ref) {
+      const refName = resolveRef(schema.$ref);
+      const schemaName = toCamelCase(refName, { prefix: this.options.prefix, suffix: this.options.suffix });
+      return `${schemaName}Schema`;
+    }
+    if (schema.enum) {
+      const enumValues = schema.enum.map((v) => typeof v === "string" ? `"${v}"` : v).join(", ");
+      return `z.enum([${enumValues}])`;
+    }
+    const type = schema.type;
+    if (type === "string") {
+      let zodType = "z.string()";
+      if (schema.minLength !== void 0) zodType = `${zodType}.min(${schema.minLength})`;
+      if (schema.maxLength !== void 0) zodType = `${zodType}.max(${schema.maxLength})`;
+      if (schema.pattern) zodType = `${zodType}.regex(/${schema.pattern}/)`;
+      if (schema.format === "email") zodType = `${zodType}.email()`;
+      if (schema.format === "uri" || schema.format === "url") zodType = `${zodType}.url()`;
+      if (schema.format === "uuid") zodType = `${zodType}.uuid()`;
+      return zodType;
+    }
+    if (type === "number" || type === "integer") {
+      let zodType = type === "integer" ? "z.number().int()" : "z.number()";
+      if (schema.minimum !== void 0) {
+        zodType = schema.exclusiveMinimum ? `${zodType}.gt(${schema.minimum})` : `${zodType}.gte(${schema.minimum})`;
+      }
+      if (schema.maximum !== void 0) {
+        zodType = schema.exclusiveMaximum ? `${zodType}.lt(${schema.maximum})` : `${zodType}.lte(${schema.maximum})`;
+      }
+      return zodType;
+    }
+    if (type === "boolean") {
+      return "z.boolean()";
+    }
+    if (type === "array" && schema.items) {
+      const itemType = this.generateQueryParamType(schema.items, param);
+      let arrayType = `z.array(${itemType})`;
+      if (schema.minItems !== void 0) arrayType = `${arrayType}.min(${schema.minItems})`;
+      if (schema.maxItems !== void 0) arrayType = `${arrayType}.max(${schema.maxItems})`;
+      return arrayType;
+    }
+    return "z.unknown()";
+  }
   /**
    * Generate native TypeScript enum
    */
@@ -1810,8 +1961,8 @@ ${typeCode}`;
     const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
     if (resolvedOptions.nativeEnumType === "enum") {
       const enumName = `${name}Enum`;
-      const members = schema.enum.map((value, index) => {
-        const key = typeof value === "string" ? this.toEnumKey(value) : `Value${index}`;
+      const members = schema.enum.map((value) => {
+        const key = typeof value === "string" ? this.toEnumKey(value) : `N${value}`;
         const val = typeof value === "string" ? `"${value}"` : value;
         return `  ${key} = ${val}`;
       }).join(",\n");
@@ -1954,7 +2105,11 @@ ${props.join("\n")}
     const visited = /* @__PURE__ */ new Set();
     const visiting = /* @__PURE__ */ new Set();
     const aliases = [];
+    const circularDeps = /* @__PURE__ */ new Set();
     const codeCache = /* @__PURE__ */ new Map();
+    for (const [name, code] of this.enums) {
+      codeCache.set(name, code);
+    }
     for (const [name, code] of this.schemas) {
       codeCache.set(name, code);
     }
@@ -1964,6 +2119,7 @@ ${props.join("\n")}
     const visit = (name) => {
       if (visited.has(name)) return;
       if (visiting.has(name)) {
+        circularDeps.add(name);
         return;
       }
       visiting.add(name);
@@ -1978,19 +2134,27 @@ ${props.join("\n")}
       const deps = this.schemaDependencies.get(name);
       if (deps && deps.size > 0) {
         for (const dep of deps) {
-          if (this.schemas.has(dep) || this.types.has(dep)) {
+          if (this.enums.has(dep) || this.schemas.has(dep) || this.types.has(dep)) {
             visit(dep);
           }
         }
       }
       visiting.delete(name);
       visited.add(name);
-      sorted.push(name);
+      if (!circularDeps.has(name)) {
+        sorted.push(name);
+      }
     };
-    const allNames = /* @__PURE__ */ new Set([...this.schemas.keys(), ...this.types.keys()]);
+    const allNames = /* @__PURE__ */ new Set([...this.enums.keys(), ...this.schemas.keys(), ...this.types.keys()]);
     for (const name of allNames) {
       visit(name);
     }
+    for (const name of circularDeps) {
+      if (!visited.has(name)) {
+        sorted.push(name);
+        visited.add(name);
+      }
+    }
     return [...sorted, ...aliases];
   }
   /**