@codewithagents/openapi-server 1.6.0 → 1.8.0

package/dist/cli.cjs

@@ -18414,7 +18414,7 @@ var import_node_path4 = require("node:path");
 var import_promises2 = require("node:fs/promises");
 var import_node_path2 = require("node:path");
 
-// ../openapi-gen/dist/config-core.js
+// ../openapi-zod-ts/dist/config-core.js
 var import_promises = require("node:fs/promises");
 var import_node_path = require("node:path");
 var import_node_url = require("node:url");
@@ -18475,44 +18475,46 @@ function validateInputPath(resolvedInput) {
     }
   }
 }
-async function loadConfigFile(opts) {
-  const resolvedConfigPath = opts.configPath ?? (0, import_node_path.join)(opts.cwd, opts.defaultFileName);
-  if (opts.configPath !== void 0) {
-    validateConfigPath(opts.configPath);
+async function loadJsConfig(resolvedConfigPath) {
+  let mod;
+  try {
+    mod = await import((0, import_node_url.pathToFileURL)(resolvedConfigPath).href);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load JS config file: ${resolvedConfigPath}
+${message}`);
   }
-  let raw;
+  const exported = mod["default"] ?? mod;
+  if (typeof exported !== "object" || exported === null) {
+    throw new Error("Config must be a JSON object");
+  }
+  return exported;
+}
+async function loadJsonConfig(resolvedConfigPath) {
+  let fileContents;
+  try {
+    fileContents = await (0, import_promises.readFile)(resolvedConfigPath, "utf-8");
+  } catch {
+    throw new Error(`Config file not found: ${resolvedConfigPath}`);
+  }
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(fileContents);
+  } catch {
+    throw new Error(`Config file is not valid JSON: ${resolvedConfigPath}`);
+  }
+  if (typeof parsed2 !== "object" || parsed2 === null) {
+    throw new Error("Config must be a JSON object");
+  }
+  return parsed2;
+}
+async function loadRawConfig(resolvedConfigPath) {
   if (isJsConfigPath(resolvedConfigPath)) {
-    let mod;
-    try {
-      mod = await import((0, import_node_url.pathToFileURL)(resolvedConfigPath).href);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to load JS config file: ${resolvedConfigPath}
-${message}`);
-    }
-    const exported = mod["default"] ?? mod;
-    if (typeof exported !== "object" || exported === null) {
-      throw new Error("Config must be a JSON object");
-    }
-    raw = exported;
-  } else {
-    let fileContents;
-    try {
-      fileContents = await (0, import_promises.readFile)(resolvedConfigPath, "utf-8");
-    } catch {
-      throw new Error(`Config file not found: ${resolvedConfigPath}`);
-    }
-    let parsed2;
-    try {
-      parsed2 = JSON.parse(fileContents);
-    } catch {
-      throw new Error(`Config file is not valid JSON: ${resolvedConfigPath}`);
-    }
-    if (typeof parsed2 !== "object" || parsed2 === null) {
-      throw new Error("Config must be a JSON object");
-    }
-    raw = parsed2;
+    return loadJsConfig(resolvedConfigPath);
   }
+  return loadJsonConfig(resolvedConfigPath);
+}
+function parseBaseConfig(raw, cwd) {
   if (typeof raw["input_openapi"] !== "string" || !raw["input_openapi"]) {
     throw new Error('Config missing required field: "input_openapi" (path to OpenAPI 3.1 spec)');
   }
@@ -18521,40 +18523,86 @@ ${message}`);
   }
   const input_openapi = raw["input_openapi"];
   const output = raw["output"];
-  validateInputPath((0, import_node_path.resolve)(opts.cwd, input_openapi));
-  validateOutputPath((0, import_node_path.resolve)(opts.cwd, output));
-  const base = { input_openapi, output };
-  return opts.parse(raw, base, opts.cwd);
+  validateInputPath((0, import_node_path.resolve)(cwd, input_openapi));
+  validateOutputPath((0, import_node_path.resolve)(cwd, output));
+  return { input_openapi, output };
 }
-
-// src/config.ts
-async function loadConfig(cwd, configPath) {
-  return loadConfigFile({
-    cwd,
-    configPath,
-    defaultFileName: "openapi-server.config.json",
-    parse: (raw) => {
-      const framework = raw["framework"];
-      if (framework !== void 0 && framework !== "hono" && framework !== "express" && framework !== "fastify" && framework !== "none") {
-        throw new Error('"framework" must be one of: "hono", "express", "fastify", or "none"');
-      }
-      if (raw["input_schema"] !== void 0 && (typeof raw["input_schema"] !== "string" || !raw["input_schema"])) {
-        throw new Error('"input_schema" must be a non-empty string path to your Zod schema file');
-      }
-      return {
-        input_openapi: raw["input_openapi"],
-        output: raw["output"],
-        framework,
-        input_schema: raw["input_schema"]
-      };
+async function prepareRaw(opts) {
+  const resolvedConfigPath = opts.configPath ?? (0, import_node_path.join)(opts.cwd, opts.defaultFileName);
+  if (opts.configPath !== void 0) {
+    validateConfigPath(opts.configPath);
+  }
+  return { raw: await loadRawConfig(resolvedConfigPath) };
+}
+function parseProjectEntry(entry, index, opts) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw new Error(`projects[${index}]: entry must be a config object`);
+  }
+  const projectRaw = entry;
+  let base;
+  try {
+    base = parseBaseConfig(projectRaw, opts.cwd);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`projects[${index}]: ${message}`);
+  }
+  try {
+    return opts.parse(projectRaw, base, opts.cwd);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`projects[${index}]: ${message}`);
+  }
+}
+async function loadConfigsFile(opts) {
+  const { raw } = await prepareRaw(opts);
+  if ("projects" in raw) {
+    return parseProjectsArray(raw, opts);
+  }
+  const base = parseBaseConfig(raw, opts.cwd);
+  return [opts.parse(raw, base, opts.cwd)];
+}
+function parseProjectsArray(raw, opts) {
+  const hasTopLevelInput = "input_openapi" in raw && raw["input_openapi"] !== void 0;
+  const hasTopLevelOutput = "output" in raw && raw["output"] !== void 0;
+  if (hasTopLevelInput || hasTopLevelOutput) {
+    throw new Error('Config cannot have both top-level "input_openapi"/"output" and a "projects" array. Use one form or the other.');
+  }
+  const projects = raw["projects"];
+  if (!Array.isArray(projects)) {
+    throw new Error('"projects" must be an array of config objects');
+  }
+  if (projects.length === 0) {
+    throw new Error('"projects" array must contain at least one config entry');
+  }
+  return projects.map((entry, index) => parseProjectEntry(entry, index, opts));
+}
+async function runProjects(configs, generateOne2) {
+  if (configs.length === 0) {
+    throw new Error("runProjects requires at least one config entry");
+  }
+  if (configs.length === 1) {
+    await generateOne2(configs[0]);
+    return;
+  }
+  for (let i = 0; i < configs.length; i++) {
+    const label = `${i + 1}/${configs.length}`;
+    console.log(`
+[${label}] generating ${configs[i].input_openapi}...`);
+    try {
+      await generateOne2(configs[i], label);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`[${label}] Project failed (${configs[i].input_openapi}): ${message}`);
     }
-  });
+  }
+  console.log(`
+All ${configs.length} projects generated successfully.`);
 }
 
-// ../openapi-gen/dist/parser.js
+// ../openapi-zod-ts/dist/parser.js
 var import_swagger_parser = __toESM(require_lib4(), 1);
 
-// ../openapi-gen/dist/utils/schema-depth.js
+// ../openapi-zod-ts/dist/utils/schema-depth.js
 var MAX_SCHEMA_DEPTH = 100;
 function isRef(schema) {
   return "$ref" in schema;
@@ -18594,7 +18642,7 @@ function assertBoundedDepth(root) {
   }
 }
 
-// ../openapi-gen/dist/utils/normalize-nullable.js
+// ../openapi-zod-ts/dist/utils/normalize-nullable.js
 function isRef2(schema) {
   return "$ref" in schema;
 }
@@ -18765,7 +18813,7 @@ function normalizeNullable(spec) {
   walkPathSchemas(spec, visited);
 }
 
-// ../openapi-gen/dist/parser.js
+// ../openapi-zod-ts/dist/parser.js
 async function parseSpec(inputPath) {
   const api = await import_swagger_parser.default.bundle(inputPath);
   for (const schema of Object.values(api.components?.schemas ?? {})) {
@@ -18775,7 +18823,7 @@ async function parseSpec(inputPath) {
   return api;
 }
 
-// ../openapi-gen/dist/utils/naming.js
+// ../openapi-zod-ts/dist/utils/naming.js
 function toTypeName(name) {
   const parts = name.split(/[^a-zA-Z0-9]+/).filter(Boolean);
   if (parts.length === 0)
@@ -18787,7 +18835,31 @@ function toTypeName(name) {
   return safe.length > 0 ? safe : "_";
 }
 
-// src/plugins/service.ts
+// src/config.ts
+function parseServerConfig(raw, base) {
+  const framework = raw["framework"];
+  if (framework !== void 0 && framework !== "hono" && framework !== "express" && framework !== "fastify" && framework !== "none") {
+    throw new Error('"framework" must be one of: "hono", "express", "fastify", or "none"');
+  }
+  if (raw["input_schema"] !== void 0 && (typeof raw["input_schema"] !== "string" || !raw["input_schema"])) {
+    throw new Error('"input_schema" must be a non-empty string path to your Zod schema file');
+  }
+  return {
+    ...base,
+    framework,
+    input_schema: raw["input_schema"]
+  };
+}
+async function loadConfigs2(cwd, configPath) {
+  return loadConfigsFile({
+    cwd,
+    configPath,
+    defaultFileName: "openapi-server.config.json",
+    parse: parseServerConfig
+  });
+}
+
+// src/plugins/shared.ts
 var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete"];
 function isRef3(obj) {
   return typeof obj === "object" && obj !== null && "$ref" in obj;
@@ -18799,7 +18871,7 @@ function refToName(ref) {
 function extractPathParamsFromPath(path) {
   const matches = path.match(/\{([^}]+)\}/g);
   if (matches === null) return [];
-  return matches.map((m) => sanitizeOperationId2(m.slice(1, -1)));
+  return matches.map((m) => m.slice(1, -1));
 }
 function resolveParam(p, spec) {
   if (!isRef3(p)) return p;
@@ -18866,6 +18938,13 @@ function normalizeParamName(name) {
   const camel = parts.map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
   return /^[^a-zA-Z_$]/.test(camel) ? `_${camel}` : camel;
 }
+function schemaToTsType(schema) {
+  if (schema === void 0 || isRef3(schema)) return "string";
+  const s = schema;
+  if (s.type === "number" || s.type === "integer") return "number";
+  if (s.type === "boolean") return "boolean";
+  return "string";
+}
 function getQueryParams(operation, spec) {
   const parameters = operation.parameters;
   if (parameters === void 0) return [];
@@ -18874,15 +18953,9 @@ function getQueryParams(operation, spec) {
     const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "query") continue;
     const schema = resolved.schema;
-    let tsType = "string";
-    if (schema !== void 0 && !isRef3(schema)) {
-      const s = schema;
-      if (s.type === "number" || s.type === "integer") tsType = "number";
-      else if (s.type === "boolean") tsType = "boolean";
-    }
     result.push({
       name: normalizeParamName(resolved.name),
-      tsType,
+      tsType: schemaToTsType(schema),
       required: resolved.required === true
     });
   }
@@ -18903,6 +18976,8 @@ function getBodyInfo(operation) {
   }
   return { typeName: void 0 };
 }
+
+// src/plugins/service.ts
 function getReturnInfo(operation) {
   const responses = operation.responses;
   if (responses === void 0) return { typeName: void 0, isArray: false, isVoid: true };
@@ -18978,7 +19053,7 @@ function collectOperations(spec) {
 function buildMethodSignature(op) {
   const args = [];
   for (const p of op.pathParams) {
-    args.push(`${p}: string`);
+    args.push(`${sanitizeOperationId2(p)}: string`);
   }
   if (op.bodyInfo !== void 0) {
     const typeName = op.bodyInfo.typeName ?? "unknown";
@@ -19028,110 +19103,9 @@ function generateService(spec) {
 }
 
 // src/plugins/router.ts
-var SUPPORTED_METHODS2 = ["get", "post", "put", "patch", "delete"];
-function isRef4(obj) {
-  return typeof obj === "object" && obj !== null && "$ref" in obj;
-}
-function refToName2(ref) {
-  const parts = ref.split("/");
-  return toTypeName(parts[parts.length - 1]);
-}
-function extractPathParamsFromPath2(path) {
-  const matches = path.match(/\{([^}]+)\}/g);
-  if (matches === null) return [];
-  return matches.map((m) => m.slice(1, -1));
-}
 function toHonoPath(openapiPath) {
   return openapiPath.replace(/\{([^}]+)\}/g, ":$1");
 }
-function resolveParam2(p, spec) {
-  if (!isRef4(p)) return p;
-  const refStr = p.$ref;
-  const name = refToName2(refStr);
-  const components = spec.components;
-  if (components?.parameters === void 0) return void 0;
-  const resolved = components.parameters[name];
-  if (resolved === void 0 || isRef4(resolved)) return void 0;
-  return resolved;
-}
-function deriveServiceName2(spec) {
-  const title = spec.info?.title ?? "";
-  const pascal = title.replace(/[^a-zA-Z0-9 ]/g, "").split(/\s+/).filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-  if (pascal.length === 0) return "ApiService";
-  const safePascal = /^[0-9]/.test(pascal) ? `_${pascal}` : pascal;
-  if (safePascal.endsWith("Service")) return safePascal;
-  return `${safePascal}Service`;
-}
-function sanitizeOperationId3(id) {
-  const parts = id.replace(/'/g, "").split(/[^a-zA-Z0-9]+/).filter(Boolean);
-  if (parts.length === 0) return "unknown";
-  const [first = "", ...rest] = parts;
-  const camel = first.charAt(0).toLowerCase() + first.slice(1) + rest.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
-  return /^[0-9]/.test(camel) ? `_${camel}` : camel;
-}
-function deriveMethodName2(operationId, method, path) {
-  if (operationId !== void 0 && operationId.length > 0) {
-    return sanitizeOperationId3(operationId);
-  }
-  return deriveOperationName3(method, path);
-}
-function deriveOperationName3(method, path) {
-  const prefixMap = {
-    get: "get",
-    post: "create",
-    put: "update",
-    patch: "patch",
-    delete: "delete"
-  };
-  const prefix = prefixMap[method] ?? method;
-  const segments = path.replace(/^\/api\/v\d+\//, "").replace(/^\//, "");
-  const parts = segments.split("/").map((seg) => {
-    const paramMatches = seg.match(/\{([^}]+)\}/g);
-    if (paramMatches !== null && !(seg.startsWith("{") && seg.endsWith("}"))) {
-      return paramMatches.map((m) => {
-        const name = sanitizeOperationId3(m.slice(1, -1));
-        return "By" + name.charAt(0).toUpperCase() + name.slice(1);
-      }).join("");
-    }
-    if (seg.startsWith("{") && seg.endsWith("}")) {
-      const name = seg.slice(1, -1);
-      const sanitized = sanitizeOperationId3(name);
-      return "By" + sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
-    }
-    return toTypeName(seg);
-  });
-  return prefix + parts.join("");
-}
-function normalizeParamName2(name) {
-  const stripped = name.replace(/\[\]$/, "").replace(/'/g, "");
-  const parts = stripped.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-  if (parts.length === 0) return "_";
-  const camel = parts.map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
-  return /^[^a-zA-Z_$]/.test(camel) ? `_${camel}` : camel;
-}
-function schemaToTsType(schema) {
-  if (schema === void 0 || isRef4(schema)) return "string";
-  const s = schema;
-  if (s.type === "number" || s.type === "integer") return "number";
-  if (s.type === "boolean") return "boolean";
-  return "string";
-}
-function getQueryParams2(operation, spec) {
-  const parameters = operation.parameters;
-  if (parameters === void 0) return [];
-  const result = [];
-  for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
-    if (resolved === void 0 || resolved.in !== "query") continue;
-    const schema = resolved.schema;
-    result.push({
-      name: normalizeParamName2(resolved.name),
-      tsType: schemaToTsType(schema),
-      required: resolved.required === true
-    });
-  }
-  return result;
-}
 function formatToZodModifier(format) {
   switch (format) {
     case "uuid":
@@ -19148,7 +19122,7 @@ function formatToZodModifier(format) {
   }
 }
 function pathParamZodExpr(schema) {
-  if (schema === void 0 || isRef4(schema)) return void 0;
+  if (schema === void 0 || isRef3(schema)) return void 0;
   const s = schema;
   if (s.type !== "string") return void 0;
   const format = s.format;
@@ -19164,7 +19138,7 @@ function paramZodExpr(tsType, required, schema) {
   } else if (tsType === "boolean") {
     base = "z.boolean()";
   } else {
-    if (schema !== void 0 && !isRef4(schema)) {
+    if (schema !== void 0 && !isRef3(schema)) {
       const s = schema;
       const format = s.format;
       const modifier = format !== void 0 ? formatToZodModifier(format) : "";
@@ -19180,7 +19154,7 @@ function getPathParamValidations(operation, spec, rawPathParamNames) {
   if (parameters === void 0) return [];
   const zodByName = /* @__PURE__ */ new Map();
   for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
+    const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "path") continue;
     const schema = resolved.schema;
     const zodExpr = pathParamZodExpr(schema);
@@ -19198,7 +19172,7 @@ function getHeaderParams(operation, spec) {
   if (parameters === void 0) return [];
   const result = [];
   for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
+    const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "header") continue;
     result.push({
       rawName: resolved.name,
@@ -19275,23 +19249,8 @@ function emitHeaderValidation(lines, headerParams, indent, framework) {
   lines.push(rawFields);
   lines.push(`${inner}})`);
 }
-function getBodyInfo2(operation) {
-  const requestBody = operation.requestBody;
-  if (requestBody === void 0) return void 0;
-  if (isRef4(requestBody)) return { typeName: void 0 };
-  const rb = requestBody;
-  const content = rb.content;
-  if (content === void 0) return { typeName: void 0 };
-  const jsonContent = content["application/json"];
-  if (jsonContent === void 0 || jsonContent.schema === void 0) return { typeName: void 0 };
-  const schema = jsonContent.schema;
-  if (isRef4(schema)) {
-    return { typeName: refToName2(schema.$ref) };
-  }
-  return { typeName: void 0 };
-}
 function response200IsVoid(resp) {
-  if (isRef4(resp)) return false;
+  if (isRef3(resp)) return false;
   const r = resp;
   const content = r.content;
   return content === void 0 || Object.keys(content).length === 0;
@@ -19314,15 +19273,15 @@ function collectOperations2(spec) {
   if (paths === void 0) return [];
   const operations = [];
   for (const [path, pathItem] of Object.entries(paths)) {
-    for (const method of SUPPORTED_METHODS2) {
+    for (const method of SUPPORTED_METHODS) {
       const operation = pathItem[method];
       if (operation === void 0) continue;
-      const methodName = deriveMethodName2(operation.operationId, method, path);
-      const pathParams = extractPathParamsFromPath2(path);
+      const methodName = deriveMethodName(operation.operationId, method, path);
+      const pathParams = extractPathParamsFromPath(path);
       const pathParamValidations = getPathParamValidations(operation, spec, pathParams);
-      const queryParams = getQueryParams2(operation, spec);
+      const queryParams = getQueryParams(operation, spec);
       const headerParams = getHeaderParams(operation, spec);
-      const bodyInfo = getBodyInfo2(operation);
+      const bodyInfo = getBodyInfo(operation);
       const responseStatus = getResponseStatus(operation, method);
       operations.push({
         methodName,
@@ -19628,7 +19587,7 @@ function operationsNeedZodForParams(operations) {
   return false;
 }
 function generateExpressRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19667,7 +19626,7 @@ function generateExpressRouter(spec, options) {
   };
 }
 function generateFastifyRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19699,7 +19658,7 @@ function generateFastifyRouter(spec, options) {
   };
 }
 function generateRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19740,66 +19699,66 @@ async function formatTs(content, filePath) {
   const config = await resolveConfig(filePath);
   return format(content, { ...config, parser: "typescript" });
 }
-async function generate2(cwd, configPath) {
-  console.log("Loading config...");
-  const config = await loadConfig(cwd, configPath);
+function buildRouterFile(spec, framework, options) {
+  if (framework === "hono") return generateRouter(spec, options);
+  if (framework === "express") return generateExpressRouter(spec, options);
+  return generateFastifyRouter(spec, options);
+}
+async function generateOne(cwd, config, label) {
   const inputPath = (0, import_node_path2.resolve)(cwd, config.input_openapi);
   const outputDir = (0, import_node_path2.resolve)(cwd, config.output);
   const framework = config.framework ?? "none";
-  console.log(`Parsing spec: ${inputPath}`);
+  const prefix = label !== void 0 ? `[${label}] ` : "";
+  console.log(`${prefix}Parsing spec: ${inputPath}`);
   const spec = await parseSpec(inputPath);
-  const generatedFiles = [];
-  generatedFiles.push(generateService(spec));
-  if (framework === "hono") {
-    generatedFiles.push(generateRouter(spec));
-  } else if (framework === "express") {
-    generatedFiles.push(generateExpressRouter(spec));
-  } else if (framework === "fastify") {
-    generatedFiles.push(generateFastifyRouter(spec));
-  }
-  console.log(`Writing output to: ${outputDir}`);
+  const generatedFiles = [generateService(spec)];
+  if (framework !== "none") {
+    generatedFiles.push(buildRouterFile(spec, framework));
+  }
+  console.log(`${prefix}Writing output to: ${outputDir}`);
   await (0, import_promises2.mkdir)(outputDir, { recursive: true });
   for (const file of generatedFiles) {
     const filePath = (0, import_node_path2.join)(outputDir, file.filename);
     await (0, import_promises2.writeFile)(filePath, await formatTs(file.content, filePath), "utf-8");
-    console.log(`  \u2713 ${file.filename}`);
+    console.log(`${prefix}  \u2713 ${file.filename}`);
   }
-  if ((framework === "hono" || framework === "express" || framework === "fastify") && config.input_schema !== void 0) {
-    const schemaPath = (0, import_node_path2.resolve)(cwd, config.input_schema);
-    let schemaContent;
-    try {
-      schemaContent = await (0, import_promises2.readFile)(schemaPath, "utf-8");
-    } catch {
-      console.log(`  \u2139 input_schema not found at ${schemaPath}, skipping Zod validation`);
-      console.log(`Done! Generated ${generatedFiles.length} file(s).`);
-      return;
-    }
-    const exportedSchemas = /* @__PURE__ */ new Set();
-    for (const match of schemaContent.matchAll(/^export\s+const\s+(\w+Schema)\b/gm)) {
-      exportedSchemas.add(match[1]);
-    }
-    if (exportedSchemas.size > 0) {
-      const relPath = (0, import_node_path2.relative)(outputDir, schemaPath).replace(/\\/g, "/");
-      const schemaImportPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
-      const schemaImportPathJs = schemaImportPath.replace(/\.ts$/, ".js");
-      const routerOptions = { schemaNames: exportedSchemas, schemaImportPath: schemaImportPathJs };
-      let routerFile;
-      if (framework === "hono") {
-        routerFile = generateRouter(spec, routerOptions);
-      } else if (framework === "express") {
-        routerFile = generateExpressRouter(spec, routerOptions);
-      } else {
-        routerFile = generateFastifyRouter(spec, routerOptions);
-      }
-      const routerPath = (0, import_node_path2.join)(outputDir, routerFile.filename);
-      await (0, import_promises2.writeFile)(routerPath, await formatTs(routerFile.content, routerPath), "utf-8");
-      console.log(`  \u2713 router.ts (with Zod validation for ${exportedSchemas.size} schema(s))`);
-    }
+  if (framework !== "none" && config.input_schema !== void 0) {
+    await generateSchemaEnhancedRouter(cwd, config, spec, framework, outputDir, prefix);
+  }
+  console.log(`${prefix}Done! Generated ${generatedFiles.length} file(s).`);
+}
+async function generateSchemaEnhancedRouter(cwd, config, spec, framework, outputDir, prefix) {
+  const schemaPath = (0, import_node_path2.resolve)(cwd, config.input_schema);
+  let schemaContent;
+  try {
+    schemaContent = await (0, import_promises2.readFile)(schemaPath, "utf-8");
+  } catch {
+    console.log(`${prefix}  input_schema not found at ${schemaPath}, skipping Zod validation`);
+    return;
   }
-  console.log(`Done! Generated ${generatedFiles.length} file(s).`);
+  const exportedSchemas = /* @__PURE__ */ new Set();
+  for (const match of schemaContent.matchAll(/^export\s+const\s+(\w+Schema)\b/gm)) {
+    exportedSchemas.add(match[1]);
+  }
+  if (exportedSchemas.size === 0) return;
+  const relPath = (0, import_node_path2.relative)(outputDir, schemaPath).replace(/\\/g, "/");
+  const schemaImportPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
+  const schemaImportPathJs = schemaImportPath.replace(/\.ts$/, ".js");
+  const routerFile = buildRouterFile(spec, framework, {
+    schemaNames: exportedSchemas,
+    schemaImportPath: schemaImportPathJs
+  });
+  const routerPath = (0, import_node_path2.join)(outputDir, routerFile.filename);
+  await (0, import_promises2.writeFile)(routerPath, await formatTs(routerFile.content, routerPath), "utf-8");
+  console.log(`${prefix}  \u2713 router.ts (with Zod validation for ${exportedSchemas.size} schema(s))`);
+}
+async function generate2(cwd, configPath) {
+  console.log("Loading config...");
+  const configs = await loadConfigs2(cwd, configPath);
+  await runProjects(configs, (config, label) => generateOne(cwd, config, label));
 }
 
-// ../openapi-gen/dist/cli-core.js
+// ../openapi-zod-ts/dist/cli-core.js
 var import_node_path3 = require("node:path");
 function parseBaseCliArgs(argv, cwd, usage) {
   const args = argv.slice(2);

package/dist/config.d.ts

@@ -1,4 +1,4 @@
-import { validateConfigPath, validateInputPath, validateOutputPath } from '@codewithagents/openapi-gen/config-core';
+import { validateConfigPath, validateInputPath, validateOutputPath } from 'openapi-zod-ts/config-core';
 export { validateConfigPath, validateInputPath, validateOutputPath };
 export interface ServerConfig {
     /** Path to the OpenAPI 3.1 spec file (JSON or YAML) */
@@ -7,8 +7,15 @@ export interface ServerConfig {
     output: string;
     /** Framework to generate a router for. Default: 'none' */
     framework?: 'hono' | 'express' | 'fastify' | 'none';
-    /** Path to user-owned Zod schema file (same file as openapi-gen's input_schema). Optional. */
+    /** Path to user-owned Zod schema file (same file as openapi-zod-ts's input_schema). Optional. */
     input_schema?: string;
 }
 export declare function loadConfig(cwd: string, configPath?: string): Promise<ServerConfig>;
+/**
+ * Load a config file and return all configs as a normalized array.
+ *
+ * Single-spec config: returns a one-element array.
+ * Multi-spec config with "projects" key: returns N-element array.
+ */
+export declare function loadConfigs(cwd: string, configPath?: string): Promise<ServerConfig[]>;
 //# sourceMappingURL=config.d.ts.map