zenko 0.1.9 → 0.1.10-beta.2

package/dist/index.mjs

@@ -1,4 +1,4 @@
-// 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();
@@ -47,7 +47,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);
@@ -127,7 +127,7 @@ function formatPropertyName(name) {
   return isValidJSIdentifier(name) ? name : `"${name}"`;
 }
 
-// src/utils/string-utils.ts
+// ../zenko-core/src/utils/string-utils.ts
 function toCamelCase(str) {
   return str.replace(/-([a-zA-Z])/g, (_, letter) => letter.toUpperCase()).replace(/-+$/, "");
 }
@@ -135,7 +135,7 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-// src/utils/http-status.ts
+// ../zenko-core/src/utils/http-status.ts
 var statusNameMap = {
   "400": "badRequest",
   "401": "unauthorized",
@@ -201,7 +201,7 @@ function isErrorStatus(status) {
   return code >= 400;
 }
 
-// src/utils/tree-shaking.ts
+// ../zenko-core/src/utils/tree-shaking.ts
 function analyzeZenkoUsage(operations) {
   const usage = {
     usesHeaderFn: false,
@@ -241,7 +241,7 @@ function hasAnyErrors(errors) {
   return Boolean(errors && Object.keys(errors).length > 0);
 }
 
-// src/utils/collect-inline-types.ts
+// ../zenko-core/src/utils/collect-inline-types.ts
 function collectInlineRequestTypes(operations, spec) {
   const requestTypesToGenerate = /* @__PURE__ */ new Map();
   const operationLookup = /* @__PURE__ */ new Map();
@@ -318,8 +318,186 @@ function collectInlineResponseTypes(operations, spec) {
   }
   return responseTypesToGenerate;
 }
+function collectInlineErrorTypes(operations, spec) {
+  const errorTypesToGenerate = /* @__PURE__ */ new Map();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const operation = operationLookup.get(op.operationId);
+    if (!operation) continue;
+    const responses = operation.responses || {};
+    for (const [statusCode, response] of Object.entries(responses)) {
+      if (isErrorStatus(statusCode) && response.content) {
+        const content = response.content;
+        const jsonContent = content["application/json"];
+        if (jsonContent && jsonContent.schema) {
+          const schema = jsonContent.schema;
+          const identifier = mapStatusToIdentifier(statusCode);
+          const typeName = `${capitalize(toCamelCase(op.operationId))}${capitalize(identifier)}`;
+          if (!schema.$ref || schema.allOf || schema.oneOf || schema.anyOf) {
+            errorTypesToGenerate.set(typeName, schema);
+          }
+        }
+      }
+    }
+  }
+  return errorTypesToGenerate;
+}
+
+// ../zenko-core/src/utils/collect-referenced-schemas.ts
+function findContentType(content) {
+  const contentTypes = Object.keys(content);
+  if (contentTypes.includes("application/json")) {
+    return "application/json";
+  }
+  const CONTENT_TYPE_MAP2 = {
+    "application/json": "unknown",
+    "text/csv": "string",
+    "text/plain": "string",
+    "application/octet-stream": "unknown",
+    "application/pdf": "unknown"
+  };
+  for (const contentType of contentTypes) {
+    if (contentType in CONTENT_TYPE_MAP2) {
+      return contentType;
+    }
+  }
+  return contentTypes[0] || "";
+}
+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 collectReferencedSchemas(operations, spec) {
+  const referenced = /* @__PURE__ */ new Set();
+  const operationLookup = /* @__PURE__ */ new Map();
+  for (const [, pathItem] of Object.entries(spec.paths || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const [, pathItem] of Object.entries(spec.webhooks || {})) {
+    for (const [, operation] of Object.entries(pathItem)) {
+      const op = operation;
+      if (op.operationId) {
+        operationLookup.set(op.operationId, op);
+      }
+    }
+  }
+  for (const op of operations) {
+    const rawOperation = operationLookup.get(op.operationId);
+    if (!rawOperation) continue;
+    const requestBody = rawOperation.requestBody?.content?.["application/json"]?.schema;
+    if (requestBody?.$ref) {
+      const refName = extractRefName(requestBody.$ref);
+      referenced.add(refName);
+    } else if (requestBody) {
+      const deps = extractDependencies(requestBody);
+      for (const dep of deps) {
+        if (spec.components?.schemas?.[dep]) {
+          referenced.add(dep);
+        }
+      }
+    }
+    const responses = rawOperation.responses || {};
+    for (const [, response] of Object.entries(responses)) {
+      const content = response?.content;
+      if (!content) continue;
+      const contentType = findContentType(content);
+      const responseSchema = content[contentType]?.schema;
+      if (responseSchema?.$ref) {
+        const refName = extractRefName(responseSchema.$ref);
+        referenced.add(refName);
+      } else if (responseSchema) {
+        const deps = extractDependencies(responseSchema);
+        for (const dep of deps) {
+          if (spec.components?.schemas?.[dep]) {
+            referenced.add(dep);
+          }
+        }
+      }
+    }
+    for (const param of op.queryParams) {
+      if (param.schema?.$ref) {
+        const refName = extractRefName(param.schema.$ref);
+        referenced.add(refName);
+      }
+      if (param.schema?.items?.$ref) {
+        const refName = extractRefName(param.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    for (const header of op.requestHeaders || []) {
+      if (header.schema?.$ref) {
+        const refName = extractRefName(header.schema.$ref);
+        referenced.add(refName);
+      }
+      if (header.schema?.items?.$ref) {
+        const refName = extractRefName(header.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+    const parameters = rawOperation.parameters || [];
+    for (const param of parameters) {
+      const resolvedParam = resolveParameter(param, spec);
+      if (resolvedParam?.schema?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.$ref);
+        referenced.add(refName);
+      }
+      if (resolvedParam?.schema?.items?.$ref) {
+        const refName = extractRefName(resolvedParam.schema.items.$ref);
+        referenced.add(refName);
+      }
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const toVisit = Array.from(referenced);
+  while (toVisit.length > 0) {
+    const schemaName = toVisit.pop();
+    if (visited.has(schemaName)) continue;
+    visited.add(schemaName);
+    const schema = spec.components?.schemas?.[schemaName];
+    if (!schema) continue;
+    const dependencies = extractDependencies(schema);
+    for (const dep of dependencies) {
+      if (spec.components?.schemas?.[dep] && !visited.has(dep)) {
+        referenced.add(dep);
+        toVisit.push(dep);
+      }
+    }
+  }
+  return referenced;
+}
 
-// src/utils/generate-helper-file.ts
+// ../zenko-core/src/utils/generate-helper-file.ts
 function generateHelperFile() {
   const output = [];
   output.push("// Generated helper types for Zenko");
@@ -361,11 +539,11 @@ function generateHelperFile() {
   return output.join("\n");
 }
 
-// src/zenko.ts
+// ../zenko-core/src/zenko.ts
 function generateWithMetadata(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
-  const { strictDates = false, strictNumeric = false } = options;
+  const { strictDates = false, strictNumeric = false, operationIds } = options;
   const typesConfig = normalizeTypesConfig(options.types);
   const schemaOptions = {
     strictDates,
@@ -379,13 +557,26 @@ function generateWithMetadata(spec, options = {}) {
       nameMap.set(name, toCamelCase(name));
     }
   }
-  const operations = parseOperations(spec, nameMap);
+  let operations = parseOperations(spec, nameMap);
+  if (operationIds && operationIds.length > 0) {
+    const selectedIds = new Set(operationIds);
+    operations = operations.filter((op) => selectedIds.has(op.operationId));
+  }
   appendHelperTypesImport(output, typesConfig, operations);
   output.push("");
   if (spec.components?.schemas) {
     output.push("// Generated Zod Schemas");
     output.push("");
-    const sortedSchemas = topologicalSort(spec.components.schemas);
+    let schemasToGenerate;
+    if (operationIds && operationIds.length > 0) {
+      const referencedSchemas = collectReferencedSchemas(operations, spec);
+      schemasToGenerate = Array.from(referencedSchemas);
+    } else {
+      schemasToGenerate = Object.keys(spec.components.schemas);
+    }
+    const sortedSchemas = topologicalSort(spec.components.schemas).filter(
+      (name) => schemasToGenerate.includes(name)
+    );
     for (const name of sortedSchemas) {
       const schema = spec.components.schemas[name];
       const sanitizedName = nameMap.get(name);
@@ -574,6 +765,9 @@ function generateWithMetadata(spec, options = {}) {
   }
   return result;
 }
+function generateFromDocument(spec, options = {}) {
+  return generateWithMetadata(spec, options);
+}
 function generateRequestTypes(output, operations, spec, nameMap, schemaOptions) {
   const requestTypesToGenerate = collectInlineRequestTypes(operations, spec);
   if (requestTypesToGenerate.size > 0) {
@@ -596,7 +790,8 @@ function generateRequestTypes(output, operations, spec, nameMap, schemaOptions)
 }
 function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
   const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
-  if (responseTypesToGenerate.size > 0) {
+  const errorTypesToGenerate = collectInlineErrorTypes(operations, spec);
+  if (responseTypesToGenerate.size > 0 || errorTypesToGenerate.size > 0) {
     output.push("// Generated Response Types");
     output.push("");
     for (const [typeName, schema] of responseTypesToGenerate) {
@@ -612,10 +807,23 @@ function generateResponseTypes(output, operations, spec, nameMap, schemaOptions)
       output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
       output.push("");
     }
+    for (const [typeName, schema] of errorTypesToGenerate) {
+      const generatedSchema = generateZodSchema(
+        typeName,
+        schema,
+        /* @__PURE__ */ new Set(),
+        schemaOptions,
+        nameMap
+      );
+      output.push(generatedSchema);
+      output.push("");
+      output.push(`export type ${typeName} = z.infer<typeof ${typeName}>;`);
+      output.push("");
+    }
   }
 }
 function generate(spec, options = {}) {
-  return generateWithMetadata(spec, options).output;
+  return generateFromDocument(spec, options).output;
 }
 function appendOperationField(buffer, key, value) {
   if (!value) return;
@@ -656,7 +864,7 @@ var CONTENT_TYPE_MAP = {
   "application/octet-stream": "unknown",
   "application/pdf": "unknown"
 };
-function findContentType(content) {
+function findContentType2(content) {
   const contentTypes = Object.keys(content);
   if (contentTypes.includes("application/json")) {
     return "application/json";
@@ -907,7 +1115,7 @@ function collectParameters(pathItem, operation, spec) {
   const addParameters = (params) => {
     if (!Array.isArray(params)) return;
     for (const param of params) {
-      const resolved = resolveParameter(param, spec);
+      const resolved = resolveParameter2(param, spec);
       if (!resolved) continue;
       const key = `${resolved.in}:${resolved.name}`;
       parametersMap.set(key, resolved);
@@ -917,7 +1125,7 @@ function collectParameters(pathItem, operation, spec) {
   addParameters(operation.parameters);
   return Array.from(parametersMap.values());
 }
-function resolveParameter(parameter, spec) {
+function resolveParameter2(parameter, spec) {
   if (!parameter) return void 0;
   if (parameter.$ref) {
     const refName = extractRefName(parameter.$ref);
@@ -972,7 +1180,7 @@ function getResponseTypes(operation, operationId, nameMap) {
       }
       continue;
     }
-    const contentType = findContentType(content);
+    const contentType = findContentType2(content);
     const resolvedSchema = content[contentType]?.schema;
     if (!resolvedSchema) {
       const inferredType = inferResponseType(contentType, statusCode);
@@ -1344,6 +1552,8 @@ function applyNumericBounds(schema, builder) {
   return builder;
 }
 export {
-  generate
+  generate,
+  generateFromDocument,
+  generateWithMetadata
 };
 //# sourceMappingURL=index.mjs.map