zenko 0.1.9 → 0.1.10-beta.2

package/dist/cli.mjs

@@ -1,12 +1,10 @@
-#!/usr/bin/env node
+#!/usr/bin/env bun
 
 // src/cli.ts
-import * as fs from "fs";
-import * as path from "path";
-import { pathToFileURL } from "url";
-import { load } from "js-yaml";
+import * as path2 from "path";
+import { mkdir } from "fs/promises";
 
-// src/utils/topological-sort.ts
+// ../zenko-core/src/utils/topological-sort.ts
 function topologicalSort(schemas) {
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
@@ -55,7 +53,7 @@ function extractRefName(ref) {
   return ref.split("/").pop() || "Unknown";
 }
 
-// src/utils/property-name.ts
+// ../zenko-core/src/utils/property-name.ts
 function isValidJSIdentifier(name) {
   if (!name) return false;
   const firstChar = name.at(0);
@@ -135,7 +133,7 @@ function formatPropertyName(name) {
   return isValidJSIdentifier(name) ? name : `"${name}"`;
 }
 
-// src/utils/string-utils.ts
+// ../zenko-core/src/utils/string-utils.ts
 function toCamelCase(str) {
   return str.replace(/-([a-zA-Z])/g, (_, letter) => letter.toUpperCase()).replace(/-+$/, "");
 }
@@ -143,7 +141,7 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-// src/utils/http-status.ts
+// ../zenko-core/src/utils/http-status.ts
 var statusNameMap = {
   "400": "badRequest",
   "401": "unauthorized",
@@ -209,7 +207,7 @@ function isErrorStatus(status) {
   return code >= 400;
 }
 
-// src/utils/tree-shaking.ts
+// ../zenko-core/src/utils/tree-shaking.ts
 function analyzeZenkoUsage(operations) {
   const usage = {
     usesHeaderFn: false,
@@ -249,7 +247,7 @@ function hasAnyErrors(errors) {
   return Boolean(errors && Object.keys(errors).length > 0);
 }
 
-// src/utils/collect-inline-types.ts
+// ../zenko-core/src/utils/collect-inline-types.ts
 function collectInlineRequestTypes(operations, spec) {
   const requestTypesToGenerate = /* @__PURE__ */ new Map();
   const operationLookup = /* @__PURE__ */ new Map();
@@ -326,8 +324,186 @@ function collectInlineResponseTypes(operations, spec) {
   }
   return responseTypesToGenerate;
 }
+function collectInlineErrorTypes(operations, spec) {
+  const errorTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const responses = operation.responses || {};
+    for (const [statusCode, response] of Object.entries(responses)) {
+      if (isErrorStatus(statusCode) && response.content) {
+        const content = response.content;
+        const jsonContent = content["application/json"];
+        if (jsonContent && jsonContent.schema) {
+          const schema = jsonContent.schema;
+          const identifier = mapStatusToIdentifier(statusCode);
+          const typeName = `${capitalize(toCamelCase(op.operationId))}${capitalize(identifier)}`;
+          if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+            errorTypesToGenerate.set(typeName, schema);
+          }
+        }
+      }
+    }
+  }
+  return errorTypesToGenerate;
+}
+
+// ../zenko-core/src/utils/collect-referenced-schemas.ts
+function findContentType(content) {
+  const contentTypes = Object.keys(content);
+  if (contentTypes.includes("application/json")) {
+    return "application/json";
+  }
+  const CONTENT_TYPE_MAP2 = {
+    "application/json": "unknown",
+    "text/csv": "string",
+    "text/plain": "string",
+    "application/octet-stream": "unknown",
+    "application/pdf": "unknown"
+  };
+  for (const contentType of contentTypes) {
+    if (contentType in CONTENT_TYPE_MAP2) {
+      return contentType;
+    }
+  }
+  return contentTypes[0] || "";
+}
+function resolveParameter(parameter, spec) {
+  if (!parameter) return void 0;
+  if (parameter.$ref) {
+    const refName = extractRefName(parameter.$ref);
+    const resolved = spec.components?.parameters?.[refName];
+    if (!resolved) return void 0;
+    const { $ref, ...overrides } = parameter;
+    return {
+      ...resolved,
+      ...overrides
+    };
+  }
+  return parameter;
+}
+function collectReferencedSchemas(operations, spec) {
+  const referenced = /* @__PURE__ */ new Set();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const rawOperation = operationLookup.get(op.operationId);
+    if (!rawOperation) continue;
+    const requestBody = rawOperation.requestBody?.content?.["application/json"]?.schema;
+    if (requestBody?.$ref) {
+      const refName = extractRefName(requestBody.$ref);
+      referenced.add(refName);
+    } else if (requestBody) {
+      const deps = extractDependencies(requestBody);
+      for (const dep of deps) {
+        if (spec.components?.schemas?.[dep]) {
+          referenced.add(dep);
+        }
+      }
+    }
+    const responses = rawOperation.responses || {};
+    for (const [, response] of Object.entries(responses)) {
+      const content = response?.content;
+      if (!content) continue;
+      const contentType = findContentType(content);
+      const responseSchema = content[contentType]?.schema;
+      if (responseSchema?.$ref) {
+        const refName = extractRefName(responseSchema.$ref);
+        referenced.add(refName);
+      } else if (responseSchema) {
+        const deps = extractDependencies(responseSchema);
+        for (const dep of deps) {
+          if (spec.components?.schemas?.[dep]) {
+            referenced.add(dep);
+          }
+        }
+      }
+    }
+    for (const param of op.queryParams) {
+      if (param.schema?.$ref) {
+        const refName = extractRefName(param.schema.$ref);
+        referenced.add(refName);
+      }
+      if (param.schema?.items?.$ref) {
+        const refName = extractRefName(param.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    for (const header of op.requestHeaders || []) {
+      if (header.schema?.$ref) {
+        const refName = extractRefName(header.schema.$ref);
+        referenced.add(refName);
+      }
+      if (header.schema?.items?.$ref) {
+        const refName = extractRefName(header.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    const parameters = rawOperation.parameters || [];
+    for (const param of parameters) {
+      const resolvedParam = resolveParameter(param, spec);
+      if (resolvedParam?.schema?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.$ref);
+        referenced.add(refName);
+      }
+      if (resolvedParam?.schema?.items?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const toVisit = Array.from(referenced);
+  while (toVisit.length > 0) {
+    const schemaName = toVisit.pop();
+    if (visited.has(schemaName)) continue;
+    visited.add(schemaName);
+    const schema = spec.components?.schemas?.[schemaName];
+    if (!schema) continue;
+    const dependencies = extractDependencies(schema);
+    for (const dep of dependencies) {
+      if (spec.components?.schemas?.[dep] && !visited.has(dep)) {
+        referenced.add(dep);
+        toVisit.push(dep);
+      }
+    }
+  }
+  return referenced;
+}
 
-// src/utils/generate-helper-file.ts
+// ../zenko-core/src/utils/generate-helper-file.ts
 function generateHelperFile() {
   const output = [];
   output.push("// Generated helper types for Zenko");
@@ -369,11 +545,11 @@ function generateHelperFile() {
   return output.join("\n");
 }
 
-// src/zenko.ts
+// ../zenko-core/src/zenko.ts
 function generateWithMetadata(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
-  const { strictDates = false, strictNumeric = false } = options;
+  const { strictDates = false, strictNumeric = false, operationIds } = options;
   const typesConfig = normalizeTypesConfig(options.types);
   const schemaOptions = {
     strictDates,
@@ -387,13 +563,26 @@ function generateWithMetadata(spec, options = {}) {
       nameMap.set(name, toCamelCase(name));
     }
   }
-  const operations = parseOperations(spec, nameMap);
+  let operations = parseOperations(spec, nameMap);
+  if (operationIds && operationIds.length > 0) {
+    const selectedIds = new Set(operationIds);
+    operations = operations.filter((op) => selectedIds.has(op.operationId));
+  }
   appendHelperTypesImport(output, typesConfig, operations);
   output.push("");
   if (spec.components?.schemas) {
     output.push("// Generated Zod Schemas");
     output.push("");
-    const sortedSchemas = topologicalSort(spec.components.schemas);
+    let schemasToGenerate;
+    if (operationIds && operationIds.length > 0) {
+      const referencedSchemas = collectReferencedSchemas(operations, spec);
+      schemasToGenerate = Array.from(referencedSchemas);
+    } else {
+      schemasToGenerate = Object.keys(spec.components.schemas);
+    }
+    const sortedSchemas = topologicalSort(spec.components.schemas).filter(
+      (name) => schemasToGenerate.includes(name)
+    );
     for (const name of sortedSchemas) {
       const schema = spec.components.schemas[name];
       const sanitizedName = nameMap.get(name);
@@ -582,6 +771,9 @@ function generateWithMetadata(spec, options = {}) {
   }
   return result;
 }
+function generateFromDocument(spec, options = {}) {
+  return generateWithMetadata(spec, options);
+}
 function generateRequestTypes(output, operations, spec, nameMap, schemaOptions) {
   const requestTypesToGenerate = collectInlineRequestTypes(operations, spec);
   if (requestTypesToGenerate.size > 0) {
@@ -604,7 +796,8 @@ function generateRequestTypes(output, operations, spec, nameMap, schemaOptions)
 }
 function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
   const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
-  if (responseTypesToGenerate.size > 0) {
+  const errorTypesToGenerate = collectInlineErrorTypes(operations, spec);
+  if (responseTypesToGenerate.size > 0 || errorTypesToGenerate.size > 0) {
     output.push("// Generated Response Types");
     output.push("");
     for (const [typeName, schema] of responseTypesToGenerate) {
@@ -620,6 +813,19 @@ function generateResponseTypes(output, operations, spec, nameMap, schemaOptions)
       output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
       output.push("");
     }
+    for (const [typeName, schema] of errorTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
   }
 }
 function appendOperationField(buffer, key, value) {
@@ -661,7 +867,7 @@ var CONTENT_TYPE_MAP = {
   "application/octet-stream": "unknown",
   "application/pdf": "unknown"
 };
-function findContentType(content) {
+function findContentType2(content) {
   const contentTypes = Object.keys(content);
   if (contentTypes.includes("application/json")) {
     return "application/json";
@@ -685,12 +891,12 @@ function inferResponseType(contentType, statusCode) {
 function parseOperations(spec, nameMap) {
   const operations = [];
   if (spec.paths) {
-    for (const [path2, pathItem] of Object.entries(spec.paths)) {
+    for (const [path3, pathItem] of Object.entries(spec.paths)) {
       for (const [method, operation] of Object.entries(pathItem)) {
         const normalizedMethod = method.toLowerCase();
         if (!isRequestMethod(normalizedMethod)) continue;
         if (!operation.operationId) continue;
-        const pathParams = extractPathParams(path2);
+        const pathParams = extractPathParams(path3);
         const requestType = getRequestType(operation);
         const { successResponse, errors } = getResponseTypes(
           operation,
@@ -702,7 +908,7 @@ function parseOperations(spec, nameMap) {
         const queryParams = getQueryParams(resolvedParameters);
         operations.push({
           operationId: operation.operationId,
-          path: path2,
+          path: path3,
           method: normalizedMethod,
           pathParams,
           queryParams,
@@ -720,8 +926,8 @@ function parseOperations(spec, nameMap) {
         const normalizedMethod = method.toLowerCase();
         if (!isRequestMethod(normalizedMethod)) continue;
         if (!operation.operationId) continue;
-        const path2 = webhookName;
-        const pathParams = extractPathParams(path2);
+        const path3 = webhookName;
+        const pathParams = extractPathParams(path3);
         const requestType = getRequestType(operation);
         const { successResponse, errors } = getResponseTypes(
           operation,
@@ -736,7 +942,7 @@ function parseOperations(spec, nameMap) {
         const queryParams = getQueryParams(resolvedParameters);
         operations.push({
           operationId: operation.operationId,
-          path: path2,
+          path: path3,
           method: normalizedMethod,
           pathParams,
           queryParams,
@@ -912,7 +1118,7 @@ function collectParameters(pathItem, operation, spec) {
   const addParameters = (params) => {
     if (!Array.isArray(params)) return;
     for (const param of params) {
-      const resolved = resolveParameter(param, spec);
+      const resolved = resolveParameter2(param, spec);
       if (!resolved) continue;
       const key = `${resolved.in}:${resolved.name}`;
       parametersMap.set(key, resolved);
@@ -922,7 +1128,7 @@ function collectParameters(pathItem, operation, spec) {
   addParameters(operation.parameters);
   return Array.from(parametersMap.values());
 }
-function resolveParameter(parameter, spec) {
+function resolveParameter2(parameter, spec) {
   if (!parameter) return void 0;
   if (parameter.$ref) {
     const refName = extractRefName(parameter.$ref);
@@ -936,9 +1142,9 @@ function resolveParameter(parameter, spec) {
   }
   return parameter;
 }
-function extractPathParams(path2) {
+function extractPathParams(path3) {
   const params = [];
-  const matches = path2.match(/{([^}]+)}/g);
+  const matches = path3.match(/{([^}]+)}/g);
   if (matches) {
     for (const match of matches) {
       const paramName = match.slice(1, -1);
@@ -977,7 +1183,7 @@ function getResponseTypes(operation, operationId, nameMap) {
       }
       continue;
     }
-    const contentType = findContentType(content);
+    const contentType = findContentType2(content);
     const resolvedSchema = content[contentType]?.schema;
     if (!resolvedSchema) {
       const inferredType = inferResponseType(contentType, statusCode);
@@ -1349,6 +1555,74 @@ function applyNumericBounds(schema, builder) {
   return builder;
 }
 
+// src/loader.ts
+import * as path from "path";
+import { pathToFileURL } from "url";
+var YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
+var JSON_EXTENSIONS = /* @__PURE__ */ new Set([".json"]);
+async function readFileText(filePath) {
+  const file = Bun.file(filePath);
+  if (!await file.exists()) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  return await file.text();
+}
+async function loadConfig(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (JSON_EXTENSIONS.has(extension)) {
+    const content = await readFileText(filePath);
+    return JSON.parse(content);
+  }
+  if (YAML_EXTENSIONS.has(extension)) {
+    const content = await readFileText(filePath);
+    return Bun.YAML.parse(content);
+  }
+  const fileUrl = pathToFileURL(filePath).href;
+  const module = await import(fileUrl);
+  return module.default ?? module.config ?? module;
+}
+async function loadSpec(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  const content = await readFileText(filePath);
+  if (YAML_EXTENSIONS.has(extension)) {
+    const parsed = Bun.YAML.parse(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error(`YAML spec did not resolve to an object: ${filePath}`);
+    }
+    if (Array.isArray(parsed)) {
+      throw new Error(
+        `YAML spec produced multiple documents; provide a single document in ${filePath}`
+      );
+    }
+    return parsed;
+  }
+  if (JSON_EXTENSIONS.has(extension)) {
+    return JSON.parse(content);
+  }
+  throw new Error(
+    `Unsupported specification format for ${filePath}. Expected .yaml, .yml, or .json`
+  );
+}
+function normalizeGenerationOptions(entry, baseDir, defaults) {
+  const resolvedInput = path.isAbsolute(entry.input) ? entry.input : path.join(baseDir, entry.input);
+  const resolvedOutput = path.isAbsolute(entry.output) ? entry.output : path.join(baseDir, entry.output);
+  return {
+    resolvedInput,
+    resolvedOutput,
+    strictDates: entry.strictDates ?? defaults.strictDates,
+    strictNumeric: entry.strictNumeric ?? defaults.strictNumeric,
+    types: mergeTypesConfig(defaults.types, entry.types),
+    operationIds: entry.operationIds ?? defaults.operationIds
+  };
+}
+function mergeTypesConfig(baseConfig, entryConfig) {
+  if (!baseConfig && !entryConfig) return void 0;
+  return {
+    ...baseConfig,
+    ...entryConfig
+  };
+}
+
 // src/cli.ts
 async function main() {
   const args = process.argv.slice(2);
@@ -1374,8 +1648,8 @@ async function main() {
         return;
       }
       await generateSingle({
-        inputFile,
-        outputFile,
+        resolvedInput: path2.resolve(inputFile),
+        resolvedOutput: path2.resolve(outputFile),
         strictDates: parsed.strictDates,
         strictNumeric: parsed.strictNumeric
       });
@@ -1443,38 +1717,22 @@ function printHelp() {
 }
 async function runFromConfig(parsed) {
   const configPath = parsed.configPath;
-  const resolvedConfigPath = path.resolve(configPath);
-  const config = await loadConfig(resolvedConfigPath);
-  validateConfig(config);
-  const baseDir = path.dirname(resolvedConfigPath);
-  const baseTypesConfig = config.types;
+  const resolvedConfigPath = path2.resolve(configPath);
+  const configDocument = await loadConfig(resolvedConfigPath);
+  validateConfig(configDocument);
+  const config = configDocument;
+  const baseDir = path2.dirname(resolvedConfigPath);
+  const defaults = {
+    strictDates: parsed.strictDates,
+    strictNumeric: parsed.strictNumeric,
+    types: config.types,
+    operationIds: void 0
+  };
   for (const entry of config.schemas) {
-    const inputFile = resolvePath(entry.input, baseDir);
-    const outputFile = resolvePath(entry.output, baseDir);
-    const typesConfig = resolveTypesConfig(baseTypesConfig, entry.types);
-    await generateSingle({
-      inputFile,
-      outputFile,
-      strictDates: entry.strictDates ?? parsed.strictDates,
-      strictNumeric: entry.strictNumeric ?? parsed.strictNumeric,
-      typesConfig
-    });
+    const options = normalizeGenerationOptions(entry, baseDir, defaults);
+    await generateSingle(options);
   }
 }
-async function loadConfig(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  if (extension === ".json") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return JSON.parse(content);
-  }
-  if (extension === ".yaml" || extension === ".yml") {
-    const content = fs.readFileSync(filePath, "utf8");
-    return load(content);
-  }
-  const fileUrl = pathToFileURL(filePath).href;
-  const module = await import(fileUrl);
-  return module.default ?? module.config ?? module;
-}
 function validateConfig(config) {
   if (!config || typeof config !== "object") {
     throw new Error("Config file must export an object");
@@ -1491,60 +1749,44 @@ function validateConfig(config) {
     }
   }
 }
-function resolvePath(filePath, baseDir) {
-  return path.isAbsolute(filePath) ? filePath : path.join(baseDir, filePath);
-}
-function resolveTypesConfig(baseConfig, entryConfig) {
-  if (!baseConfig && !entryConfig) return void 0;
-  return {
-    ...baseConfig,
-    ...entryConfig
-  };
-}
 async function generateSingle(options) {
-  const { inputFile, outputFile, strictDates, strictNumeric, typesConfig } = options;
-  const resolvedInput = path.resolve(inputFile);
-  const resolvedOutput = path.resolve(outputFile);
-  const spec = readSpec(resolvedInput);
-  const result = generateWithMetadata(spec, {
+  const {
+    resolvedInput,
+    resolvedOutput,
+    strictDates = false,
+    strictNumeric = false,
+    types,
+    operationIds
+  } = options;
+  const spec = await loadSpec(resolvedInput);
+  const result = generateFromDocument(spec, {
     strictDates,
     strictNumeric,
-    types: typesConfig
+    types,
+    operationIds
   });
-  fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
-  fs.writeFileSync(resolvedOutput, result.output);
+  await mkdir(path2.dirname(resolvedOutput), { recursive: true });
+  await Bun.write(resolvedOutput, result.output);
   console.log(`\u2705 Generated TypeScript types in ${resolvedOutput}`);
   console.log(`\u{1F4C4} Processed ${Object.keys(spec.paths || {}).length} paths`);
   if (spec.webhooks) {
     console.log(`\u{1FA9D} Processed ${Object.keys(spec.webhooks).length} webhooks`);
   }
   if (result.helperFile) {
-    const helperPath = path.isAbsolute(result.helperFile.path) ? result.helperFile.path : path.resolve(path.dirname(resolvedOutput), result.helperFile.path);
-    const absoluteResolvedOutput = path.resolve(resolvedOutput);
-    const absoluteHelperPath = path.resolve(helperPath);
+    const helperPath = path2.isAbsolute(result.helperFile.path) ? result.helperFile.path : path2.resolve(path2.dirname(resolvedOutput), result.helperFile.path);
+    const absoluteResolvedOutput = path2.resolve(resolvedOutput);
+    const absoluteHelperPath = path2.resolve(helperPath);
     if (absoluteResolvedOutput === absoluteHelperPath) {
       console.warn(
         `\u26A0\uFE0F  Skipping helper file generation: would overwrite main output at ${absoluteResolvedOutput}`
       );
       return;
     }
-    fs.mkdirSync(path.dirname(helperPath), { recursive: true });
-    fs.writeFileSync(helperPath, result.helperFile.content, {
-      encoding: "utf8"
-    });
+    await mkdir(path2.dirname(helperPath), { recursive: true });
+    await Bun.write(helperPath, result.helperFile.content);
     console.log(`\u{1F4E6} Generated helper types in ${helperPath}`);
   }
 }
-function readSpec(filePath) {
-  if (!fs.existsSync(filePath)) {
-    throw new Error(`Input file not found: ${filePath}`);
-  }
-  const content = fs.readFileSync(filePath, "utf8");
-  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
-    return load(content);
-  }
-  return JSON.parse(content);
-}
 main().catch((error) => {
   console.error("\u274C Error:", error);
   process.exit(1);