zenko 0.1.10-beta.2 → 0.1.10-beta.4

package/dist/index.d.ts

@@ -1 +1,48 @@
-export { GenerateOptions, GenerateResult, HeaderFn, OpenAPISpec, OperationDefinition, OperationErrors, PathFn, TypesConfig, TypesHelperMode, generate, generateFromDocument, generateWithMetadata } from '@zenko/core';
+type OpenAPISpec = {
+    openapi: string;
+    info: unknown;
+    paths: Record<string, Record<string, unknown>>;
+    webhooks?: Record<string, Record<string, unknown>>;
+    components?: {
+        schemas?: Record<string, unknown>;
+        parameters?: Record<string, unknown>;
+    };
+};
+type TypesHelperMode = "package" | "inline" | "file";
+type TypesConfig = {
+    emit?: boolean;
+    helpers?: TypesHelperMode;
+    helpersOutput?: string;
+    treeShake?: boolean;
+    optionalType?: "optional" | "nullable" | "nullish";
+};
+type GenerateOptions = {
+    strictDates?: boolean;
+    strictNumeric?: boolean;
+    types?: TypesConfig;
+    operationIds?: string[];
+};
+/**
+ * Generates TypeScript client code from an OpenAPI specification.
+ *
+ * @param spec - The OpenAPI specification object.
+ * @param options - Configuration options controlling code generation behavior.
+ * @returns Generated TypeScript code as a string.
+ */
+declare function generate(spec: OpenAPISpec, options?: GenerateOptions): string;
+
+type PathFn<TArgs extends unknown[] = []> = (...args: TArgs) => string;
+type RequestMethod = "get" | "put" | "post" | "delete" | "options" | "head" | "patch" | "trace";
+type HeaderFn<TArgs extends unknown[] = [], TResult = Record<string, unknown> | Record<string, never>> = (...args: TArgs) => TResult;
+type AnyHeaderFn = HeaderFn<any, unknown> | (() => unknown);
+type OperationErrors<TError = unknown> = TError extends Record<string, unknown> ? TError : Record<string, TError>;
+type OperationDefinition<TMethod extends RequestMethod, TPath extends (...args: any[]) => string, TRequest = undefined, TResponse = undefined, THeaders extends AnyHeaderFn | undefined = undefined, TErrors extends OperationErrors | undefined = undefined> = {
+    method: TMethod;
+    path: TPath;
+    request?: TRequest;
+    response?: TResponse;
+    headers?: THeaders;
+    errors?: TErrors;
+};
+
+export { type GenerateOptions, type HeaderFn, type OpenAPISpec, type OperationDefinition, type OperationErrors, type PathFn, type TypesConfig, generate };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-// ../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();
@@ -47,7 +47,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);
@@ -127,7 +127,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(/-+$/, "");
 }
@@ -135,7 +135,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",
@@ -201,7 +201,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,
@@ -241,7 +241,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();
@@ -318,48 +318,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")) {
@@ -497,7 +457,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");
@@ -539,7 +499,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();
@@ -765,9 +725,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) {
@@ -790,8 +747,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) {
@@ -807,23 +763,10 @@ 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 generateFromDocument(spec, options).output;
+  return generateWithMetadata(spec, options).output;
 }
 function appendOperationField(buffer, key, value) {
   if (!value) return;
@@ -1552,8 +1495,6 @@ function applyNumericBounds(schema, builder) {
   return builder;
 }
 export {
-  generate,
-  generateFromDocument,
-  generateWithMetadata
+  generate
 };
 //# sourceMappingURL=index.mjs.map