@cerios/openapi-to-zod 0.6.0 → 1.1.0

package/dist/cli.js

@@ -5013,10 +5013,123 @@ var ConfigurationError = class extends GeneratorError {
   }
 };
 
+// src/batch-executor.ts
+async function processSpec(spec, index, total, createGenerator) {
+  const specInput = spec.input || "spec";
+  const specOutput = spec.output || "output";
+  console.log(`Processing [${index + 1}/${total}] ${specInput}...`);
+  try {
+    const generator = createGenerator(spec);
+    generator.generate();
+    return {
+      spec,
+      success: true
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u2717 Failed to generate ${specOutput}: ${errorMessage}`);
+    return {
+      spec,
+      success: false,
+      error: errorMessage
+    };
+  }
+}
+async function executeParallel(specs, createGenerator, batchSize) {
+  console.log(`
+Executing ${specs.length} specification(s) in parallel (batch size: ${batchSize})...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i += batchSize) {
+    const batch = specs.slice(i, Math.min(i + batchSize, specs.length));
+    const batchPromises = batch.map(
+      (spec, batchIndex) => processSpec(spec, i + batchIndex, specs.length, createGenerator)
+    );
+    const batchResults = await Promise.allSettled(batchPromises);
+    for (let j = 0; j < batchResults.length; j++) {
+      const result = batchResults[j];
+      if (result.status === "fulfilled") {
+        results.push(result.value);
+      } else {
+        results.push({
+          spec: batch[j],
+          success: false,
+          error: result.reason instanceof Error ? result.reason.message : String(result.reason)
+        });
+      }
+    }
+  }
+  return results;
+}
+async function executeSequential(specs, createGenerator) {
+  console.log(`
+Executing ${specs.length} spec(s) sequentially...
+`);
+  const results = [];
+  for (let i = 0; i < specs.length; i++) {
+    const result = await processSpec(specs[i], i, specs.length, createGenerator);
+    results.push(result);
+  }
+  return results;
+}
+function printSummary(summary) {
+  console.log(`
+${"=".repeat(50)}`);
+  console.log("Batch Execution Summary");
+  console.log("=".repeat(50));
+  console.log(`Total specs: ${summary.total}`);
+  console.log(`Successful: ${summary.successful}`);
+  console.log(`Failed: ${summary.failed}`);
+  if (summary.failed > 0) {
+    console.log("\nFailed specs:");
+    for (const result of summary.results) {
+      if (!result.success) {
+        const specInput = result.spec.input || "spec";
+        console.error(`  \u2717 ${specInput}`);
+        console.error(`    Error: ${result.error}`);
+      }
+    }
+  }
+  console.log(`${"=".repeat(50)}
+`);
+}
+async function executeBatch(specs, executionMode = "parallel", createGenerator, batchSize) {
+  if (specs.length === 0) {
+    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
+  }
+  let results = [];
+  try {
+    results = executionMode === "parallel" ? await executeParallel(specs, createGenerator, batchSize) : await executeSequential(specs, createGenerator);
+    const summary = {
+      total: results.length,
+      successful: results.filter((r) => r.success).length,
+      failed: results.filter((r) => !r.success).length,
+      results
+    };
+    printSummary(summary);
+    return summary;
+  } finally {
+    if (results.length > batchSize) {
+      for (const result of results) {
+        if (result.spec) {
+          result.spec = null;
+        }
+      }
+      if (global.gc) {
+        global.gc();
+      }
+    }
+  }
+}
+function getBatchExitCode(summary) {
+  return summary.failed > 0 ? 1 : 0;
+}
+
 // src/openapi-generator.ts
 init_cjs_shims();
 var import_node_fs = require("fs");
 var import_node_path = require("path");
+var import_minimatch2 = require("minimatch");
 var import_yaml = require("yaml");
 
 // src/generators/enum-generator.ts
@@ -5024,8 +5137,20 @@ init_cjs_shims();
 
 // src/utils/name-utils.ts
 init_cjs_shims();
+function sanitizeIdentifier(str) {
+  return str.replace(/[^a-zA-Z0-9._\-\s]+/g, "_");
+}
 function toCamelCase(str, options) {
-  let name = str.charAt(0).toLowerCase() + str.slice(1);
+  const sanitized = sanitizeIdentifier(str);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let name;
+  if (words.length === 0) {
+    name = str.charAt(0).toLowerCase() + str.slice(1);
+  } else if (words.length === 1) {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1);
+  } else {
+    name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (options == null ? void 0 : options.prefix) {
     const prefix = options.prefix.toLowerCase();
     name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
@@ -5038,12 +5163,23 @@ function toCamelCase(str, options) {
 }
 function toPascalCase(str) {
   const stringValue = String(str);
-  let result = stringValue.replace(/[^a-zA-Z0-9_]+/g, "_").split(/[-_]+/).filter((word) => word.length > 0).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  const isAlreadyValidCase = /^[a-zA-Z][a-zA-Z0-9]*$/.test(stringValue);
+  if (isAlreadyValidCase) {
+    return stringValue.charAt(0).toUpperCase() + stringValue.slice(1);
+  }
+  const sanitized = sanitizeIdentifier(stringValue);
+  const words = sanitized.split(/[.\-_\s]+/).filter((word) => word.length > 0);
+  let result;
+  if (words.length === 0) {
+    result = "Value";
+  } else {
+    result = words.map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+  }
   if (/^\d/.test(result)) {
     result = `N${result}`;
   }
   if (!result || /^_+$/.test(result)) {
-    result = "Value";
+    return "Value";
   }
   return result;
 }
@@ -5055,9 +5191,10 @@ function resolveRef(ref) {
 // src/generators/enum-generator.ts
 function generateEnum(name, values, options) {
   const schemaName = `${toCamelCase(name, options)}Schema`;
+  const typeName = toPascalCase(name);
   const enumValues = values.map((v) => `"${v}"`).join(", ");
   const schemaCode = `export const ${schemaName} = z.enum([${enumValues}]);`;
-  const typeCode = `export type ${name} = z.infer<typeof ${schemaName}>;`;
+  const typeCode = `export type ${typeName} = z.infer<typeof ${schemaName}>;`;
   return { schemaCode, typeCode };
 }
 
@@ -5165,6 +5302,9 @@ var LRUCache = class {
     this.cache = /* @__PURE__ */ new Map();
     this.maxSize = maxSize;
   }
+  get capacity() {
+    return this.maxSize;
+  }
   get(key) {
     if (!this.cache.has(key)) return void 0;
     const value = this.cache.get(key);
@@ -5195,6 +5335,77 @@ var LRUCache = class {
   }
 };
 
+// src/utils/pattern-utils.ts
+init_cjs_shims();
+function isRegexPattern(pattern) {
+  if (pattern.startsWith("^") || pattern.endsWith("$")) {
+    return true;
+  }
+  if (/\\[dDwWsS]/.test(pattern)) {
+    return true;
+  }
+  if (/\.\*|\.\+/.test(pattern)) {
+    return true;
+  }
+  if (/[[\]()]/.test(pattern)) {
+    return true;
+  }
+  if (/[^/][+?*]\{/.test(pattern)) {
+    return true;
+  }
+  return false;
+}
+function patternToRegex(pattern) {
+  if (pattern instanceof RegExp) {
+    return pattern;
+  }
+  if (isRegexPattern(pattern)) {
+    try {
+      return new RegExp(pattern);
+    } catch (error) {
+      console.warn(`\u26A0\uFE0F  Invalid regex pattern "${pattern}": ${error instanceof Error ? error.message : String(error)}`);
+      return null;
+    }
+  }
+  return null;
+}
+function stripPrefix(input, pattern, ensureLeadingChar) {
+  if (!pattern) {
+    return input;
+  }
+  const regex = patternToRegex(pattern);
+  if (regex) {
+    const match = input.match(regex);
+    if (match && match.index === 0) {
+      const stripped = input.substring(match[0].length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  } else {
+    const stringPattern = pattern;
+    if (input.startsWith(stringPattern)) {
+      const stripped = input.substring(stringPattern.length);
+      if (ensureLeadingChar) {
+        if (stripped === "") {
+          return ensureLeadingChar;
+        }
+        if (!stripped.startsWith(ensureLeadingChar)) {
+          return `${ensureLeadingChar}${stripped}`;
+        }
+      }
+      return stripped;
+    }
+  }
+  return input;
+}
+
 // src/validators/array-validator.ts
 init_cjs_shims();
 function generateArrayValidation(schema, context) {
@@ -5722,6 +5933,11 @@ ${properties.join(",\n")}
 // src/validators/string-validator.ts
 init_cjs_shims();
 var PATTERN_CACHE = new LRUCache(1e3);
+function configurePatternCache(size) {
+  if (size > 0 && size !== PATTERN_CACHE.capacity) {
+    PATTERN_CACHE = new LRUCache(size);
+  }
+}
 var FORMAT_MAP = {
   uuid: "z.uuid()",
   email: "z.email()",
@@ -6054,8 +6270,9 @@ var _PropertyGenerator = class _PropertyGenerator {
         }
         (_a = this.context.schemaDependencies.get(currentSchema)) == null ? void 0 : _a.add(refName);
       }
-      const schemaName = `${toCamelCase(resolvedRefName, this.context.namingOptions)}Schema`;
-      if (currentSchema && this.isCircularThroughAlias(currentSchema, refName)) {
+      const strippedRefName = stripPrefix(resolvedRefName, this.context.stripSchemaPrefix);
+      const schemaName = `${toCamelCase(strippedRefName, this.context.namingOptions)}Schema`;
+      if (currentSchema && (refName === currentSchema || this.isCircularThroughAlias(currentSchema, refName))) {
         const lazySchema = `z.lazy((): z.ZodTypeAny => ${schemaName})`;
         return wrapNullable(lazySchema, nullable);
       }
@@ -6343,7 +6560,7 @@ var OpenApiGenerator = class {
     this.schemaUsageMap = /* @__PURE__ */ new Map();
     this.needsZodImport = true;
     this.filterStats = createFilterStatistics();
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     if (!options.input) {
       throw new ConfigurationError("Input path is required", { providedOptions: options });
     }
@@ -6356,11 +6573,18 @@ var OpenApiGenerator = class {
       schemaType: options.schemaType || "all",
       prefix: options.prefix,
       suffix: options.suffix,
+      stripSchemaPrefix: options.stripSchemaPrefix,
       showStats: (_c = options.showStats) != null ? _c : true,
       request: options.request,
       response: options.response,
-      operationFilters: options.operationFilters
+      operationFilters: options.operationFilters,
+      ignoreHeaders: options.ignoreHeaders,
+      cacheSize: (_d = options.cacheSize) != null ? _d : 1e3,
+      batchSize: (_e = options.batchSize) != null ? _e : 10
     };
+    if (this.options.cacheSize) {
+      configurePatternCache(this.options.cacheSize);
+    }
     try {
       const fs = require("fs");
       if (!fs.existsSync(this.options.input)) {
@@ -6426,7 +6650,8 @@ var OpenApiGenerator = class {
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
   }
   /**
@@ -6460,9 +6685,11 @@ var OpenApiGenerator = class {
       const typeCode = this.types.get(name);
       if (schemaCode) {
         output.push(schemaCode);
-        if (!schemaCode.includes(`export type ${name}`)) {
-          const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
-          output.push(`export type ${name} = z.infer<typeof ${schemaName}>;`);
+        const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+        const typeName = toPascalCase(strippedName);
+        if (!schemaCode.includes(`export type ${typeName}`)) {
+          const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+          output.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
         }
         output.push("");
       } else if (typeCode) {
@@ -6496,6 +6723,7 @@ var OpenApiGenerator = class {
     const normalizedOutput = (0, import_node_path.normalize)(this.options.output);
     this.ensureDirectoryExists(normalizedOutput);
     (0, import_node_fs.writeFileSync)(normalizedOutput, output);
+    console.log(`  \u2713 Generated ${normalizedOutput}`);
   }
   /**
    * Resolve options for a specific context (request or response)
@@ -6777,7 +7005,8 @@ var OpenApiGenerator = class {
     const resolvedOptions = context === "response" ? this.responseOptions : this.requestOptions;
     if (schema.enum) {
       const jsdoc2 = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
-      const { schemaCode, typeCode } = generateEnum(name, schema.enum, {
+      const strippedName2 = stripPrefix(name, this.options.stripSchemaPrefix);
+      const { schemaCode, typeCode } = generateEnum(strippedName2, schema.enum, {
         prefix: this.options.prefix,
         suffix: this.options.suffix
       });
@@ -6786,7 +7015,8 @@ ${typeCode}`;
       this.schemas.set(name, enumSchemaCode);
       return;
     }
-    const schemaName = `${toCamelCase(name, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
+    const strippedName = stripPrefix(name, this.options.stripSchemaPrefix);
+    const schemaName = `${toCamelCase(strippedName, { prefix: this.options.prefix, suffix: this.options.suffix })}Schema`;
     const jsdoc = generateJSDoc(schema, name, { includeDescriptions: resolvedOptions.includeDescriptions });
     if (schema.allOf && schema.allOf.length === 1 && schema.allOf[0].$ref) {
       const refName = resolveRef(schema.allOf[0].$ref);
@@ -6802,7 +7032,8 @@ ${typeCode}`;
       namingOptions: {
         prefix: this.options.prefix,
         suffix: this.options.suffix
-      }
+      },
+      stripSchemaPrefix: this.options.stripSchemaPrefix
     });
     const isAlias = !!(schema.$ref && !schema.properties && !schema.allOf && !schema.oneOf && !schema.anyOf);
     const zodSchema = this.propertyGenerator.generatePropertySchema(schema, name, isAlias);
@@ -6906,6 +7137,24 @@ ${propsCode}
       }
     }
   }
+  /**
+   * Check if a header should be ignored based on filter patterns
+   * @internal
+   */
+  shouldIgnoreHeader(headerName) {
+    const ignorePatterns = this.options.ignoreHeaders;
+    if (!ignorePatterns || ignorePatterns.length === 0) {
+      return false;
+    }
+    if (ignorePatterns.includes("*")) {
+      return true;
+    }
+    const headerLower = headerName.toLowerCase();
+    return ignorePatterns.some((pattern) => {
+      const patternLower = pattern.toLowerCase();
+      return (0, import_minimatch2.minimatch)(headerLower, patternLower);
+    });
+  }
   /**
    * Generate header parameter schemas for each operation
    * Header parameters are always string type (HTTP header semantics)
@@ -6928,7 +7177,7 @@ ${propsCode}
           continue;
         }
         const headerParams = operation.parameters.filter(
-          (param) => param && typeof param === "object" && param.in === "header"
+          (param) => param && typeof param === "object" && param.in === "header" && !this.shouldIgnoreHeader(param.name)
         );
         if (headerParams.length === 0) {
           continue;
@@ -6986,7 +7235,8 @@ ${propsCode}
   generateQueryParamType(schema, param) {
     if (schema.$ref) {
       const refName = resolveRef(schema.$ref);
-      const schemaName = toCamelCase(refName, { prefix: this.options.prefix, suffix: this.options.suffix });
+      const strippedRefName = stripPrefix(refName, this.options.stripSchemaPrefix);
+      const schemaName = toCamelCase(strippedRefName, { prefix: this.options.prefix, suffix: this.options.suffix });
       return `${schemaName}Schema`;
     }
     if (schema.enum) {
@@ -7125,110 +7375,13 @@ ${propsCode}
   }
 };
 
-// src/batch-executor.ts
-async function processSpec(spec, index, total) {
-  console.log(`Processing [${index + 1}/${total}] ${spec.input}...`);
-  try {
-    const generator = new OpenApiGenerator(spec);
-    generator.generate();
-    console.log(`\u2713 Successfully generated ${spec.output}`);
-    return {
-      spec,
-      success: true
-    };
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    console.error(`\u2717 Failed to generate ${spec.output}: ${errorMessage}`);
-    return {
-      spec,
-      success: false,
-      error: errorMessage
-    };
-  }
-}
-async function executeParallel(specs) {
-  console.log(`
-Executing ${specs.length} spec(s) in parallel...
-`);
-  const promises = specs.map((spec, index) => processSpec(spec, index, specs.length));
-  const results = await Promise.allSettled(promises);
-  return results.map((result, index) => {
-    if (result.status === "fulfilled") {
-      return result.value;
-    }
-    return {
-      spec: specs[index],
-      success: false,
-      error: result.reason instanceof Error ? result.reason.message : String(result.reason)
-    };
-  });
-}
-async function executeSequential(specs) {
-  console.log(`
-Executing ${specs.length} spec(s) sequentially...
-`);
-  const results = [];
-  for (let i = 0; i < specs.length; i++) {
-    const result = await processSpec(specs[i], i, specs.length);
-    results.push(result);
-  }
-  return results;
-}
-function printSummary(summary) {
-  console.log(`
-${"=".repeat(50)}`);
-  console.log("Batch Execution Summary");
-  console.log("=".repeat(50));
-  console.log(`Total specs: ${summary.total}`);
-  console.log(`Successful: ${summary.successful}`);
-  console.log(`Failed: ${summary.failed}`);
-  if (summary.failed > 0) {
-    console.log("\nFailed specs:");
-    for (const result of summary.results) {
-      if (!result.success) {
-        console.error(`  \u2717 ${result.spec.input}`);
-        console.error(`    Error: ${result.error}`);
-      }
-    }
-  }
-  console.log(`${"=".repeat(50)}
-`);
-}
-async function executeBatch(specs, executionMode = "parallel") {
-  if (specs.length === 0) {
-    throw new ConfigurationError("No specs provided for batch execution", { specsCount: 0, executionMode });
-  }
-  let results = [];
-  try {
-    results = executionMode === "parallel" ? await executeParallel(specs) : await executeSequential(specs);
-    const summary = {
-      total: results.length,
-      successful: results.filter((r) => r.success).length,
-      failed: results.filter((r) => !r.success).length,
-      results
-    };
-    printSummary(summary);
-    return summary;
-  } finally {
-    if (results.length > 10) {
-      for (const result of results) {
-        if (result.spec) {
-          result.spec = null;
-        }
-      }
-      if (global.gc) {
-        global.gc();
-      }
-    }
-  }
-}
-function getBatchExitCode(summary) {
-  return summary.failed > 0 ? 1 : 0;
-}
-
 // src/utils/config-loader.ts
 init_cjs_shims();
 var import_cosmiconfig = require("cosmiconfig");
+var import_zod2 = require("zod");
+
+// src/utils/config-schemas.ts
+init_cjs_shims();
 var import_zod = require("zod");
 var RequestResponseOptionsSchema = import_zod.z.strictObject({
   mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
@@ -7246,38 +7399,37 @@ var OperationFiltersSchema = import_zod.z.strictObject({
   excludeOperationIds: import_zod.z.array(import_zod.z.string()).optional(),
   excludeDeprecated: import_zod.z.boolean().optional()
 });
-var OpenApiGeneratorOptionsSchema = import_zod.z.strictObject({
-  mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
-  input: import_zod.z.string(),
-  output: import_zod.z.string(),
-  includeDescriptions: import_zod.z.boolean().optional(),
-  useDescribe: import_zod.z.boolean().optional(),
-  schemaType: import_zod.z.enum(["all", "request", "response"]).optional(),
-  prefix: import_zod.z.string().optional(),
-  suffix: import_zod.z.string().optional(),
-  showStats: import_zod.z.boolean().optional(),
-  request: RequestResponseOptionsSchema.optional(),
-  response: RequestResponseOptionsSchema.optional(),
-  name: import_zod.z.string().optional(),
-  operationFilters: OperationFiltersSchema.optional()
-});
-var ConfigFileSchema = import_zod.z.strictObject({
-  defaults: import_zod.z.strictObject({
-    mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
-    includeDescriptions: import_zod.z.boolean().optional(),
-    useDescribe: import_zod.z.boolean().optional(),
-    schemaType: import_zod.z.enum(["all", "request", "response"]).optional(),
-    prefix: import_zod.z.string().optional(),
-    suffix: import_zod.z.string().optional(),
-    showStats: import_zod.z.boolean().optional(),
-    request: RequestResponseOptionsSchema.optional(),
-    response: RequestResponseOptionsSchema.optional(),
-    operationFilters: OperationFiltersSchema.optional()
-  }).optional(),
-  specs: import_zod.z.array(OpenApiGeneratorOptionsSchema).min(1, "At least one spec is required"),
-  executionMode: import_zod.z.enum(["parallel", "sequential"]).optional()
-});
-var createTypeScriptLoader = () => {
+
+// src/utils/config-validation.ts
+init_cjs_shims();
+function formatConfigValidationError(error, filepath, configPath, additionalNotes) {
+  var _a;
+  const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
+    const path = err.path.length > 0 ? err.path.join(".") : "root";
+    return `  - ${path}: ${err.message}`;
+  }).join("\n")) || "Unknown validation error";
+  const configSource = filepath || configPath || "config file";
+  const lines = [
+    `Invalid configuration file at: ${configSource}`,
+    "",
+    "Validation errors:",
+    formattedErrors,
+    "",
+    "Please check your configuration file and ensure:",
+    "  - All required fields are present (specs array with input/output)",
+    "  - Field names are spelled correctly (no typos)",
+    "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
+    "  - No unknown/extra properties are included"
+  ];
+  if (additionalNotes && additionalNotes.length > 0) {
+    lines.push(...additionalNotes.map((note) => `  - ${note}`));
+  }
+  return lines.join("\n");
+}
+
+// src/utils/typescript-loader.ts
+init_cjs_shims();
+function createTypeScriptLoader() {
   return async (filepath) => {
     try {
       const esbuild = await import("esbuild");
@@ -7308,9 +7460,51 @@ var createTypeScriptLoader = () => {
       );
     }
   };
-};
+}
+
+// src/utils/config-loader.ts
+var OpenApiGeneratorOptionsSchema = import_zod2.z.strictObject({
+  mode: import_zod2.z.enum(["strict", "normal", "loose"]).optional(),
+  input: import_zod2.z.string(),
+  output: import_zod2.z.string(),
+  includeDescriptions: import_zod2.z.boolean().optional(),
+  useDescribe: import_zod2.z.boolean().optional(),
+  schemaType: import_zod2.z.enum(["all", "request", "response"]).optional(),
+  prefix: import_zod2.z.string().optional(),
+  suffix: import_zod2.z.string().optional(),
+  stripSchemaPrefix: import_zod2.z.string().optional(),
+  showStats: import_zod2.z.boolean().optional(),
+  request: RequestResponseOptionsSchema.optional(),
+  response: RequestResponseOptionsSchema.optional(),
+  name: import_zod2.z.string().optional(),
+  operationFilters: OperationFiltersSchema.optional(),
+  cacheSize: import_zod2.z.number().positive().optional(),
+  batchSize: import_zod2.z.number().positive().optional()
+});
+var ConfigFileSchema = import_zod2.z.strictObject({
+  defaults: import_zod2.z.strictObject({
+    mode: import_zod2.z.enum(["strict", "normal", "loose"]).optional(),
+    includeDescriptions: import_zod2.z.boolean().optional(),
+    useDescribe: import_zod2.z.boolean().optional(),
+    schemaType: import_zod2.z.enum(["all", "request", "response"]).optional(),
+    prefix: import_zod2.z.string().optional(),
+    suffix: import_zod2.z.string().optional(),
+    stripSchemaPrefix: import_zod2.z.string().optional(),
+    showStats: import_zod2.z.boolean().optional(),
+    request: RequestResponseOptionsSchema.optional(),
+    response: RequestResponseOptionsSchema.optional(),
+    operationFilters: OperationFiltersSchema.optional(),
+    cacheSize: import_zod2.z.number().positive().optional(),
+    batchSize: import_zod2.z.number().positive().optional()
+  }).optional(),
+  specs: import_zod2.z.array(OpenApiGeneratorOptionsSchema).min(1, {
+    message: "Configuration must include at least one specification. Each specification should have 'input' and 'output' paths."
+  }).refine((specs) => specs.every((spec) => spec.input && spec.output), {
+    message: "Each specification must have both 'input' and 'output' paths defined"
+  }),
+  executionMode: import_zod2.z.enum(["parallel", "sequential"]).optional()
+});
 async function loadConfig(configPath) {
-  var _a;
   const explorer = (0, import_cosmiconfig.cosmiconfig)("openapi-to-zod", {
     searchPlaces: ["openapi-to-zod.config.ts", "openapi-to-zod.config.json", "package.json"],
     loaders: {
@@ -7325,31 +7519,15 @@ async function loadConfig(configPath) {
   }
   if (!result || !result.config) {
     throw new Error(
-      configPath ? `Config file not found at: ${configPath}` : "No config file found. Searched for: openapi-to-zod.config.ts, openapi-to-zod.config.json, package.json (openapi-to-zod key)"
+      configPath ? `Config file not found at: ${configPath}` : "No config file found. Searched for: openapi-to-zod.config.ts, openapi-to-zod.config.json, package.json (openapi-to-zod key)\nRun 'openapi-to-zod init' to create a new config file."
     );
   }
   try {
     const validatedConfig = ConfigFileSchema.parse(result.config);
     return validatedConfig;
   } catch (error) {
-    if (error instanceof import_zod.z.ZodError) {
-      const formattedErrors = ((_a = error.issues) == null ? void 0 : _a.map((err) => {
-        const path = err.path.length > 0 ? err.path.join(".") : "root";
-        return `  - ${path}: ${err.message}`;
-      }).join("\n")) || "Unknown validation error";
-      const configSource = result.filepath || configPath || "config file";
-      const errorMessage = [
-        `Invalid configuration file at: ${configSource}`,
-        "",
-        "Validation errors:",
-        formattedErrors,
-        "",
-        "Please check your configuration file and ensure:",
-        "  - All required fields are present (specs array with input/output)",
-        "  - Field names are spelled correctly (no typos)",
-        "  - Values match the expected types (e.g., mode: 'strict' | 'normal' | 'loose')",
-        "  - No unknown/extra properties are included"
-      ].join("\n");
+    if (error instanceof import_zod2.z.ZodError) {
+      const errorMessage = formatConfigValidationError(error, result.filepath, configPath);
       throw new Error(errorMessage);
     }
     throw error;
@@ -7384,17 +7562,13 @@ program.name("openapi-to-zod").description("Generate Zod v4 schemas from OpenAPI
   `
 Examples:
   # Create a new config file
-  $ openapi-to-zod --init
+  $ openapi-to-zod init
 
   # Generate with auto-discovered config
   $ openapi-to-zod
 
   # Generate with custom config path
   $ openapi-to-zod --config custom.config.ts
-
-Breaking Changes (v2.0):
-  CLI options removed. Use configuration file instead.
-  Run 'openapi-to-zod --init' to create a config file.
 `
 ).action(async (options) => {
   try {
@@ -7451,17 +7625,12 @@ function findSpecFiles() {
   return { files, totalCount };
 }
 async function executeConfigMode(options) {
-  let config;
-  try {
-    config = await loadConfig(options.config);
-  } catch {
-    throw new CliOptionsError("No config file found. Run 'openapi-to-zod --init' to create one.", {
-      configPath: options.config
-    });
-  }
+  var _a, _b;
+  const config = await loadConfig(options.config);
   const specs = mergeConfigWithDefaults(config);
   const executionMode = config.executionMode || "parallel";
-  const summary = await executeBatch(specs, executionMode);
+  const batchSize = (_b = (_a = specs[0]) == null ? void 0 : _a.batchSize) != null ? _b : 10;
+  const summary = await executeBatch(specs, executionMode, (spec) => new OpenApiGenerator(spec), batchSize);
   const exitCode = getBatchExitCode(summary);
   if (exitCode !== 0) {
     process.exit(exitCode);
@@ -7585,7 +7754,7 @@ export default defineConfig({
     mode: 'strict',
     includeDescriptions: true,
 	useDescribe: false,
-    showStats: false,
+    showStats: true,
 	schemaType: 'all',
   },
   specs: [