zenko 0.1.0 → 0.1.2

package/dist/cli.mjs

@@ -214,11 +214,13 @@ function generate(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
   const { strictDates = false, strictNumeric = false } = options;
+  const typesConfig = normalizeTypesConfig(options.types);
   const schemaOptions = {
     strictDates,
     strictNumeric
   };
   output.push('import { z } from "zod";');
+  appendHelperTypesImport(output, typesConfig);
   output.push("");
   if (spec.components?.schemas) {
     output.push("// Generated Zod Schemas");
@@ -238,16 +240,79 @@ function generate(spec, options = {}) {
   output.push("// Path Functions");
   output.push("export const paths = {");
   for (const op of operations) {
-    if (op.pathParams.length === 0) {
+    const pathParamNames = op.pathParams.map((p) => p.name);
+    const hasPathParams = pathParamNames.length > 0;
+    const hasQueryParams = op.queryParams.length > 0;
+    if (!hasPathParams && !hasQueryParams) {
       output.push(`  ${op.operationId}: () => "${op.path}",`);
-    } else {
-      const paramNames = op.pathParams.map((p) => p.name).join(", ");
-      const paramTypes = op.pathParams.map((p) => `${p.name}: string`).join(", ");
-      const pathWithParams = op.path.replace(/{([^}]+)}/g, "${$1}");
+      continue;
+    }
+    const allParamNames = [
+      ...pathParamNames,
+      ...op.queryParams.map((p) => p.name)
+    ];
+    const signaturePieces = [];
+    for (const param of op.pathParams) {
+      signaturePieces.push(`${param.name}: string`);
+    }
+    for (const param of op.queryParams) {
+      signaturePieces.push(
+        `${param.name}${param.required ? "" : "?"}: ${mapQueryType(param)}`
+      );
+    }
+    const signatureParams = signaturePieces.join(", ");
+    const needsDefaultObject = !hasPathParams && hasQueryParams && op.queryParams.every((param) => !param.required);
+    const signatureArgs = allParamNames.length ? `{ ${allParamNames.join(", ")} }` : "{}";
+    const signature = `${signatureArgs}: { ${signatureParams} }${needsDefaultObject ? " = {}" : ""}`;
+    const pathWithParams = op.path.replace(/{([^}]+)}/g, "${$1}");
+    if (!hasQueryParams) {
       output.push(
-        `  ${op.operationId}: ({ ${paramNames} }: { ${paramTypes} }) => \`${pathWithParams}\`,`
+        `  ${op.operationId}: (${signature}) => \`${pathWithParams}\`,`
       );
+      continue;
+    }
+    output.push(`  ${op.operationId}: (${signature}) => {`);
+    output.push("    const params = new URLSearchParams()");
+    for (const param of op.queryParams) {
+      const propertyKey = formatPropertyName(param.name);
+      const accessor = isValidJSIdentifier(param.name) ? param.name : propertyKey;
+      const schema = param.schema ?? {};
+      if (schema?.type === "array") {
+        const itemValueExpression = convertQueryParamValue(
+          schema.items ?? {},
+          "value"
+        );
+        if (param.required) {
+          output.push(`    for (const value of ${accessor}) {`);
+          output.push(
+            `      params.append("${param.name}", ${itemValueExpression})`
+          );
+          output.push("    }");
+        } else {
+          output.push(`    if (${accessor} !== undefined) {`);
+          output.push(`      for (const value of ${accessor}) {`);
+          output.push(
+            `        params.append("${param.name}", ${itemValueExpression})`
+          );
+          output.push("      }");
+          output.push("    }");
+        }
+        continue;
+      }
+      const valueExpression = convertQueryParamValue(schema, accessor);
+      if (param.required) {
+        output.push(`    params.set("${param.name}", ${valueExpression})`);
+      } else {
+        output.push(`    if (${accessor} !== undefined) {`);
+        output.push(`      params.set("${param.name}", ${valueExpression})`);
+        output.push("    }");
+      }
     }
+    output.push("    const _searchParams = params.toString()");
+    output.push(
+      `    return \`${pathWithParams}\${_searchParams ? \`?\${_searchParams}\` : ""}\``
+    );
+    output.push("  },");
   }
   output.push("} as const;");
   output.push("");
@@ -339,6 +404,7 @@ function generate(spec, options = {}) {
     output.push("} as const;");
     output.push("");
   }
+  generateOperationTypes(output, operations, typesConfig);
   return output.join("\n");
 }
 function appendOperationField(buffer, key, value) {
@@ -374,11 +440,13 @@ function parseOperations(spec) {
       );
       const resolvedParameters = collectParameters(pathItem, operation, spec);
       const requestHeaders = getRequestHeaders(resolvedParameters);
+      const queryParams = getQueryParams(resolvedParameters);
       operations.push({
         operationId: operation.operationId,
         path: path2,
         method: method.toLowerCase(),
         pathParams,
+        queryParams,
         requestType,
         responseType: successResponse,
         requestHeaders,
@@ -388,6 +456,129 @@ function parseOperations(spec) {
   }
   return operations;
 }
+function normalizeTypesConfig(config) {
+  return {
+    emit: config?.emit ?? true,
+    helpers: config?.helpers ?? "package",
+    helpersOutput: config?.helpersOutput ?? "./zenko-types"
+  };
+}
+function appendHelperTypesImport(buffer, config) {
+  if (!config.emit) return;
+  switch (config.helpers) {
+    case "package":
+      buffer.push(
+        'import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "zenko";'
+      );
+      return;
+    case "file":
+      buffer.push(
+        `import type { PathFn, HeaderFn, OperationDefinition, OperationErrors } from "${config.helpersOutput}";`
+      );
+      return;
+    case "inline":
+      buffer.push(
+        "type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;"
+      );
+      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("};");
+      buffer.push(
+        "type OperationDefinition<TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends HeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {"
+      );
+      buffer.push("  path: TPath;");
+      buffer.push("  request?: TRequest;");
+      buffer.push("  response?: TResponse;");
+      buffer.push("  headers?: THeaders;");
+      buffer.push("  errors?: TErrors;");
+      buffer.push("};");
+      return;
+  }
+}
+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 requestType = wrapTypeReference(op.requestType);
+    const responseType = wrapTypeReference(op.responseType);
+    const errorsType = buildOperationErrorsType(op.errors);
+    buffer.push(
+      `export type ${capitalize(op.operationId)}Operation = OperationDefinition<`
+    );
+    buffer.push(`  typeof paths.${op.operationId},`);
+    buffer.push(`  ${requestType},`);
+    buffer.push(`  ${responseType},`);
+    buffer.push(`  ${headerType},`);
+    buffer.push(`  ${errorsType}`);
+    buffer.push(`>;`);
+    buffer.push("");
+  }
+}
+function buildOperationErrorsType(errors) {
+  if (!errors || !hasAnyErrors(errors)) {
+    return "OperationErrors";
+  }
+  const client = buildErrorBucket(errors.clientErrors);
+  const server = buildErrorBucket(errors.serverErrors);
+  const fallback = buildErrorBucket(errors.defaultErrors);
+  const other = buildErrorBucket(errors.otherErrors);
+  return `OperationErrors<${client}, ${server}, ${fallback}, ${other}>`;
+}
+function buildErrorBucket(bucket) {
+  if (!bucket || Object.keys(bucket).length === 0) {
+    return "unknown";
+  }
+  const entries = Object.entries(bucket);
+  const accessibleEntries = entries.map(([name, type]) => {
+    const propertyKey = formatPropertyName(name);
+    const valueType = wrapErrorValueType(type);
+    return `${propertyKey}: ${valueType}`;
+  });
+  return `{ ${accessibleEntries.join("; ")} }`;
+}
+var TYPE_KEYWORDS = /* @__PURE__ */ new Set([
+  "any",
+  "unknown",
+  "never",
+  "void",
+  "null",
+  "undefined",
+  "string",
+  "number",
+  "boolean",
+  "bigint",
+  "symbol"
+]);
+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;
+}
+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}`;
+  }
+  return typeName;
+}
 function collectParameters(pathItem, operation, spec) {
   const parametersMap = /* @__PURE__ */ new Map();
   const addParameters = (params) => {
@@ -530,6 +721,20 @@ function getRequestHeaders(parameters) {
   }
   return headers;
 }
+function getQueryParams(parameters) {
+  const queryParams = [];
+  for (const param of parameters ?? []) {
+    if (param.in === "query") {
+      queryParams.push({
+        name: param.name,
+        description: param.description,
+        schema: param.schema,
+        required: param.required
+      });
+    }
+  }
+  return queryParams;
+}
 function mapHeaderType(header) {
   const schemaType = header.schema?.type;
   switch (schemaType) {
@@ -542,6 +747,39 @@ function mapHeaderType(header) {
       return "string";
   }
 }
+function mapQueryType(param) {
+  return mapQuerySchemaType(param.schema);
+}
+function mapQuerySchemaType(schema) {
+  if (!schema) return "string";
+  if (schema.type === "array") {
+    const itemType = mapQuerySchemaType(schema.items);
+    return `Array<${itemType}>`;
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function convertQueryParamValue(schema, accessor) {
+  if (!schema) {
+    return `String(${accessor})`;
+  }
+  switch (schema.type) {
+    case "integer":
+    case "number":
+      return `String(${accessor})`;
+    case "boolean":
+      return `${accessor} ? "true" : "false"`;
+    default:
+      return `String(${accessor})`;
+  }
+}
 function generateZodSchema(name, schema, generatedTypes, options) {
   if (generatedTypes.has(name)) return "";
   generatedTypes.add(name);
@@ -550,18 +788,7 @@ function generateZodSchema(name, schema, generatedTypes, options) {
     return `export const ${name} = z.enum([${enumValues}]);`;
   }
   if (schema.type === "object" || schema.properties) {
-    const properties = [];
-    for (const [propName, propSchema] of Object.entries(
-      schema.properties || {}
-    )) {
-      const isRequired = schema.required?.includes(propName) ?? false;
-      const zodType = getZodTypeFromSchema(propSchema, options);
-      const finalType = isRequired ? zodType : `${zodType}.optional()`;
-      properties.push(`  ${formatPropertyName(propName)}: ${finalType},`);
-    }
-    return `export const ${name} = z.object({
-${properties.join("\n")}
-});`;
+    return `export const ${name} = ${buildZodObject(schema, options)};`;
   }
   if (schema.type === "array") {
     const itemSchema = schema.items ?? { type: "unknown" };
@@ -584,6 +811,9 @@ function getZodTypeFromSchema(schema, options) {
     const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
     return `z.enum([${enumValues}])`;
   }
+  if (schema.type === "object" || schema.properties) {
+    return buildZodObject(schema, options);
+  }
   switch (schema.type) {
     case "string":
       return buildString(schema, options);
@@ -604,6 +834,23 @@ function getZodTypeFromSchema(schema, options) {
       return "z.unknown()";
   }
 }
+function buildZodObject(schema, options) {
+  const properties = [];
+  for (const [propName, propSchema] of Object.entries(
+    schema.properties || {}
+  )) {
+    const isRequired = schema.required?.includes(propName) ?? false;
+    const zodType = getZodTypeFromSchema(propSchema, options);
+    const finalType = isRequired ? zodType : `${zodType}.optional()`;
+    properties.push(`  ${formatPropertyName(propName)}: ${finalType},`);
+  }
+  if (properties.length === 0) {
+    return "z.object({})";
+  }
+  return `z.object({
+${properties.join("\n")}
+})`;
+}
 function buildString(schema, options) {
   if (options.strictDates) {
     switch (schema.format) {
@@ -794,7 +1041,7 @@ function printHelp() {
   console.log("");
   console.log("Config file format:");
   console.log(
-    '  {"schemas": [{ input, output, strictDates?, strictNumeric? }] }'
+    '  {"types"?: { emit?, helpers?, helpersOutput? }, "schemas": [{ input, output, strictDates?, strictNumeric?, types? }] }'
   );
 }
 async function runFromConfig(parsed) {
@@ -803,14 +1050,17 @@ async function runFromConfig(parsed) {
   const config = await loadConfig(resolvedConfigPath);
   validateConfig(config);
   const baseDir = path.dirname(resolvedConfigPath);
+  const baseTypesConfig = config.types;
   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
+      strictNumeric: entry.strictNumeric ?? parsed.strictNumeric,
+      typesConfig
     });
   }
 }
@@ -847,12 +1097,23 @@ 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 } = options;
+  const { inputFile, outputFile, strictDates, strictNumeric, typesConfig } = options;
   const resolvedInput = path.resolve(inputFile);
   const resolvedOutput = path.resolve(outputFile);
   const spec = readSpec(resolvedInput);
-  const output = generate(spec, { strictDates, strictNumeric });
+  const output = generate(spec, {
+    strictDates,
+    strictNumeric,
+    types: typesConfig
+  });
   fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
   fs.writeFileSync(resolvedOutput, output);
   console.log(`\u2705 Generated TypeScript types in ${resolvedOutput}`);