zenko 0.1.0

package/dist/index.mjs

@@ -0,0 +1,702 @@
+// src/utils/topological-sort.ts
+function topologicalSort(schemas) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const result = [];
+  const visit = (name) => {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      return;
+    }
+    visiting.add(name);
+    const schema = schemas[name];
+    const dependencies = extractDependencies(schema);
+    for (const dep of dependencies) {
+      if (schemas[dep]) {
+        visit(dep);
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+    result.push(name);
+  };
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+  return result;
+}
+function extractDependencies(schema) {
+  const dependencies = [];
+  const traverse = (obj) => {
+    if (typeof obj !== "object" || obj === null) return;
+    if (obj.$ref && typeof obj.$ref === "string") {
+      const refName = extractRefName(obj.$ref);
+      dependencies.push(refName);
+      return;
+    }
+    if (Array.isArray(obj)) {
+      obj.forEach(traverse);
+    } else {
+      Object.values(obj).forEach(traverse);
+    }
+  };
+  traverse(schema);
+  return [...new Set(dependencies)];
+}
+function extractRefName(ref) {
+  return ref.split("/").pop() || "Unknown";
+}
+
+// src/utils/property-name.ts
+function isValidJSIdentifier(name) {
+  if (!name) return false;
+  const firstChar = name.at(0);
+  if (firstChar === void 0) return false;
+  if (!/[a-zA-Z_$]/.test(firstChar)) return false;
+  if (!/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name)) return false;
+  const reservedWords = /* @__PURE__ */ new Set([
+    "abstract",
+    "arguments",
+    "await",
+    "boolean",
+    "break",
+    "byte",
+    "case",
+    "catch",
+    "char",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "double",
+    "else",
+    "enum",
+    "eval",
+    "export",
+    "extends",
+    "false",
+    "final",
+    "finally",
+    "float",
+    "for",
+    "function",
+    "goto",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "instanceof",
+    "int",
+    "interface",
+    "let",
+    "long",
+    "native",
+    "new",
+    "null",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "return",
+    "short",
+    "static",
+    "super",
+    "switch",
+    "synchronized",
+    "this",
+    "throw",
+    "throws",
+    "transient",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "volatile",
+    "while",
+    "with",
+    "yield",
+    "async"
+  ]);
+  return !reservedWords.has(name);
+}
+function formatPropertyName(name) {
+  return isValidJSIdentifier(name) ? name : `"${name}"`;
+}
+
+// src/utils/http-status.ts
+var statusNameMap = {
+  "400": "badRequest",
+  "401": "unauthorized",
+  "402": "paymentRequired",
+  "403": "forbidden",
+  "404": "notFound",
+  "405": "methodNotAllowed",
+  "406": "notAcceptable",
+  "407": "proxyAuthenticationRequired",
+  "408": "requestTimeout",
+  "409": "conflict",
+  "410": "gone",
+  "411": "lengthRequired",
+  "412": "preconditionFailed",
+  "413": "payloadTooLarge",
+  "414": "uriTooLong",
+  "415": "unsupportedMediaType",
+  "416": "rangeNotSatisfiable",
+  "417": "expectationFailed",
+  "418": "imATeapot",
+  "421": "misdirectedRequest",
+  "422": "unprocessableEntity",
+  "423": "locked",
+  "424": "failedDependency",
+  "425": "tooEarly",
+  "426": "upgradeRequired",
+  "428": "preconditionRequired",
+  "429": "tooManyRequests",
+  "431": "requestHeaderFieldsTooLarge",
+  "451": "unavailableForLegalReasons",
+  "500": "internalServerError",
+  "501": "notImplemented",
+  "502": "badGateway",
+  "503": "serviceUnavailable",
+  "504": "gatewayTimeout",
+  "505": "httpVersionNotSupported",
+  "506": "variantAlsoNegotiates",
+  "507": "insufficientStorage",
+  "508": "loopDetected",
+  "510": "notExtended",
+  "511": "networkAuthenticationRequired"
+};
+function mapStatusToIdentifier(status) {
+  if (status === "default") return "defaultError";
+  const trimmed = status.trim();
+  const mapped = statusNameMap[trimmed];
+  if (mapped) return mapped;
+  if (/^\d{3}$/.test(trimmed)) {
+    return `status${trimmed}`;
+  }
+  const sanitized = trimmed.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+  if (!sanitized) return "unknownError";
+  const parts = sanitized.split(/\s+/);
+  const [first, ...rest] = parts;
+  const candidate = first + rest.map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+  if (!candidate) return "unknownError";
+  return /^[a-zA-Z_$]/.test(candidate) ? candidate : `status${candidate.charAt(0).toUpperCase()}${candidate.slice(1)}`;
+}
+function getStatusCategory(status) {
+  if (status === "default") return "default";
+  const code = Number(status);
+  if (!Number.isInteger(code)) return "unknown";
+  if (code >= 400 && code <= 499) return "client";
+  if (code >= 500 && code <= 599) return "server";
+  return "unknown";
+}
+function isErrorStatus(status) {
+  if (status === "default") return true;
+  const code = Number(status);
+  if (!Number.isInteger(code)) return false;
+  return code >= 400;
+}
+
+// src/zenko.ts
+function generate(spec, options = {}) {
+  const output = [];
+  const generatedTypes = /* @__PURE__ */ new Set();
+  const { strictDates = false, strictNumeric = false } = options;
+  const schemaOptions = {
+    strictDates,
+    strictNumeric
+  };
+  output.push('import { z } from "zod";');
+  output.push("");
+  if (spec.components?.schemas) {
+    output.push("// Generated Zod Schemas");
+    output.push("");
+    const sortedSchemas = topologicalSort(spec.components.schemas);
+    for (const name of sortedSchemas) {
+      const schema = spec.components.schemas[name];
+      output.push(
+        generateZodSchema(name, schema, generatedTypes, schemaOptions)
+      );
+      output.push("");
+      output.push(`export type ${name} = z.infer<typeof ${name}>;`);
+      output.push("");
+    }
+  }
+  const operations = parseOperations(spec);
+  output.push("// Path Functions");
+  output.push("export const paths = {");
+  for (const op of operations) {
+    if (op.pathParams.length === 0) {
+      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}");
+      output.push(
+        `  ${op.operationId}: ({ ${paramNames} }: { ${paramTypes} }) => \`${pathWithParams}\`,`
+      );
+    }
+  }
+  output.push("} as const;");
+  output.push("");
+  output.push("// Header Functions");
+  output.push("export const headers = {");
+  for (const op of operations) {
+    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("  }),");
+      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} =>`);
+      output.push(
+        `    ${accessor} !== undefined ? { ${propertyKey}: ${accessor} } : {},`
+      );
+      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("  },");
+  }
+  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},`);
+    appendOperationField(output, "request", op.requestType);
+    appendOperationField(output, "response", op.responseType);
+    if (op.requestHeaders && op.requestHeaders.length > 0) {
+      output.push(`  headers: headers.${op.operationId},`);
+    }
+    if (op.errors && hasAnyErrors(op.errors)) {
+      output.push("  errors: {");
+      appendErrorGroup(output, "clientErrors", op.errors.clientErrors);
+      appendErrorGroup(output, "serverErrors", op.errors.serverErrors);
+      appendErrorGroup(output, "defaultErrors", op.errors.defaultErrors);
+      appendErrorGroup(output, "otherErrors", op.errors.otherErrors);
+      output.push("  },");
+    }
+    output.push("} as const;");
+    output.push("");
+  }
+  return output.join("\n");
+}
+function appendOperationField(buffer, key, value) {
+  if (!value) return;
+  buffer.push(`  ${key}: ${value},`);
+}
+function appendErrorGroup(buffer, label, errors) {
+  if (!errors || Object.keys(errors).length === 0) return;
+  buffer.push(`    ${label}: {`);
+  for (const [name, typeName] of Object.entries(errors)) {
+    buffer.push(`      ${formatPropertyName(name)}: ${typeName},`);
+  }
+  buffer.push("    },");
+}
+function hasAnyErrors(group) {
+  return [
+    group.clientErrors,
+    group.serverErrors,
+    group.defaultErrors,
+    group.otherErrors
+  ].some((bucket) => bucket && Object.keys(bucket).length > 0);
+}
+function parseOperations(spec) {
+  const operations = [];
+  for (const [path, pathItem] of Object.entries(spec.paths)) {
+    for (const [method, operation] of Object.entries(pathItem)) {
+      if (!operation.operationId) continue;
+      const pathParams = extractPathParams(path);
+      const requestType = getRequestType(operation);
+      const { successResponse, errors } = getResponseTypes(
+        operation,
+        operation.operationId
+      );
+      const resolvedParameters = collectParameters(pathItem, operation, spec);
+      const requestHeaders = getRequestHeaders(resolvedParameters);
+      operations.push({
+        operationId: operation.operationId,
+        path,
+        method: method.toLowerCase(),
+        pathParams,
+        requestType,
+        responseType: successResponse,
+        requestHeaders,
+        errors
+      });
+    }
+  }
+  return operations;
+}
+function collectParameters(pathItem, operation, spec) {
+  const parametersMap = /* @__PURE__ */ new Map();
+  const addParameters = (params) => {
+    if (!Array.isArray(params)) return;
+    for (const param of params) {
+      const resolved = resolveParameter(param, spec);
+      if (!resolved) continue;
+      const key = `${resolved.in}:${resolved.name}`;
+      parametersMap.set(key, resolved);
+    }
+  };
+  addParameters(pathItem.parameters);
+  addParameters(operation.parameters);
+  return Array.from(parametersMap.values());
+}
+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 extractPathParams(path) {
+  const params = [];
+  const matches = path.match(/{([^}]+)}/g);
+  if (matches) {
+    for (const match of matches) {
+      const paramName = match.slice(1, -1);
+      params.push({
+        name: paramName,
+        type: "string"
+        // OpenAPI path params are always strings
+      });
+    }
+  }
+  return params;
+}
+function getRequestType(operation) {
+  const requestBody = operation.requestBody?.content?.["application/json"]?.schema;
+  if (!requestBody) return void 0;
+  if (requestBody.$ref) {
+    return extractRefName(requestBody.$ref);
+  }
+  const typeName = `${capitalize(operation.operationId)}Request`;
+  return typeName;
+}
+function getResponseTypes(operation, operationId) {
+  const responses = operation.responses ?? {};
+  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;
+    if (isErrorStatus(statusCode)) {
+      errorEntries.push({ code: statusCode, schema: resolvedSchema });
+      continue;
+    }
+    if (/^2\d\d$/.test(statusCode) || statusCode === "default") {
+      successCodes.set(statusCode, resolvedSchema);
+    }
+  }
+  const successResponse = selectSuccessResponse(successCodes, operationId);
+  const errors = buildErrorGroups(errorEntries, operationId);
+  return { successResponse, errors };
+}
+function selectSuccessResponse(responses, operationId) {
+  if (responses.size === 0) return void 0;
+  const preferredOrder = ["200", "201", "204"];
+  for (const code of preferredOrder) {
+    const schema = responses.get(code);
+    if (schema) {
+      return resolveResponseType(
+        schema,
+        `${capitalize(operationId)}Response${code}`
+      );
+    }
+  }
+  const [firstCode, firstSchema] = responses.entries().next().value ?? [];
+  if (!firstSchema) return void 0;
+  return resolveResponseType(
+    firstSchema,
+    `${capitalize(operationId)}Response${firstCode ?? "Default"}`
+  );
+}
+function buildErrorGroups(errors = [], operationId) {
+  if (!errors.length) return void 0;
+  const group = {};
+  for (const { code, schema } of errors) {
+    const category = getStatusCategory(code);
+    const identifier = mapStatusToIdentifier(code);
+    const typeName = resolveResponseType(
+      schema,
+      `${capitalize(operationId)}${capitalize(identifier)}`
+    );
+    switch (category) {
+      case "client":
+        group.clientErrors ??= {};
+        group.clientErrors[identifier] = typeName;
+        break;
+      case "server":
+        group.serverErrors ??= {};
+        group.serverErrors[identifier] = typeName;
+        break;
+      case "default":
+        group.defaultErrors ??= {};
+        group.defaultErrors[identifier] = typeName;
+        break;
+      default:
+        group.otherErrors ??= {};
+        group.otherErrors[identifier] = typeName;
+        break;
+    }
+  }
+  return group;
+}
+function resolveResponseType(schema, fallbackName) {
+  if (schema.$ref) {
+    return extractRefName(schema.$ref);
+  }
+  return fallbackName;
+}
+function getRequestHeaders(parameters) {
+  const headers = [];
+  for (const param of parameters ?? []) {
+    if (param.in === "header") {
+      headers.push({
+        name: param.name,
+        description: param.description,
+        schema: param.schema,
+        required: param.required
+      });
+    }
+  }
+  return headers;
+}
+function mapHeaderType(header) {
+  const schemaType = header.schema?.type;
+  switch (schemaType) {
+    case "integer":
+    case "number":
+      return "number";
+    case "boolean":
+      return "boolean";
+    default:
+      return "string";
+  }
+}
+function generateZodSchema(name, schema, generatedTypes, options) {
+  if (generatedTypes.has(name)) return "";
+  generatedTypes.add(name);
+  if (schema.enum) {
+    const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+    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")}
+});`;
+  }
+  if (schema.type === "array") {
+    const itemSchema = schema.items ?? { type: "unknown" };
+    const itemType = getZodTypeFromSchema(itemSchema, options);
+    const builder = applyStrictArrayBounds(
+      schema,
+      `z.array(${itemType})`,
+      itemSchema,
+      options.strictNumeric
+    );
+    return `export const ${name} = ${builder};`;
+  }
+  return `export const ${name} = ${getZodTypeFromSchema(schema, options)};`;
+}
+function getZodTypeFromSchema(schema, options) {
+  if (schema.$ref) {
+    return extractRefName(schema.$ref);
+  }
+  if (schema.enum) {
+    const enumValues = schema.enum.map((v) => `"${v}"`).join(", ");
+    return `z.enum([${enumValues}])`;
+  }
+  switch (schema.type) {
+    case "string":
+      return buildString(schema, options);
+    case "boolean":
+      return "z.boolean()";
+    case "array":
+      return `z.array(${getZodTypeFromSchema(
+        schema.items ?? { type: "unknown" },
+        options
+      )})`;
+    case "null":
+      return "z.null()";
+    case "number":
+      return buildNumber(schema, options);
+    case "integer":
+      return buildInteger(schema, options);
+    default:
+      return "z.unknown()";
+  }
+}
+function buildString(schema, options) {
+  if (options.strictDates) {
+    switch (schema.format) {
+      case "date-time":
+        return "z.string().datetime()";
+      case "date":
+        return "z.string().date()";
+      case "time":
+        return "z.string().time()";
+      case "duration":
+        return "z.string().duration()";
+    }
+  }
+  let builder = "z.string()";
+  if (options.strictNumeric) {
+    if (typeof schema.minLength === "number") {
+      builder += `.min(${schema.minLength})`;
+    }
+    if (typeof schema.maxLength === "number") {
+      builder += `.max(${schema.maxLength})`;
+    }
+    if (schema.pattern) {
+      builder += `.regex(new RegExp(${JSON.stringify(schema.pattern)}))`;
+    }
+  }
+  switch (schema.format) {
+    case "uuid":
+      return `${builder}.uuid()`;
+    case "email":
+      return `${builder}.email()`;
+    case "uri":
+    case "url":
+      return `${builder}.url()`;
+    case "ipv4":
+      return `${builder}.ip({ version: "v4" })`;
+    case "ipv6":
+      return `${builder}.ip({ version: "v6" })`;
+    default:
+      return builder;
+  }
+}
+function buildNumber(schema, options) {
+  let builder = "z.number()";
+  if (options.strictNumeric) {
+    builder = applyNumericBounds(schema, builder);
+    if (typeof schema.multipleOf === "number" && schema.multipleOf !== 0) {
+      builder += `.refine((value) => Math.abs(value / ${schema.multipleOf} - Math.round(value / ${schema.multipleOf})) < Number.EPSILON, { message: "Must be a multiple of ${schema.multipleOf}" })`;
+    }
+  }
+  return builder;
+}
+function buildInteger(schema, options) {
+  let builder = buildNumber(schema, options);
+  builder += ".int()";
+  return builder;
+}
+function applyStrictArrayBounds(schema, builder, itemSchema, enforceBounds) {
+  if (!enforceBounds) {
+    return builder;
+  }
+  if (typeof schema.minItems === "number") {
+    builder += `.min(${schema.minItems})`;
+  }
+  if (typeof schema.maxItems === "number") {
+    builder += `.max(${schema.maxItems})`;
+  }
+  if (schema.uniqueItems && isPrimitiveLike(itemSchema)) {
+    builder += '.refine((items) => new Set(items).size === items.length, { message: "Items must be unique" })';
+  }
+  return builder;
+}
+function isPrimitiveLike(schema) {
+  if (schema?.$ref) return false;
+  const primitiveTypes = /* @__PURE__ */ new Set(["string", "number", "integer", "boolean"]);
+  return primitiveTypes.has(schema?.type);
+}
+function applyNumericBounds(schema, builder) {
+  if (typeof schema.minimum === "number") {
+    if (schema.exclusiveMinimum === true) {
+      builder += `.gt(${schema.minimum})`;
+    } else {
+      builder += `.min(${schema.minimum})`;
+    }
+  } else if (typeof schema.exclusiveMinimum === "number") {
+    builder += `.gt(${schema.exclusiveMinimum})`;
+  }
+  if (typeof schema.maximum === "number") {
+    if (schema.exclusiveMaximum === true) {
+      builder += `.lt(${schema.maximum})`;
+    } else {
+      builder += `.max(${schema.maximum})`;
+    }
+  } else if (typeof schema.exclusiveMaximum === "number") {
+    builder += `.lt(${schema.exclusiveMaximum})`;
+  }
+  return builder;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+export {
+  generate
+};
+//# sourceMappingURL=index.mjs.map