@cerios/openapi-to-zod 0.1.1 → 0.2.0

package/dist/cli.mjs

@@ -130,7 +130,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 };
   }
@@ -347,20 +347,20 @@ var init_array_validator = __esm({
 });
 
 // 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())`);
   }
@@ -1243,7 +1243,8 @@ var init_property_generator = __esm({
             {
               passthrough: needsPassthrough,
               discriminatorMapping: (_c = schema.discriminator) == null ? void 0 : _c.mapping
-            }
+            },
+            currentSchema
           );
           if (schema.unevaluatedProperties !== void 0) {
             composition = this.applyUnevaluatedProperties(composition, schema);
@@ -1263,7 +1264,8 @@ var init_property_generator = __esm({
             {
               passthrough: needsPassthrough,
               discriminatorMapping: (_e = schema.discriminator) == null ? void 0 : _e.mapping
-            }
+            },
+            currentSchema
           );
           if (schema.unevaluatedProperties !== void 0) {
             composition = this.applyUnevaluatedProperties(composition, schema);
@@ -1347,7 +1349,8 @@ var init_property_generator = __esm({
 });
 
 // src/generator.ts
-import { readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
 import { parse } from "yaml";
 var ZodSchemaGenerator;
 var init_generator = __esm({
@@ -1448,10 +1451,13 @@ var init_generator = __esm({
         }
         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
               });
@@ -1459,14 +1465,13 @@ var init_generator = __esm({
                 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) {
@@ -1477,12 +1482,8 @@ var init_generator = __esm({
           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("");
@@ -1490,9 +1491,13 @@ var init_generator = __esm({
         }
         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`;
@@ -1506,6 +1511,15 @@ var init_generator = __esm({
         }
         return output.join("\n");
       }
+      /**
+       * Ensure directory exists for a file path
+       */
+      ensureDirectoryExists(filePath) {
+        const dir = dirname(filePath);
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true });
+        }
+      }
       /**
        * Generate the complete output file
        */
@@ -1517,6 +1531,7 @@ var init_generator = __esm({
           );
         }
         const output = this.generateString();
+        this.ensureDirectoryExists(this.options.output);
         writeFileSync(this.options.output, output);
       }
       /**
@@ -1820,10 +1835,19 @@ var init_generator = __esm({
         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
             });
@@ -1882,6 +1906,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
        */
@@ -1892,8 +2043,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");
@@ -2036,7 +2187,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);
         }
@@ -2046,6 +2201,7 @@ ${props.join("\n")}
         const visit = (name) => {
           if (visited.has(name)) return;
           if (visiting.has(name)) {
+            circularDeps.add(name);
             return;
           }
           visiting.add(name);
@@ -2060,19 +2216,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];
       }
       /**
@@ -2109,8 +2273,7 @@ ${props.join("\n")}
 
 // src/batch-executor.ts
 async function processSpec(spec, index, total) {
-  const specName = spec.name || spec.input;
-  console.log(`Processing [${index + 1}/${total}] ${specName}...`);
+  console.log(`Processing [${index + 1}/${total}] ${spec.input}...`);
   try {
     const generator = new ZodSchemaGenerator(spec);
     generator.generate();
@@ -2169,8 +2332,7 @@ ${"=".repeat(50)}`);
     console.log("\nFailed specs:");
     for (const result of summary.results) {
       if (!result.success) {
-        const specName = result.spec.name || result.spec.input;
-        console.error(`  \u2717 ${specName}`);
+        console.error(`  \u2717 ${result.spec.input}`);
         console.error(`    Error: ${result.error}`);
       }
     }
@@ -2218,19 +2380,6 @@ var init_batch_executor = __esm({
   }
 });
 
-// src/types.ts
-var FilePath;
-var init_types = __esm({
-  "src/types.ts"() {
-    "use strict";
-    init_esm_shims();
-    FilePath = {
-      from: (path2) => path2,
-      is: (value) => typeof value === "string" && value.length > 0
-    };
-  }
-});
-
 // src/utils/config-loader.ts
 import { cosmiconfig } from "cosmiconfig";
 import { z } from "zod";
@@ -2400,7 +2549,6 @@ var require_cli = __commonJS({
     init_batch_executor();
     init_errors();
     init_generator();
-    init_types();
     init_config_loader();
     var CliOptionsSchema = z2.object({
       config: z2.string().optional(),
@@ -2484,8 +2632,8 @@ Examples:
         });
       }
       const generatorOptions = {
-        input: FilePath.from(options.input),
-        output: FilePath.from(options.output),
+        input: options.input,
+        output: options.output,
         mode: options.mode,
         includeDescriptions: options.descriptions,
         enumType: options.enumType,