zenko 0.1.4 → 0.1.6-beta.1

package/dist/cli.cjs

@@ -29,7 +29,7 @@ var path = __toESM(require("path"), 1);
 var import_url = require("url");
 var import_js_yaml = require("js-yaml");
 
-// 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();
@@ -78,7 +78,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);
@@ -158,7 +158,7 @@ function formatPropertyName(name) {
   return isValidJSIdentifier(name) ? name : `"${name}"`;
 }
 
-// src/utils/http-status.ts
+// ../zenko-core/src/utils/http-status.ts
 var statusNameMap = {
   "400": "badRequest",
   "401": "unauthorized",
@@ -232,8 +232,8 @@ function isErrorStatus(status) {
   return code >= 400;
 }
 
-// src/zenko.ts
-function generate(spec, options = {}) {
+// ../zenko-core/src/zenko.ts
+function generateWithMetadata(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
   const { strictDates = false, strictNumeric = false } = options;
@@ -408,7 +408,16 @@ function generate(spec, options = {}) {
     output.push("");
   }
   generateOperationTypes(output, operations, typesConfig);
-  return output.join("\n");
+  const result = {
+    output: output.join("\n")
+  };
+  if (typesConfig.emit && typesConfig.helpers === "file" && typesConfig.helpersOutput) {
+    result.helperFile = {
+      path: typesConfig.helpersOutput,
+      content: generateHelperFile()
+    };
+  }
+  return result;
 }
 function appendOperationField(buffer, key, value) {
   if (!value) return;
@@ -536,6 +545,9 @@ function appendHelperTypesImport(buffer, config) {
       buffer.push(
         "type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;"
       );
+      buffer.push(
+        "type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);"
+      );
       buffer.push(
         "type OperationErrors<TClient = unknown, TServer = unknown, TDefault = unknown, TOther = unknown> = {"
       );
@@ -545,7 +557,7 @@ function appendHelperTypesImport(buffer, config) {
       buffer.push("  otherErrors?: TOther;");
       buffer.push("};");
       buffer.push(
-        "type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends HeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+        "type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
       );
       buffer.push("  method: TMethod;");
       buffer.push("  path: TPath;");
@@ -616,26 +628,35 @@ var TYPE_KEYWORDS = /* @__PURE__ */ new Set([
   "bigint",
   "symbol"
 ]);
+var IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 function wrapTypeReference(typeName) {
   if (!typeName) return "undefined";
-  if (typeName === "undefined") return "undefined";
-  if (TYPE_KEYWORDS.has(typeName)) return typeName;
-  if (typeName.startsWith("typeof ")) return typeName;
-  const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-  if (identifierPattern.test(typeName)) {
-    return `typeof ${typeName}`;
-  }
-  return typeName;
+  const normalized = typeName.trim();
+  if (normalized === "undefined") return "undefined";
+  if (TYPE_KEYWORDS.has(normalized)) return normalized;
+  if (normalized.startsWith("typeof ")) return normalized;
+  const arrayMatch = normalized.match(/^z\.array\((.+)\)$/);
+  if (arrayMatch) {
+    return `z.ZodArray<${wrapTypeReference(arrayMatch[1])}>`;
+  }
+  if (IDENTIFIER_PATTERN.test(normalized)) {
+    return `typeof ${normalized}`;
+  }
+  return normalized;
 }
 function wrapErrorValueType(typeName) {
   if (!typeName) return "unknown";
-  if (TYPE_KEYWORDS.has(typeName)) return typeName;
-  if (typeName.startsWith("typeof ")) return typeName;
-  const identifierPattern = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
-  if (identifierPattern.test(typeName)) {
-    return `typeof ${typeName}`;
+  const normalized = typeName.trim();
+  if (TYPE_KEYWORDS.has(normalized)) return normalized;
+  if (normalized.startsWith("typeof ")) return normalized;
+  const arrayMatch = normalized.match(/^z\.array\((.+)\)$/);
+  if (arrayMatch) {
+    return `z.ZodArray<${wrapErrorValueType(arrayMatch[1])}>`;
   }
-  return typeName;
+  if (IDENTIFIER_PATTERN.test(normalized)) {
+    return `typeof ${normalized}`;
+  }
+  return normalized;
 }
 function collectParameters(pathItem, operation, spec) {
   const parametersMap = /* @__PURE__ */ new Map();
@@ -699,6 +720,11 @@ function getResponseTypes(operation, operationId) {
     if (!content || Object.keys(content).length === 0) {
       if (statusCode === "204" || /^3\d\d$/.test(statusCode)) {
         successCodes.set(statusCode, "undefined");
+      } else if (isErrorStatus(statusCode)) {
+        errorEntries.push({
+          code: statusCode,
+          schema: "undefined"
+        });
       }
       continue;
     }
@@ -793,6 +819,10 @@ function resolveResponseType(schema, fallbackName) {
   if (schema.$ref) {
     return extractRefName(schema.$ref);
   }
+  if (schema.type === "array" && schema.items?.$ref) {
+    const itemRef = extractRefName(schema.items.$ref);
+    return `z.array(${itemRef})`;
+  }
   return fallbackName;
 }
 function getRequestHeaders(parameters) {
@@ -1042,6 +1072,51 @@ function applyNumericBounds(schema, builder) {
   }
   return builder;
 }
+function generateHelperFile() {
+  const output = [];
+  output.push("// Generated helper types for Zenko");
+  output.push(
+    "// This file provides type definitions for operation objects and path functions"
+  );
+  output.push("");
+  output.push(
+    "export type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string"
+  );
+  output.push("");
+  output.push(
+    'export type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace"'
+  );
+  output.push("");
+  output.push(
+    "export type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult"
+  );
+  output.push("");
+  output.push(
+    "export type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown)"
+  );
+  output.push("");
+  output.push(
+    "export type OperationErrors<TClient = unknown, TServer = unknown, TDefault = unknown, TOther = unknown> = {"
+  );
+  output.push("  clientErrors?: TClient");
+  output.push("  serverErrors?: TServer");
+  output.push("  defaultErrors?: TDefault");
+  output.push("  otherErrors?: TOther");
+  output.push("}");
+  output.push("");
+  output.push(
+    "export type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+  );
+  output.push("  method: TMethod");
+  output.push("  path: TPath");
+  output.push("  request?: TRequest");
+  output.push("  response?: TResponse");
+  output.push("  headers?: THeaders");
+  output.push("  errors?: TErrors");
+  output.push("}");
+  output.push("");
+  return output.join("\n");
+}
 function toCamelCase(str) {
   return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }
@@ -1206,15 +1281,31 @@ async function generateSingle(options) {
   const resolvedInput = path.resolve(inputFile);
   const resolvedOutput = path.resolve(outputFile);
   const spec = readSpec(resolvedInput);
-  const output = generate(spec, {
+  const result = generateWithMetadata(spec, {
     strictDates,
     strictNumeric,
     types: typesConfig
   });
   fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
-  fs.writeFileSync(resolvedOutput, output);
+  fs.writeFileSync(resolvedOutput, result.output);
   console.log(`\u2705 Generated TypeScript types in ${resolvedOutput}`);
   console.log(`\u{1F4C4} Processed ${Object.keys(spec.paths).length} paths`);
+  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);
+    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"
+    });
+    console.log(`\u{1F4E6} Generated helper types in ${helperPath}`);
+  }
 }
 function readSpec(filePath) {
   if (!fs.existsSync(filePath)) {