zenko 0.1.10-beta.3 → 0.1.10

package/README.md

@@ -17,25 +17,30 @@ Unlike most OpenAPI generators, Zenko does not create a client. Instead you are
 
 ## Installation
 
-### One-time Usage (Bun)
+### One-time Usage
 
 ```bash
-# Use directly with bunx (no installation required)
+# Use directly with npx (no installation required)
+npx zenko input.yaml output.ts
+
+# Or with bunx
 bunx zenko input.yaml output.ts
 ```
 
-### Install for Repeated Use (Bun runtime)
+### Install for Repeated Use
 
 ```bash
 # Install globally
+npm install -g zenko
 bun install -g zenko
 
 # Or install locally
+npm install zenko
 bun add zenko
+yarn add zenko
+pnpm add zenko
 ```
 
-> 💡 Need pure Node.js support? Install [`zenko-node`](../zenko-node/README.md) for an equivalent CLI and library powered by `js-yaml`.
-
 ## Usage
 
 ### Command Line
@@ -98,13 +103,18 @@ The config file controls generation for multiple specs and can also configure ty
 ### Programmatic Usage
 
 ```typescript
-import { generateFromDocument, type OpenAPISpec } from "zenko"
+import { generate, type OpenAPISpec } from "zenko"
+import * as fs from "fs"
+import { load } from "js-yaml"
+
+// Load your OpenAPI spec
+const spec = load(fs.readFileSync("api.yaml", "utf8")) as OpenAPISpec
 
-const specText = await Bun.file("api.yaml").text()
-const spec = Bun.YAML.parse(specText) as OpenAPISpec
+// Generate TypeScript code
+const output = generate(spec)
 
-const { output } = generateFromDocument(spec)
-await Bun.write("types.ts", output)
+// Write to file
+fs.writeFileSync("types.ts", output)
 ```
 
 #### ES Modules
@@ -274,7 +284,7 @@ bun test
 bun run build
 
 # Test with example spec
-zenko ../zenko-core/src/resources/petstore.yaml output.ts
+zenko src/resources/petstore.yaml output.ts
 
 # Format code
 bun run format

package/dist/cli.cjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -24,10 +24,12 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/cli.ts
-var path2 = __toESM(require("path"), 1);
-var import_promises = require("fs/promises");
+var fs = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+var import_url = require("url");
+var import_js_yaml = require("js-yaml");
 
-// ../zenko-core/src/utils/topological-sort.ts
+// src/utils/topological-sort.ts
 function topologicalSort(schemas) {
   const visited = /* @__PURE__ */ new Set();
   const visiting = /* @__PURE__ */ new Set();
@@ -76,7 +78,7 @@ function extractRefName(ref) {
   return ref.split("/").pop() || "Unknown";
 }
 
-// ../zenko-core/src/utils/property-name.ts
+// src/utils/property-name.ts
 function isValidJSIdentifier(name) {
   if (!name) return false;
   const firstChar = name.at(0);
@@ -156,7 +158,7 @@ function formatPropertyName(name) {
   return isValidJSIdentifier(name) ? name : `"${name}"`;
 }
 
-// ../zenko-core/src/utils/string-utils.ts
+// src/utils/string-utils.ts
 function toCamelCase(str) {
   return str.replace(/-([a-zA-Z])/g, (_, letter) => letter.toUpperCase()).replace(/-+$/, "");
 }
@@ -164,7 +166,7 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 
-// ../zenko-core/src/utils/http-status.ts
+// src/utils/http-status.ts
 var statusNameMap = {
   "400": "badRequest",
   "401": "unauthorized",
@@ -230,7 +232,7 @@ function isErrorStatus(status) {
   return code >= 400;
 }
 
-// ../zenko-core/src/utils/tree-shaking.ts
+// src/utils/tree-shaking.ts
 function analyzeZenkoUsage(operations) {
   const usage = {
     usesHeaderFn: false,
@@ -270,7 +272,7 @@ function hasAnyErrors(errors) {
   return Boolean(errors && Object.keys(errors).length > 0);
 }
 
-// ../zenko-core/src/utils/collect-inline-types.ts
+// src/utils/collect-inline-types.ts
 function collectInlineRequestTypes(operations, spec) {
   const requestTypesToGenerate = /* @__PURE__ */ new Map();
   const operationLookup = /* @__PURE__ */ new Map();
@@ -347,48 +349,8 @@ 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
+// src/utils/collect-referenced-schemas.ts
 function findContentType(content) {
   const contentTypes = Object.keys(content);
   if (contentTypes.includes("application/json")) {
@@ -526,7 +488,7 @@ function collectReferencedSchemas(operations, spec) {
   return referenced;
 }
 
-// ../zenko-core/src/utils/generate-helper-file.ts
+// src/utils/generate-helper-file.ts
 function generateHelperFile() {
   const output = [];
   output.push("// Generated helper types for Zenko");
@@ -568,7 +530,7 @@ function generateHelperFile() {
   return output.join("\n");
 }
 
-// ../zenko-core/src/zenko.ts
+// src/zenko.ts
 function generateWithMetadata(spec, options = {}) {
   const output = [];
   const generatedTypes = /* @__PURE__ */ new Set();
@@ -794,9 +756,6 @@ 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) {
@@ -819,8 +778,7 @@ function generateRequestTypes(output, operations, spec, nameMap, schemaOptions)
 }
 function generateResponseTypes(output, operations, spec, nameMap, schemaOptions) {
   const responseTypesToGenerate = collectInlineResponseTypes(operations, spec);
-  const errorTypesToGenerate = collectInlineErrorTypes(operations, spec);
-  if (responseTypesToGenerate.size > 0 || errorTypesToGenerate.size > 0) {
+  if (responseTypesToGenerate.size > 0) {
     output.push("// Generated Response Types");
     output.push("");
     for (const [typeName, schema] of responseTypesToGenerate) {
@@ -836,19 +794,6 @@ 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 appendOperationField(buffer, key, value) {
@@ -914,12 +859,12 @@ function inferResponseType(contentType, statusCode) {
 function parseOperations(spec, nameMap) {
   const operations = [];
   if (spec.paths) {
-    for (const [path3, pathItem] of Object.entries(spec.paths)) {
+    for (const [path2, 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(path3);
+        const pathParams = extractPathParams(path2);
         const requestType = getRequestType(operation);
         const { successResponse, errors } = getResponseTypes(
           operation,
@@ -931,7 +876,7 @@ function parseOperations(spec, nameMap) {
         const queryParams = getQueryParams(resolvedParameters);
         operations.push({
           operationId: operation.operationId,
-          path: path3,
+          path: path2,
           method: normalizedMethod,
           pathParams,
           queryParams,
@@ -949,8 +894,8 @@ function parseOperations(spec, nameMap) {
         const normalizedMethod = method.toLowerCase();
         if (!isRequestMethod(normalizedMethod)) continue;
         if (!operation.operationId) continue;
-        const path3 = webhookName;
-        const pathParams = extractPathParams(path3);
+        const path2 = webhookName;
+        const pathParams = extractPathParams(path2);
         const requestType = getRequestType(operation);
         const { successResponse, errors } = getResponseTypes(
           operation,
@@ -965,7 +910,7 @@ function parseOperations(spec, nameMap) {
         const queryParams = getQueryParams(resolvedParameters);
         operations.push({
           operationId: operation.operationId,
-          path: path3,
+          path: path2,
           method: normalizedMethod,
           pathParams,
           queryParams,
@@ -1165,9 +1110,9 @@ function resolveParameter2(parameter, spec) {
   }
   return parameter;
 }
-function extractPathParams(path3) {
+function extractPathParams(path2) {
   const params = [];
-  const matches = path3.match(/{([^}]+)}/g);
+  const matches = path2.match(/{([^}]+)}/g);
   if (matches) {
     for (const match of matches) {
       const paramName = match.slice(1, -1);
@@ -1578,74 +1523,6 @@ function applyNumericBounds(schema, builder) {
   return builder;
 }
 
-// src/loader.ts
-var path = __toESM(require("path"), 1);
-var import_url = require("url");
-var YAML_EXTENSIONS = /* @__PURE__ */ new Set([".yaml", ".yml"]);
-var JSON_EXTENSIONS = /* @__PURE__ */ new Set([".json"]);
-async function readFileText(filePath) {
-  const file = Bun.file(filePath);
-  if (!await file.exists()) {
-    throw new Error(`File not found: ${filePath}`);
-  }
-  return await file.text();
-}
-async function loadConfig(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  if (JSON_EXTENSIONS.has(extension)) {
-    const content = await readFileText(filePath);
-    return JSON.parse(content);
-  }
-  if (YAML_EXTENSIONS.has(extension)) {
-    const content = await readFileText(filePath);
-    return Bun.YAML.parse(content);
-  }
-  const fileUrl = (0, import_url.pathToFileURL)(filePath).href;
-  const module2 = await import(fileUrl);
-  return module2.default ?? module2.config ?? module2;
-}
-async function loadSpec(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  const content = await readFileText(filePath);
-  if (YAML_EXTENSIONS.has(extension)) {
-    const parsed = Bun.YAML.parse(content);
-    if (!parsed || typeof parsed !== "object") {
-      throw new Error(`YAML spec did not resolve to an object: ${filePath}`);
-    }
-    if (Array.isArray(parsed)) {
-      throw new Error(
-        `YAML spec produced multiple documents; provide a single document in ${filePath}`
-      );
-    }
-    return parsed;
-  }
-  if (JSON_EXTENSIONS.has(extension)) {
-    return JSON.parse(content);
-  }
-  throw new Error(
-    `Unsupported specification format for ${filePath}. Expected .yaml, .yml, or .json`
-  );
-}
-function normalizeGenerationOptions(entry, baseDir, defaults) {
-  const resolvedInput = path.isAbsolute(entry.input) ? entry.input : path.join(baseDir, entry.input);
-  const resolvedOutput = path.isAbsolute(entry.output) ? entry.output : path.join(baseDir, entry.output);
-  return {
-    resolvedInput,
-    resolvedOutput,
-    strictDates: entry.strictDates ?? defaults.strictDates,
-    strictNumeric: entry.strictNumeric ?? defaults.strictNumeric,
-    types: mergeTypesConfig(defaults.types, entry.types),
-    operationIds: entry.operationIds ?? defaults.operationIds
-  };
-}
-function mergeTypesConfig(baseConfig, entryConfig) {
-  if (!baseConfig && !entryConfig) return void 0;
-  return {
-    ...baseConfig,
-    ...entryConfig
-  };
-}
-
 // src/cli.ts
 async function main() {
   const args = process.argv.slice(2);
@@ -1671,8 +1548,8 @@ async function main() {
         return;
       }
       await generateSingle({
-        resolvedInput: path2.resolve(inputFile),
-        resolvedOutput: path2.resolve(outputFile),
+        inputFile,
+        outputFile,
         strictDates: parsed.strictDates,
         strictNumeric: parsed.strictNumeric
       });
@@ -1740,22 +1617,39 @@ function printHelp() {
 }
 async function runFromConfig(parsed) {
   const configPath = parsed.configPath;
-  const resolvedConfigPath = path2.resolve(configPath);
-  const configDocument = await loadConfig(resolvedConfigPath);
-  validateConfig(configDocument);
-  const config = configDocument;
-  const baseDir = path2.dirname(resolvedConfigPath);
-  const defaults = {
-    strictDates: parsed.strictDates,
-    strictNumeric: parsed.strictNumeric,
-    types: config.types,
-    operationIds: void 0
-  };
+  const resolvedConfigPath = path.resolve(configPath);
+  const config = await loadConfig(resolvedConfigPath);
+  validateConfig(config);
+  const baseDir = path.dirname(resolvedConfigPath);
+  const baseTypesConfig = config.types;
   for (const entry of config.schemas) {
-    const options = normalizeGenerationOptions(entry, baseDir, defaults);
-    await generateSingle(options);
+    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,
+      typesConfig,
+      operationIds: entry.operationIds
+    });
   }
 }
+async function loadConfig(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === ".json") {
+    const content = fs.readFileSync(filePath, "utf8");
+    return JSON.parse(content);
+  }
+  if (extension === ".yaml" || extension === ".yml") {
+    const content = fs.readFileSync(filePath, "utf8");
+    return (0, import_js_yaml.load)(content);
+  }
+  const fileUrl = (0, import_url.pathToFileURL)(filePath).href;
+  const module2 = await import(fileUrl);
+  return module2.default ?? module2.config ?? module2;
+}
 function validateConfig(config) {
   if (!config || typeof config !== "object") {
     throw new Error("Config file must export an object");
@@ -1772,44 +1666,68 @@ 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 {
-    resolvedInput,
-    resolvedOutput,
-    strictDates = false,
-    strictNumeric = false,
-    types,
+    inputFile,
+    outputFile,
+    strictDates,
+    strictNumeric,
+    typesConfig,
     operationIds
   } = options;
-  const spec = await loadSpec(resolvedInput);
-  const result = generateFromDocument(spec, {
+  const resolvedInput = path.resolve(inputFile);
+  const resolvedOutput = path.resolve(outputFile);
+  const spec = readSpec(resolvedInput);
+  const result = generateWithMetadata(spec, {
     strictDates,
     strictNumeric,
-    types,
+    types: typesConfig,
     operationIds
   });
-  await (0, import_promises.mkdir)(path2.dirname(resolvedOutput), { recursive: true });
-  await Bun.write(resolvedOutput, result.output);
+  fs.mkdirSync(path.dirname(resolvedOutput), { recursive: true });
+  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 (spec.webhooks) {
     console.log(`\u{1FA9D} Processed ${Object.keys(spec.webhooks).length} webhooks`);
   }
   if (result.helperFile) {
-    const helperPath = path2.isAbsolute(result.helperFile.path) ? result.helperFile.path : path2.resolve(path2.dirname(resolvedOutput), result.helperFile.path);
-    const absoluteResolvedOutput = path2.resolve(resolvedOutput);
-    const absoluteHelperPath = path2.resolve(helperPath);
+    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;
     }
-    await (0, import_promises.mkdir)(path2.dirname(helperPath), { recursive: true });
-    await Bun.write(helperPath, result.helperFile.content);
+    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)) {
+    throw new Error(`Input file not found: ${filePath}`);
+  }
+  const content = fs.readFileSync(filePath, "utf8");
+  if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
+    return (0, import_js_yaml.load)(content);
+  }
+  return JSON.parse(content);
+}
 main().catch((error) => {
   console.error("\u274C Error:", error);
   process.exit(1);