@cerios/openapi-to-zod 1.2.0 → 1.3.1

package/dist/internal.d.mts

@@ -1,4 +1,4 @@
-import { E as ExecutionMode, d as OperationFilters } from './types--r0d47sd.mjs';
+import { E as ExecutionMode, g as OperationFilters, f as OpenAPISpec, b as OpenAPIParameter, c as OpenAPIRequestBody, d as OpenAPIResponse, e as OpenAPISchema } from './types-DZ4Bw-D5.mjs';
 import { z } from 'zod';
 import { Loader } from 'cosmiconfig';
 
@@ -60,6 +60,11 @@ declare const RequestResponseOptionsSchema: z.ZodObject<{
     useDescribe: z.ZodOptional<z.ZodBoolean>;
     includeDescriptions: z.ZodOptional<z.ZodBoolean>;
     defaultNullable: z.ZodOptional<z.ZodBoolean>;
+    emptyObjectBehavior: z.ZodOptional<z.ZodEnum<{
+        strict: "strict";
+        loose: "loose";
+        record: "record";
+    }>>;
 }, z.core.$strict>;
 /**
  * @shared Base Zod schema for operation filters (without status codes)
@@ -99,6 +104,43 @@ type BaseOperationFilters = z.infer<typeof OperationFiltersSchema>;
  */
 declare function formatConfigValidationError(error: z.ZodError, filepath: string | undefined, configPath: string | undefined, additionalNotes?: string[]): string;
 
+/**
+ * Content type utilities for determining response parsing methods
+ */
+/**
+ * Result of content type analysis
+ */
+interface ContentTypeParseResult {
+    /**
+     * The recommended parsing method
+     * - "json": Use response.json() for JSON content types
+     * - "text": Use response.text() for text-based content types
+     * - "body": Use response.body() for binary content types
+     */
+    method: "json" | "text" | "body";
+    /**
+     * Whether the content type was unknown and fallback was used
+     */
+    isUnknown: boolean;
+}
+/**
+ * Fallback parsing method for unknown content types
+ */
+type FallbackContentTypeParsing = "json" | "text" | "body";
+/**
+ * Determines the appropriate response parsing method based on content type
+ *
+ * Categories:
+ * - JSON: application/json, text/json, *+json suffix
+ * - Text: text/* (except text/json), application/xml, *+xml suffix, application/javascript
+ * - Binary: image/*, audio/*, video/*, font/*, application/octet-stream, application/pdf, etc.
+ *
+ * @param contentType - The content type to analyze (e.g., "application/json; charset=utf-8")
+ * @param fallback - The method to use for unknown content types (default: "text" for safety)
+ * @returns The recommended parsing method and whether the content type was unknown
+ */
+declare function getResponseParseMethod(contentType: string | undefined, fallback?: FallbackContentTypeParsing): ContentTypeParseResult;
+
 /**
  * @shared Simple LRU Cache implementation for performance optimization
  * @since 1.0.0
@@ -226,6 +268,55 @@ declare function stripPrefix(input: string, pattern: string | undefined, ensureL
  */
 declare function stripPathPrefix(path: string, pattern: string | undefined): string;
 
+/**
+ * OpenAPI $ref resolution utilities
+ *
+ * Provides functions to resolve $ref references to component definitions
+ * Supports: parameters, requestBodies, responses, schemas
+ *
+ * @internal Used by core and playwright packages
+ */
+
+/**
+ * Type for any resolvable component
+ */
+type ResolvableComponent = OpenAPIParameter | OpenAPIRequestBody | OpenAPIResponse | OpenAPISchema | any;
+/**
+ * Resolve a $ref to a component definition
+ * Handles nested $refs by recursively resolving until no more refs found
+ *
+ * @param obj - Object that may contain a $ref
+ * @param spec - The OpenAPI specification
+ * @param maxDepth - Maximum recursion depth to prevent infinite loops (default: 10)
+ * @returns The resolved component, or the original object if not a reference
+ */
+declare function resolveRef<T extends ResolvableComponent>(obj: T | any, spec: OpenAPISpec, maxDepth?: number): T;
+/**
+ * Resolve a parameter reference
+ * Convenience wrapper for resolveRef with parameter type
+ */
+declare function resolveParameterRef(param: any, spec: OpenAPISpec): OpenAPIParameter | any;
+/**
+ * Resolve a request body reference
+ * Convenience wrapper for resolveRef with request body type
+ */
+declare function resolveRequestBodyRef(requestBody: any, spec: OpenAPISpec): OpenAPIRequestBody | any;
+/**
+ * Resolve a response reference
+ * Convenience wrapper for resolveRef with response type
+ */
+declare function resolveResponseRef(response: any, spec: OpenAPISpec): OpenAPIResponse | any;
+/**
+ * Merge path-level parameters with operation-level parameters
+ * Operation parameters override path-level parameters with the same name and location
+ *
+ * @param pathParams - Parameters defined at the path level
+ * @param operationParams - Parameters defined at the operation level
+ * @param spec - The OpenAPI specification for resolving $refs
+ * @returns Merged array of resolved parameters
+ */
+declare function mergeParameters(pathParams: any[] | undefined, operationParams: any[] | undefined, spec: OpenAPISpec): any[];
+
 /**
  * String utility functions for escaping and formatting
  */
@@ -269,4 +360,4 @@ declare function configureDateTimeFormat(pattern?: string | RegExp): void;
  */
 declare function resetFormatMap(): void;
 
-export { type BaseOperationFilters, type FilterStatistics, type Generator, LRUCache, OperationFiltersSchema, type RequestResponseOptions, RequestResponseOptionsSchema, configureDateTimeFormat, createFilterStatistics, createTypeScriptLoader, escapeJSDoc, executeBatch, formatConfigValidationError, formatFilterStatistics, getBatchExitCode, resetFormatMap, shouldIncludeOperation, stripPathPrefix, stripPrefix, toCamelCase, toPascalCase, validateFilters };
+export { type BaseOperationFilters, type ContentTypeParseResult, type FallbackContentTypeParsing, type FilterStatistics, type Generator, LRUCache, OperationFiltersSchema, type RequestResponseOptions, RequestResponseOptionsSchema, configureDateTimeFormat, createFilterStatistics, createTypeScriptLoader, escapeJSDoc, executeBatch, formatConfigValidationError, formatFilterStatistics, getBatchExitCode, getResponseParseMethod, mergeParameters, resetFormatMap, resolveParameterRef, resolveRef, resolveRequestBodyRef, resolveResponseRef, shouldIncludeOperation, stripPathPrefix, stripPrefix, toCamelCase, toPascalCase, validateFilters };

package/dist/internal.d.ts

@@ -1,4 +1,4 @@
-import { E as ExecutionMode, d as OperationFilters } from './types--r0d47sd.js';
+import { E as ExecutionMode, g as OperationFilters, f as OpenAPISpec, b as OpenAPIParameter, c as OpenAPIRequestBody, d as OpenAPIResponse, e as OpenAPISchema } from './types-DZ4Bw-D5.js';
 import { z } from 'zod';
 import { Loader } from 'cosmiconfig';
 
@@ -60,6 +60,11 @@ declare const RequestResponseOptionsSchema: z.ZodObject<{
     useDescribe: z.ZodOptional<z.ZodBoolean>;
     includeDescriptions: z.ZodOptional<z.ZodBoolean>;
     defaultNullable: z.ZodOptional<z.ZodBoolean>;
+    emptyObjectBehavior: z.ZodOptional<z.ZodEnum<{
+        strict: "strict";
+        loose: "loose";
+        record: "record";
+    }>>;
 }, z.core.$strict>;
 /**
  * @shared Base Zod schema for operation filters (without status codes)
@@ -99,6 +104,43 @@ type BaseOperationFilters = z.infer<typeof OperationFiltersSchema>;
  */
 declare function formatConfigValidationError(error: z.ZodError, filepath: string | undefined, configPath: string | undefined, additionalNotes?: string[]): string;
 
+/**
+ * Content type utilities for determining response parsing methods
+ */
+/**
+ * Result of content type analysis
+ */
+interface ContentTypeParseResult {
+    /**
+     * The recommended parsing method
+     * - "json": Use response.json() for JSON content types
+     * - "text": Use response.text() for text-based content types
+     * - "body": Use response.body() for binary content types
+     */
+    method: "json" | "text" | "body";
+    /**
+     * Whether the content type was unknown and fallback was used
+     */
+    isUnknown: boolean;
+}
+/**
+ * Fallback parsing method for unknown content types
+ */
+type FallbackContentTypeParsing = "json" | "text" | "body";
+/**
+ * Determines the appropriate response parsing method based on content type
+ *
+ * Categories:
+ * - JSON: application/json, text/json, *+json suffix
+ * - Text: text/* (except text/json), application/xml, *+xml suffix, application/javascript
+ * - Binary: image/*, audio/*, video/*, font/*, application/octet-stream, application/pdf, etc.
+ *
+ * @param contentType - The content type to analyze (e.g., "application/json; charset=utf-8")
+ * @param fallback - The method to use for unknown content types (default: "text" for safety)
+ * @returns The recommended parsing method and whether the content type was unknown
+ */
+declare function getResponseParseMethod(contentType: string | undefined, fallback?: FallbackContentTypeParsing): ContentTypeParseResult;
+
 /**
  * @shared Simple LRU Cache implementation for performance optimization
  * @since 1.0.0
@@ -226,6 +268,55 @@ declare function stripPrefix(input: string, pattern: string | undefined, ensureL
  */
 declare function stripPathPrefix(path: string, pattern: string | undefined): string;
 
+/**
+ * OpenAPI $ref resolution utilities
+ *
+ * Provides functions to resolve $ref references to component definitions
+ * Supports: parameters, requestBodies, responses, schemas
+ *
+ * @internal Used by core and playwright packages
+ */
+
+/**
+ * Type for any resolvable component
+ */
+type ResolvableComponent = OpenAPIParameter | OpenAPIRequestBody | OpenAPIResponse | OpenAPISchema | any;
+/**
+ * Resolve a $ref to a component definition
+ * Handles nested $refs by recursively resolving until no more refs found
+ *
+ * @param obj - Object that may contain a $ref
+ * @param spec - The OpenAPI specification
+ * @param maxDepth - Maximum recursion depth to prevent infinite loops (default: 10)
+ * @returns The resolved component, or the original object if not a reference
+ */
+declare function resolveRef<T extends ResolvableComponent>(obj: T | any, spec: OpenAPISpec, maxDepth?: number): T;
+/**
+ * Resolve a parameter reference
+ * Convenience wrapper for resolveRef with parameter type
+ */
+declare function resolveParameterRef(param: any, spec: OpenAPISpec): OpenAPIParameter | any;
+/**
+ * Resolve a request body reference
+ * Convenience wrapper for resolveRef with request body type
+ */
+declare function resolveRequestBodyRef(requestBody: any, spec: OpenAPISpec): OpenAPIRequestBody | any;
+/**
+ * Resolve a response reference
+ * Convenience wrapper for resolveRef with response type
+ */
+declare function resolveResponseRef(response: any, spec: OpenAPISpec): OpenAPIResponse | any;
+/**
+ * Merge path-level parameters with operation-level parameters
+ * Operation parameters override path-level parameters with the same name and location
+ *
+ * @param pathParams - Parameters defined at the path level
+ * @param operationParams - Parameters defined at the operation level
+ * @param spec - The OpenAPI specification for resolving $refs
+ * @returns Merged array of resolved parameters
+ */
+declare function mergeParameters(pathParams: any[] | undefined, operationParams: any[] | undefined, spec: OpenAPISpec): any[];
+
 /**
  * String utility functions for escaping and formatting
  */
@@ -269,4 +360,4 @@ declare function configureDateTimeFormat(pattern?: string | RegExp): void;
  */
 declare function resetFormatMap(): void;
 
-export { type BaseOperationFilters, type FilterStatistics, type Generator, LRUCache, OperationFiltersSchema, type RequestResponseOptions, RequestResponseOptionsSchema, configureDateTimeFormat, createFilterStatistics, createTypeScriptLoader, escapeJSDoc, executeBatch, formatConfigValidationError, formatFilterStatistics, getBatchExitCode, resetFormatMap, shouldIncludeOperation, stripPathPrefix, stripPrefix, toCamelCase, toPascalCase, validateFilters };
+export { type BaseOperationFilters, type ContentTypeParseResult, type FallbackContentTypeParsing, type FilterStatistics, type Generator, LRUCache, OperationFiltersSchema, type RequestResponseOptions, RequestResponseOptionsSchema, configureDateTimeFormat, createFilterStatistics, createTypeScriptLoader, escapeJSDoc, executeBatch, formatConfigValidationError, formatFilterStatistics, getBatchExitCode, getResponseParseMethod, mergeParameters, resetFormatMap, resolveParameterRef, resolveRef, resolveRequestBodyRef, resolveResponseRef, shouldIncludeOperation, stripPathPrefix, stripPrefix, toCamelCase, toPascalCase, validateFilters };

package/dist/internal.js

@@ -41,7 +41,13 @@ __export(internal_exports, {
   formatConfigValidationError: () => formatConfigValidationError,
   formatFilterStatistics: () => formatFilterStatistics,
   getBatchExitCode: () => getBatchExitCode,
+  getResponseParseMethod: () => getResponseParseMethod,
+  mergeParameters: () => mergeParameters,
   resetFormatMap: () => resetFormatMap,
+  resolveParameterRef: () => resolveParameterRef,
+  resolveRef: () => resolveRef,
+  resolveRequestBodyRef: () => resolveRequestBodyRef,
+  resolveResponseRef: () => resolveResponseRef,
   shouldIncludeOperation: () => shouldIncludeOperation,
   stripPathPrefix: () => stripPathPrefix,
   stripPrefix: () => stripPrefix,
@@ -187,7 +193,8 @@ var RequestResponseOptionsSchema = import_zod.z.strictObject({
   mode: import_zod.z.enum(["strict", "normal", "loose"]).optional(),
   useDescribe: import_zod.z.boolean().optional(),
   includeDescriptions: import_zod.z.boolean().optional(),
-  defaultNullable: import_zod.z.boolean().optional()
+  defaultNullable: import_zod.z.boolean().optional(),
+  emptyObjectBehavior: import_zod.z.enum(["strict", "loose", "record"]).optional()
 });
 var OperationFiltersSchema = import_zod.z.strictObject({
   includeTags: import_zod.z.array(import_zod.z.string()).optional(),
@@ -227,6 +234,45 @@ function formatConfigValidationError(error, filepath, configPath, additionalNote
   return lines.join("\n");
 }
 
+// src/utils/content-type-utils.ts
+function getResponseParseMethod(contentType, fallback = "text") {
+  if (!contentType) {
+    return { method: fallback, isUnknown: true };
+  }
+  const normalized = contentType.toLowerCase().split(";")[0].trim();
+  if (!normalized) {
+    return { method: fallback, isUnknown: true };
+  }
+  if (normalized === "application/json" || normalized === "text/json" || normalized.endsWith("+json")) {
+    return { method: "json", isUnknown: false };
+  }
+  if (normalized.startsWith("text/")) {
+    return { method: "text", isUnknown: false };
+  }
+  if (normalized === "application/xml" || normalized.endsWith("+xml")) {
+    return { method: "text", isUnknown: false };
+  }
+  if (normalized === "application/javascript" || normalized === "application/x-javascript" || normalized === "application/ecmascript") {
+    return { method: "text", isUnknown: false };
+  }
+  if (normalized.startsWith("image/")) {
+    return { method: "body", isUnknown: false };
+  }
+  if (normalized.startsWith("audio/")) {
+    return { method: "body", isUnknown: false };
+  }
+  if (normalized.startsWith("video/")) {
+    return { method: "body", isUnknown: false };
+  }
+  if (normalized.startsWith("font/")) {
+    return { method: "body", isUnknown: false };
+  }
+  if (normalized === "application/octet-stream" || normalized === "application/pdf" || normalized === "application/zip" || normalized === "application/gzip" || normalized === "application/x-tar" || normalized === "application/x-7z-compressed" || normalized === "application/x-rar-compressed" || normalized === "application/wasm" || normalized === "application/x-protobuf") {
+    return { method: "body", isUnknown: false };
+  }
+  return { method: fallback, isUnknown: true };
+}
+
 // src/utils/lru-cache.ts
 var LRUCache = class {
   constructor(maxSize) {
@@ -282,12 +328,12 @@ function toCamelCase(str, options) {
     name = words[0].charAt(0).toLowerCase() + words[0].slice(1) + words.slice(1).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
   }
   if (options == null ? void 0 : options.prefix) {
-    const prefix = options.prefix.toLowerCase();
+    const prefix = options.prefix.charAt(0).toLowerCase() + options.prefix.slice(1);
     name = prefix + name.charAt(0).toUpperCase() + name.slice(1);
   }
   if (options == null ? void 0 : options.suffix) {
-    const suffix = options.suffix;
-    name = name + suffix.charAt(0).toUpperCase() + suffix.slice(1).toLowerCase();
+    const suffix = options.suffix.charAt(0).toUpperCase() + options.suffix.slice(1);
+    name = name + suffix;
   }
   return name;
 }
@@ -522,6 +568,65 @@ function stripPathPrefix(path, pattern) {
   return stripPrefix(path, pattern, "/");
 }
 
+// src/utils/ref-resolver.ts
+function resolveRef(obj, spec, maxDepth = 10) {
+  var _a, _b, _c, _d;
+  if (!obj || typeof obj !== "object" || maxDepth <= 0) return obj;
+  if (!obj.$ref) return obj;
+  const ref = obj.$ref;
+  let resolved = null;
+  const paramMatch = ref.match(/^#\/components\/parameters\/(.+)$/);
+  const requestBodyMatch = ref.match(/^#\/components\/requestBodies\/(.+)$/);
+  const responseMatch = ref.match(/^#\/components\/responses\/(.+)$/);
+  const schemaMatch = ref.match(/^#\/components\/schemas\/(.+)$/);
+  if (paramMatch && ((_a = spec.components) == null ? void 0 : _a.parameters)) {
+    const name = paramMatch[1];
+    resolved = spec.components.parameters[name];
+  } else if (requestBodyMatch && ((_b = spec.components) == null ? void 0 : _b.requestBodies)) {
+    const name = requestBodyMatch[1];
+    resolved = spec.components.requestBodies[name];
+  } else if (responseMatch && ((_c = spec.components) == null ? void 0 : _c.responses)) {
+    const name = responseMatch[1];
+    resolved = spec.components.responses[name];
+  } else if (schemaMatch && ((_d = spec.components) == null ? void 0 : _d.schemas)) {
+    const name = schemaMatch[1];
+    resolved = spec.components.schemas[name];
+  }
+  if (resolved) {
+    if (resolved.$ref) {
+      return resolveRef(resolved, spec, maxDepth - 1);
+    }
+    return resolved;
+  }
+  return obj;
+}
+function resolveParameterRef(param, spec) {
+  return resolveRef(param, spec);
+}
+function resolveRequestBodyRef(requestBody, spec) {
+  return resolveRef(requestBody, spec);
+}
+function resolveResponseRef(response, spec) {
+  return resolveRef(response, spec);
+}
+function mergeParameters(pathParams, operationParams, spec) {
+  const resolvedPathParams = (pathParams || []).map((p) => resolveParameterRef(p, spec));
+  const resolvedOperationParams = (operationParams || []).map((p) => resolveParameterRef(p, spec));
+  const merged = [...resolvedPathParams];
+  for (const opParam of resolvedOperationParams) {
+    if (!opParam || typeof opParam !== "object") continue;
+    const existingIndex = merged.findIndex(
+      (p) => p && typeof p === "object" && p.name === opParam.name && p.in === opParam.in
+    );
+    if (existingIndex >= 0) {
+      merged[existingIndex] = opParam;
+    } else {
+      merged.push(opParam);
+    }
+  }
+  return merged;
+}
+
 // src/utils/string-utils.ts
 function escapePattern(str) {
   return str.replace(/\//g, "\\/");
@@ -637,7 +742,13 @@ function resetFormatMap() {
   formatConfigValidationError,
   formatFilterStatistics,
   getBatchExitCode,
+  getResponseParseMethod,
+  mergeParameters,
   resetFormatMap,
+  resolveParameterRef,
+  resolveRef,
+  resolveRequestBodyRef,
+  resolveResponseRef,
   shouldIncludeOperation,
   stripPathPrefix,
   stripPrefix,