zenko 0.1.3 → 0.1.5

package/dist/cli.mjs

@@ -210,7 +210,7 @@ function isErrorStatus(status) {
 }
 
 // src/zenko.ts
-function generate(spec, options = {}) {
+function generateWithMetadata(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
   const { strictDates = false, strictNumeric = false } = options;
@@ -243,8 +243,11 @@ function generate(spec, options = {}) {
     const pathParamNames = op.pathParams.map((p) => p.name);
     const hasPathParams = pathParamNames.length > 0;
     const hasQueryParams = op.queryParams.length > 0;
+    const camelCaseOperationId = toCamelCase(op.operationId);
     if (!hasPathParams && !hasQueryParams) {
-      output.push(`  ${op.operationId}: () => "${op.path}",`);
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: () => "${op.path}",`
+      );
       continue;
     }
     const allParamNames = [
@@ -267,11 +270,13 @@ function generate(spec, options = {}) {
     const pathWithParams = op.path.replace(/{([^}]+)}/g, "${$1}");
     if (!hasQueryParams) {
       output.push(
-        `  ${op.operationId}: (${signature}) => \`${pathWithParams}\`,`
+        `  ${formatPropertyName(camelCaseOperationId)}: (${signature}) => \`${pathWithParams}\`,`
       );
       continue;
     }
-    output.push(`  ${op.operationId}: (${signature}) => {`);
+    output.push(
+      `  ${formatPropertyName(camelCaseOperationId)}: (${signature}) => {`
+    );
     output.push("    const params = new URLSearchParams()");
     for (const param of op.queryParams) {
       const propertyKey = formatPropertyName(param.name);
@@ -316,83 +321,57 @@ function generate(spec, options = {}) {
   }
   output.push("} as const;");
   output.push("");
-  output.push("// Header Functions");
-  output.push("export const headers = {");
+  output.push("// Header Schemas");
+  output.push("export const headerSchemas = {");
   for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
     if (!op.requestHeaders || op.requestHeaders.length === 0) {
-      output.push(`  ${op.operationId}: () => ({}),`);
-      continue;
-    }
-    const typeEntries = op.requestHeaders.map(
-      (header) => `${formatPropertyName(header.name)}${header.required ? "" : "?"}: ${mapHeaderType(
-        header
-      )}`
-    ).join(", ");
-    const requiredHeaders = op.requestHeaders.filter(
-      (header) => header.required
-    );
-    const optionalHeaders = op.requestHeaders.filter(
-      (header) => !header.required
-    );
-    const hasRequired = requiredHeaders.length > 0;
-    const signature = hasRequired ? `(params: { ${typeEntries} })` : `(params: { ${typeEntries} } = {})`;
-    if (optionalHeaders.length === 0) {
-      output.push(`  ${op.operationId}: ${signature} => ({`);
-      for (const header of requiredHeaders) {
-        const propertyKey = formatPropertyName(header.name);
-        const accessor = isValidJSIdentifier(header.name) ? `params.${header.name}` : `params[${propertyKey}]`;
-        output.push(`    ${propertyKey}: ${accessor},`);
-      }
-      output.push("  }),");
+      output.push(
+        `  ${formatPropertyName(camelCaseOperationId)}: z.object({}),`
+      );
       continue;
     }
-    if (!hasRequired && optionalHeaders.length === 1 && optionalHeaders[0]) {
-      const header = optionalHeaders[0];
-      const propertyKey = formatPropertyName(header.name);
-      const accessor = isValidJSIdentifier(header.name) ? `params.${header.name}` : `params[${propertyKey}]`;
-      output.push(`  ${op.operationId}: ${signature} =>`);
+    const schemaFields = op.requestHeaders.map((header) => {
+      const zodType = mapHeaderToZodType(header);
+      const optional = header.required ? "" : ".optional()";
+      return `    ${formatPropertyName(header.name)}: ${zodType}${optional},`;
+    }).join("\n");
+    output.push(`  ${formatPropertyName(camelCaseOperationId)}: z.object({`);
+    output.push(schemaFields);
+    output.push("  }),");
+  }
+  output.push("} as const;");
+  output.push("");
+  output.push("// Header Functions");
+  output.push("export const headers = {");
+  for (const op of operations) {
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    if (!op.requestHeaders || op.requestHeaders.length === 0) {
       output.push(
-        `    ${accessor} !== undefined ? { ${propertyKey}: ${accessor} } : {},`
+        `  ${formatPropertyName(camelCaseOperationId)}: () => ${isValidJSIdentifier(camelCaseOperationId) ? `headerSchemas.${camelCaseOperationId}` : `headerSchemas[${formatPropertyName(camelCaseOperationId)}]`}.parse({}),`
       );
       continue;
     }
-    const valueTypes = Array.from(
-      new Set(optionalHeaders.map((header) => mapHeaderType(header)))
-    ).join(" | ");
-    output.push(`  ${op.operationId}: ${signature} => {`);
-    if (hasRequired) {
-      output.push("    const headers = {");
-      for (const header of requiredHeaders) {
-        const propertyKey = formatPropertyName(header.name);
-        const accessor = isValidJSIdentifier(header.name) ? `params.${header.name}` : `params[${propertyKey}]`;
-        output.push(`      ${propertyKey}: ${accessor},`);
-      }
-      output.push("    }");
-    } else {
-      output.push(`    const headers: Record<string, ${valueTypes}> = {}`);
-    }
-    for (const header of optionalHeaders) {
-      const propertyKey = formatPropertyName(header.name);
-      const accessor = isValidJSIdentifier(header.name) ? `params.${header.name}` : `params[${propertyKey}]`;
-      const assignment = isValidJSIdentifier(header.name) ? `headers.${header.name}` : `headers[${propertyKey}]`;
-      output.push(`    if (${accessor} !== undefined) {`);
-      output.push(`      ${assignment} = ${accessor}`);
-      output.push("    }");
-    }
-    output.push("    return headers");
+    output.push(
+      `  ${formatPropertyName(camelCaseOperationId)}: (params: z.input<${isValidJSIdentifier(camelCaseOperationId) ? `typeof headerSchemas.${camelCaseOperationId}` : `(typeof headerSchemas)[${formatPropertyName(camelCaseOperationId)}]`}>) => {`
+    );
+    output.push(
+      `    return ${isValidJSIdentifier(camelCaseOperationId) ? `headerSchemas.${camelCaseOperationId}` : `headerSchemas[${formatPropertyName(camelCaseOperationId)}]`}.parse(params)`
+    );
     output.push("  },");
   }
   output.push("} as const;");
   output.push("");
   output.push("// Operation Objects");
   for (const op of operations) {
-    output.push(`export const ${op.operationId} = {`);
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    output.push(`export const ${camelCaseOperationId} = {`);
     output.push(`  method: "${op.method}",`);
-    output.push(`  path: paths.${op.operationId},`);
+    output.push(`  path: paths.${camelCaseOperationId},`);
     appendOperationField(output, "request", op.requestType);
     appendOperationField(output, "response", op.responseType);
     if (op.requestHeaders && op.requestHeaders.length > 0) {
-      output.push(`  headers: headers.${op.operationId},`);
+      output.push(`  headers: headers.${camelCaseOperationId},`);
     }
     if (op.errors && hasAnyErrors(op.errors)) {
       output.push("  errors: {");
@@ -406,7 +385,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;
@@ -443,6 +431,36 @@ function isRequestMethod(method) {
       return false;
   }
 }
+var CONTENT_TYPE_MAP = {
+  "application/json": "unknown",
+  // Will use schema when available
+  "text/csv": "string",
+  "text/plain": "string",
+  // Binary/ambiguous types default to unknown for cross-platform compatibility
+  "application/octet-stream": "unknown",
+  "application/pdf": "unknown"
+};
+function findContentType(content) {
+  const contentTypes = Object.keys(content);
+  if (contentTypes.includes("application/json")) {
+    return "application/json";
+  }
+  for (const contentType of contentTypes) {
+    if (contentType in CONTENT_TYPE_MAP) {
+      return contentType;
+    }
+  }
+  return contentTypes[0] || "";
+}
+function inferResponseType(contentType, statusCode) {
+  if (statusCode === "204" || /^3\d\d$/.test(statusCode)) {
+    return "undefined";
+  }
+  if (contentType in CONTENT_TYPE_MAP) {
+    return CONTENT_TYPE_MAP[contentType];
+  }
+  return "unknown";
+}
 function parseOperations(spec) {
   const operations = [];
   for (const [path2, pathItem] of Object.entries(spec.paths)) {
@@ -504,6 +522,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> = {"
       );
@@ -513,7 +534,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;");
@@ -529,15 +550,18 @@ function generateOperationTypes(buffer, operations, config) {
   if (!config.emit) return;
   buffer.push("// Operation Types");
   for (const op of operations) {
-    const headerType = op.requestHeaders?.length ? `typeof headers.${op.operationId}` : "undefined";
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    const headerType = op.requestHeaders?.length ? isValidJSIdentifier(camelCaseOperationId) ? `typeof headers.${camelCaseOperationId}` : `(typeof headers)[${formatPropertyName(camelCaseOperationId)}]` : "undefined";
     const requestType = wrapTypeReference(op.requestType);
     const responseType = wrapTypeReference(op.responseType);
     const errorsType = buildOperationErrorsType(op.errors);
     buffer.push(
-      `export type ${capitalize(op.operationId)}Operation = OperationDefinition<`
+      `export type ${capitalize(camelCaseOperationId)}Operation = OperationDefinition<`
     );
     buffer.push(`  "${op.method}",`);
-    buffer.push(`  typeof paths.${op.operationId},`);
+    buffer.push(
+      `  ${isValidJSIdentifier(camelCaseOperationId) ? `typeof paths.${camelCaseOperationId}` : `(typeof paths)[${formatPropertyName(camelCaseOperationId)}]`},`
+    );
     buffer.push(`  ${requestType},`);
     buffer.push(`  ${responseType},`);
     buffer.push(`  ${headerType},`);
@@ -581,26 +605,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}`;
+  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])}>`;
   }
-  return typeName;
+  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();
@@ -660,13 +693,39 @@ function getResponseTypes(operation, operationId) {
   const successCodes = /* @__PURE__ */ new Map();
   const errorEntries = [];
   for (const [statusCode, response] of Object.entries(responses)) {
-    const resolvedSchema = response?.content?.["application/json"]?.schema;
-    if (!resolvedSchema) continue;
+    const content = response?.content;
+    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;
+    }
+    const contentType = findContentType(content);
+    const resolvedSchema = content[contentType]?.schema;
+    if (!resolvedSchema) {
+      const inferredType = inferResponseType(contentType, statusCode);
+      if (inferredType) {
+        if (isErrorStatus(statusCode)) {
+          errorEntries.push({
+            code: statusCode,
+            schema: inferredType
+          });
+        } else if (/^2\d\d$/.test(statusCode)) {
+          successCodes.set(statusCode, inferredType);
+        }
+      }
+      continue;
+    }
     if (isErrorStatus(statusCode)) {
       errorEntries.push({ code: statusCode, schema: resolvedSchema });
       continue;
     }
-    if (/^2\d\d$/.test(statusCode) || statusCode === "default") {
+    if (/^2\d\d$/.test(statusCode)) {
       successCodes.set(statusCode, resolvedSchema);
     }
   }
@@ -680,6 +739,9 @@ function selectSuccessResponse(responses, operationId) {
   for (const code of preferredOrder) {
     const schema = responses.get(code);
     if (schema) {
+      if (typeof schema === "string") {
+        return schema;
+      }
       return resolveResponseType(
         schema,
         `${capitalize(operationId)}Response${code}`
@@ -688,6 +750,9 @@ function selectSuccessResponse(responses, operationId) {
   }
   const [firstCode, firstSchema] = responses.entries().next().value ?? [];
   if (!firstSchema) return void 0;
+  if (typeof firstSchema === "string") {
+    return firstSchema;
+  }
   return resolveResponseType(
     firstSchema,
     `${capitalize(operationId)}Response${firstCode ?? "Default"}`
@@ -725,9 +790,16 @@ function buildErrorGroups(errors = [], operationId) {
   return group;
 }
 function resolveResponseType(schema, fallbackName) {
+  if (typeof schema === "string") {
+    return schema;
+  }
   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) {
@@ -758,16 +830,22 @@ function getQueryParams(parameters) {
   }
   return queryParams;
 }
-function mapHeaderType(header) {
-  const schemaType = header.schema?.type;
+function mapHeaderToZodType(header) {
+  const schema = header.schema ?? {};
+  const schemaType = schema.type;
   switch (schemaType) {
     case "integer":
     case "number":
-      return "number";
+      return "z.coerce.number()";
     case "boolean":
-      return "boolean";
+      return "z.coerce.boolean()";
+    case "array": {
+      const items = schema.items ?? { type: "string" };
+      const itemType = items.type === "integer" || items.type === "number" ? "z.coerce.number()" : items.type === "boolean" ? "z.coerce.boolean()" : "z.string()";
+      return `z.array(${itemType})`;
+    }
     default:
-      return "string";
+      return "z.string()";
   }
 }
 function mapQueryType(param) {
@@ -971,6 +1049,54 @@ 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());
+}
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -1132,15 +1258,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)) {