zenko 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -261,8 +261,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 = [
@@ -285,11 +288,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);
@@ -334,82 +339,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} = {`);
-    output.push(`  path: paths.${op.operationId},`);
+    const camelCaseOperationId = toCamelCase(op.operationId);
+    output.push(`export const ${camelCaseOperationId} = {`);
+    output.push(`  method: "${op.method}",`);
+    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: {");
@@ -445,10 +425,57 @@ function hasAnyErrors(group) {
     group.otherErrors
   ].some((bucket) => bucket && Object.keys(bucket).length > 0);
 }
+function isRequestMethod(method) {
+  switch (method) {
+    case "get":
+    case "put":
+    case "post":
+    case "delete":
+    case "options":
+    case "head":
+    case "patch":
+    case "trace":
+      return true;
+    default:
+      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 [path, 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(path);
       const requestType = getRequestType(operation);
@@ -462,7 +489,7 @@ function parseOperations(spec) {
       operations.push({
         operationId: operation.operationId,
         path,
-        method: method.toLowerCase(),
+        method: normalizedMethod,
         pathParams,
         queryParams,
         requestType,
@@ -498,20 +525,24 @@ function appendHelperTypesImport(buffer, config) {
       buffer.push(
         "type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;"
       );
+      buffer.push(
+        'type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";'
+      );
       buffer.push(
         "type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;"
       );
       buffer.push(
         "type OperationErrors<TClient = unknown, TServer = unknown, TDefault = unknown, TOther = unknown> = {"
       );
-      buffer.push("  clientErrors?: Record<string, TClient>;");
-      buffer.push("  serverErrors?: Record<string, TServer>;");
-      buffer.push("  defaultErrors?: Record<string, TDefault>;");
-      buffer.push("  otherErrors?: Record<string, TOther>;");
+      buffer.push("  clientErrors?: TClient;");
+      buffer.push("  serverErrors?: TServer;");
+      buffer.push("  defaultErrors?: TDefault;");
+      buffer.push("  otherErrors?: TOther;");
       buffer.push("};");
       buffer.push(
-        "type OperationDefinition<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 HeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
       );
+      buffer.push("  method: TMethod;");
       buffer.push("  path: TPath;");
       buffer.push("  request?: TRequest;");
       buffer.push("  response?: TResponse;");
@@ -525,14 +556,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(
+      `  ${isValidJSIdentifier(camelCaseOperationId) ? `typeof paths.${camelCaseOperationId}` : `(typeof paths)[${formatPropertyName(camelCaseOperationId)}]`},`
     );
-    buffer.push(`  typeof paths.${op.operationId},`);
     buffer.push(`  ${requestType},`);
     buffer.push(`  ${responseType},`);
     buffer.push(`  ${headerType},`);
@@ -655,13 +690,34 @@ 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");
+      }
+      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);
     }
   }
@@ -675,6 +731,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}`
@@ -683,6 +742,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"}`
@@ -720,6 +782,9 @@ function buildErrorGroups(errors = [], operationId) {
   return group;
 }
 function resolveResponseType(schema, fallbackName) {
+  if (typeof schema === "string") {
+    return schema;
+  }
   if (schema.$ref) {
     return extractRefName(schema.$ref);
   }
@@ -753,16 +818,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) {
@@ -966,6 +1037,9 @@ function applyNumericBounds(schema, builder) {
   }
   return builder;
 }
+function toCamelCase(str) {
+  return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
 function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }