@morojs/moro 1.0.0 → 1.0.2

package/src/core/docs/zod-to-openapi.ts

@@ -14,10 +14,10 @@ import {
   ZodDefault,
   ZodUnion,
   ZodLiteral,
-} from "zod";
-import { createFrameworkLogger } from "../logger";
+} from 'zod';
+import { createFrameworkLogger } from '../logger';
 
-const logger = createFrameworkLogger("ZodToOpenAPI");
+const logger = createFrameworkLogger('ZodToOpenAPI');
 
 // OpenAPI schema types
 export interface OpenAPISchema {
@@ -50,10 +50,7 @@ export interface ConversionOptions {
 }
 
 // Main conversion function
-export function zodToOpenAPI(
-  schema: ZodSchema,
-  options: ConversionOptions = {},
-): OpenAPISchema {
+export function zodToOpenAPI(schema: ZodSchema, options: ConversionOptions = {}): OpenAPISchema {
   const opts = {
     includeExamples: true,
     includeDescriptions: true,
@@ -64,14 +61,14 @@ export function zodToOpenAPI(
   try {
     return convertZodType(schema._def, opts);
   } catch (error) {
-    logger.error("Failed to convert Zod schema to OpenAPI", "Conversion", {
+    logger.error('Failed to convert Zod schema to OpenAPI', 'Conversion', {
       error: error instanceof Error ? error.message : String(error),
     });
 
     // Return a basic schema as fallback
     return {
-      type: "object",
-      description: "Schema conversion failed",
+      type: 'object',
+      description: 'Schema conversion failed',
       additionalProperties: true,
     };
   }
@@ -79,84 +76,81 @@ export function zodToOpenAPI(
 
 // Convert Zod type definition to OpenAPI schema
 function convertZodType(def: any, options: ConversionOptions): OpenAPISchema {
-  if (!def || typeof def !== "object") {
-    logger.warn("Invalid Zod definition received", "Conversion", { def });
-    return { type: "object", additionalProperties: true };
+  if (!def || typeof def !== 'object') {
+    logger.warn('Invalid Zod definition received', 'Conversion', { def });
+    return { type: 'object', additionalProperties: true };
   }
 
   // Handle newer Zod structure - check for 'type' field first, then 'typeName'
   const typeName = def.typeName || def.type;
 
   if (!typeName) {
-    logger.warn("Missing typeName/type in Zod definition", "Conversion", {
+    logger.warn('Missing typeName/type in Zod definition', 'Conversion', {
       def: JSON.stringify(def).substring(0, 200),
     });
-    return { type: "object", additionalProperties: true };
+    return { type: 'object', additionalProperties: true };
   }
 
   switch (typeName) {
-    case "ZodString":
-    case "string":
+    case 'ZodString':
+    case 'string':
       return convertZodString(def, options);
 
-    case "ZodNumber":
-    case "number":
+    case 'ZodNumber':
+    case 'number':
       return convertZodNumber(def, options);
 
-    case "ZodBoolean":
-    case "boolean":
+    case 'ZodBoolean':
+    case 'boolean':
       return convertZodBoolean(def, options);
 
-    case "ZodObject":
-    case "object":
+    case 'ZodObject':
+    case 'object':
       return convertZodObject(def, options);
 
-    case "ZodArray":
-    case "array":
+    case 'ZodArray':
+    case 'array':
       return convertZodArray(def, options);
 
-    case "ZodEnum":
-    case "enum":
+    case 'ZodEnum':
+    case 'enum':
       return convertZodEnum(def, options);
 
-    case "ZodOptional":
-    case "optional":
+    case 'ZodOptional':
+    case 'optional':
       return convertZodOptional(def, options);
 
-    case "ZodDefault":
-    case "default":
+    case 'ZodDefault':
+    case 'default':
       return convertZodDefault(def, options);
 
-    case "ZodUnion":
-    case "union":
+    case 'ZodUnion':
+    case 'union':
       return convertZodUnion(def, options);
 
-    case "ZodLiteral":
-    case "literal":
+    case 'ZodLiteral':
+    case 'literal':
       return convertZodLiteral(def, options);
 
-    case "ZodDate":
+    case 'ZodDate':
       return {
-        type: "string",
-        format: "date-time",
-        description: options.includeDescriptions
-          ? "ISO 8601 date-time string"
-          : undefined,
+        type: 'string',
+        format: 'date-time',
+        description: options.includeDescriptions ? 'ISO 8601 date-time string' : undefined,
       };
 
-    case "ZodUUID":
+    case 'ZodUUID':
       return {
-        type: "string",
-        format: "uuid",
-        pattern:
-          "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
-        description: options.includeDescriptions ? "UUID string" : undefined,
+        type: 'string',
+        format: 'uuid',
+        pattern: '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$',
+        description: options.includeDescriptions ? 'UUID string' : undefined,
       };
 
     default:
-      logger.warn(`Unsupported Zod type: ${typeName}`, "Conversion");
+      logger.warn(`Unsupported Zod type: ${typeName}`, 'Conversion');
       return {
-        type: "object",
+        type: 'object',
         description: `Unsupported type: ${typeName}`,
         additionalProperties: true,
       };
@@ -165,48 +159,47 @@ function convertZodType(def: any, options: ConversionOptions): OpenAPISchema {
 
 // Convert ZodString
 function convertZodString(def: any, options: ConversionOptions): OpenAPISchema {
-  const schema: OpenAPISchema = { type: "string" };
+  const schema: OpenAPISchema = { type: 'string' };
 
   // Handle checks (validations)
   if (def.checks) {
     for (const check of def.checks) {
       switch (check.kind) {
-        case "min":
+        case 'min':
           schema.minLength = check.value;
           break;
-        case "max":
+        case 'max':
           schema.maxLength = check.value;
           break;
-        case "email":
-          schema.format = "email";
+        case 'email':
+          schema.format = 'email';
           break;
-        case "url":
-          schema.format = "uri";
+        case 'url':
+          schema.format = 'uri';
           break;
-        case "uuid":
-          schema.format = "uuid";
-          schema.pattern =
-            "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+        case 'uuid':
+          schema.format = 'uuid';
+          schema.pattern = '^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$';
           break;
-        case "regex":
+        case 'regex':
           schema.pattern = check.regex.source;
           break;
-        case "datetime":
-          schema.format = "date-time";
+        case 'datetime':
+          schema.format = 'date-time';
           break;
       }
     }
   }
 
   if (options.includeExamples) {
-    if (schema.format === "email") {
-      schema.example = "user@example.com";
-    } else if (schema.format === "uuid") {
-      schema.example = "123e4567-e89b-12d3-a456-426614174000";
-    } else if (schema.format === "date-time") {
-      schema.example = "2023-12-01T10:00:00Z";
+    if (schema.format === 'email') {
+      schema.example = 'user@example.com';
+    } else if (schema.format === 'uuid') {
+      schema.example = '123e4567-e89b-12d3-a456-426614174000';
+    } else if (schema.format === 'date-time') {
+      schema.example = '2023-12-01T10:00:00Z';
     } else {
-      schema.example = "string";
+      schema.example = 'string';
     }
   }
 
@@ -215,37 +208,34 @@ function convertZodString(def: any, options: ConversionOptions): OpenAPISchema {
 
 // Convert ZodNumber
 function convertZodNumber(def: any, options: ConversionOptions): OpenAPISchema {
-  const schema: OpenAPISchema = { type: "number" };
+  const schema: OpenAPISchema = { type: 'number' };
 
   if (def.checks) {
     for (const check of def.checks) {
       switch (check.kind) {
-        case "min":
+        case 'min':
           schema.minimum = check.value;
           break;
-        case "max":
+        case 'max':
           schema.maximum = check.value;
           break;
-        case "int":
-          schema.type = "integer";
+        case 'int':
+          schema.type = 'integer';
           break;
       }
     }
   }
 
   if (options.includeExamples) {
-    schema.example = schema.type === "integer" ? 42 : 3.14;
+    schema.example = schema.type === 'integer' ? 42 : 3.14;
   }
 
   return schema;
 }
 
 // Convert ZodBoolean
-function convertZodBoolean(
-  def: any,
-  options: ConversionOptions,
-): OpenAPISchema {
-  const schema: OpenAPISchema = { type: "boolean" };
+function convertZodBoolean(def: any, options: ConversionOptions): OpenAPISchema {
+  const schema: OpenAPISchema = { type: 'boolean' };
 
   if (options.includeExamples) {
     schema.example = true;
@@ -257,20 +247,20 @@ function convertZodBoolean(
 // Convert ZodObject
 function convertZodObject(def: any, options: ConversionOptions): OpenAPISchema {
   const schema: OpenAPISchema = {
-    type: "object",
+    type: 'object',
     properties: {},
     required: [],
   };
 
   // Handle both old and new Zod object structures
   let shape;
-  if (typeof def.shape === "function") {
+  if (typeof def.shape === 'function') {
     shape = def.shape();
-  } else if (def.shape && typeof def.shape === "object") {
+  } else if (def.shape && typeof def.shape === 'object') {
     shape = def.shape;
   } else {
-    logger.warn("Could not extract shape from Zod object", "Conversion");
-    return { type: "object", additionalProperties: true };
+    logger.warn('Could not extract shape from Zod object', 'Conversion');
+    return { type: 'object', additionalProperties: true };
   }
 
   for (const [key, value] of Object.entries(shape)) {
@@ -291,10 +281,10 @@ function convertZodObject(def: any, options: ConversionOptions): OpenAPISchema {
     // Check if field is required (not optional and no default)
     const typeStr = typeDef.typeName || typeDef.type;
     if (
-      typeStr !== "optional" &&
-      typeStr !== "ZodOptional" &&
-      typeStr !== "default" &&
-      typeStr !== "ZodDefault"
+      typeStr !== 'optional' &&
+      typeStr !== 'ZodOptional' &&
+      typeStr !== 'default' &&
+      typeStr !== 'ZodDefault'
     ) {
       schema.required!.push(key);
     }
@@ -311,25 +301,20 @@ function convertZodObject(def: any, options: ConversionOptions): OpenAPISchema {
 // Convert ZodArray
 function convertZodArray(def: any, options: ConversionOptions): OpenAPISchema {
   const schema: OpenAPISchema = {
-    type: "array",
-    items:
-      def.type && def.type._def
-        ? convertZodType(def.type._def, options)
-        : { type: "string" },
+    type: 'array',
+    items: def.type && def.type._def ? convertZodType(def.type._def, options) : { type: 'string' },
   };
 
   // Handle array length constraints
   if (def.minLength !== null && def.minLength !== undefined) {
-    schema.minLength =
-      typeof def.minLength === "object" ? def.minLength.value : def.minLength;
+    schema.minLength = typeof def.minLength === 'object' ? def.minLength.value : def.minLength;
   }
   if (def.maxLength !== null && def.maxLength !== undefined) {
-    schema.maxLength =
-      typeof def.maxLength === "object" ? def.maxLength.value : def.maxLength;
+    schema.maxLength = typeof def.maxLength === 'object' ? def.maxLength.value : def.maxLength;
   }
 
   if (options.includeExamples && schema.items) {
-    schema.example = [schema.items.example || "item"];
+    schema.example = [schema.items.example || 'item'];
   }
 
   return schema;
@@ -338,16 +323,11 @@ function convertZodArray(def: any, options: ConversionOptions): OpenAPISchema {
 // Convert ZodEnum
 function convertZodEnum(def: any, options: ConversionOptions): OpenAPISchema {
   const schema: OpenAPISchema = {
-    type: "string",
+    type: 'string',
     enum: def.values || [],
   };
 
-  if (
-    options.includeExamples &&
-    def.values &&
-    Array.isArray(def.values) &&
-    def.values.length > 0
-  ) {
+  if (options.includeExamples && def.values && Array.isArray(def.values) && def.values.length > 0) {
     schema.example = def.values[0];
   }
 
@@ -355,26 +335,20 @@ function convertZodEnum(def: any, options: ConversionOptions): OpenAPISchema {
 }
 
 // Convert ZodOptional
-function convertZodOptional(
-  def: any,
-  options: ConversionOptions,
-): OpenAPISchema {
+function convertZodOptional(def: any, options: ConversionOptions): OpenAPISchema {
   return convertZodType(def.innerType._def, options);
 }
 
 // Convert ZodDefault
-function convertZodDefault(
-  def: any,
-  options: ConversionOptions,
-): OpenAPISchema {
+function convertZodDefault(def: any, options: ConversionOptions): OpenAPISchema {
   const schema = convertZodType(def.innerType._def, options);
 
   // Handle both function and property forms of defaultValue
-  if (typeof def.defaultValue === "function") {
+  if (typeof def.defaultValue === 'function') {
     try {
       schema.default = def.defaultValue();
     } catch (error) {
-      logger.warn("Failed to get default value from function", "Conversion", {
+      logger.warn('Failed to get default value from function', 'Conversion', {
         error,
       });
       schema.default = undefined;
@@ -382,7 +356,7 @@ function convertZodDefault(
   } else if (def.defaultValue !== undefined) {
     schema.default = def.defaultValue;
   } else {
-    logger.warn("No default value found in ZodDefault", "Conversion");
+    logger.warn('No default value found in ZodDefault', 'Conversion');
     schema.default = undefined;
   }
 
@@ -391,9 +365,7 @@ function convertZodDefault(
 
 // Convert ZodUnion
 function convertZodUnion(def: any, options: ConversionOptions): OpenAPISchema {
-  const schemas = def.options.map((option: ZodType) =>
-    convertZodType(option._def, options),
-  );
+  const schemas = def.options.map((option: ZodType) => convertZodType(option._def, options));
 
   return {
     oneOf: schemas,
@@ -401,10 +373,7 @@ function convertZodUnion(def: any, options: ConversionOptions): OpenAPISchema {
 }
 
 // Convert ZodLiteral
-function convertZodLiteral(
-  def: any,
-  options: ConversionOptions,
-): OpenAPISchema {
+function convertZodLiteral(def: any, options: ConversionOptions): OpenAPISchema {
   const value = def.value;
 
   return {
@@ -416,11 +385,11 @@ function convertZodLiteral(
 
 // Helper functions
 function isOptionalType(type: ZodType): boolean {
-  return (type._def as any).typeName === "ZodOptional";
+  return (type._def as any).typeName === 'ZodOptional';
 }
 
 function hasDefault(type: ZodType): boolean {
-  return (type._def as any).typeName === "ZodDefault";
+  return (type._def as any).typeName === 'ZodDefault';
 }
 
 // Generate example data from Zod schema
@@ -428,7 +397,7 @@ export function generateExampleFromSchema(schema: ZodSchema): any {
   try {
     return generateExample(schema._def);
   } catch (error) {
-    logger.warn("Failed to generate example from schema", "ExampleGeneration", {
+    logger.warn('Failed to generate example from schema', 'ExampleGeneration', {
       error: error instanceof Error ? error.message : String(error),
     });
     return {};
@@ -439,32 +408,31 @@ function generateExample(def: any): any {
   const typeName = def.typeName;
 
   switch (typeName) {
-    case "ZodString":
+    case 'ZodString':
       if (def.checks) {
         for (const check of def.checks) {
-          if (check.kind === "email") return "user@example.com";
-          if (check.kind === "uuid")
-            return "123e4567-e89b-12d3-a456-426614174000";
-          if (check.kind === "url") return "https://example.com";
-          if (check.kind === "datetime") return "2023-12-01T10:00:00Z";
+          if (check.kind === 'email') return 'user@example.com';
+          if (check.kind === 'uuid') return '123e4567-e89b-12d3-a456-426614174000';
+          if (check.kind === 'url') return 'https://example.com';
+          if (check.kind === 'datetime') return '2023-12-01T10:00:00Z';
         }
       }
-      return "string";
+      return 'string';
 
-    case "ZodNumber":
+    case 'ZodNumber':
       return 42;
 
-    case "ZodBoolean":
+    case 'ZodBoolean':
       return true;
 
-    case "ZodObject": {
+    case 'ZodObject': {
       const example: any = {};
       let shape;
 
       try {
-        if (typeof def.shape === "function") {
+        if (typeof def.shape === 'function') {
           shape = def.shape();
-        } else if (def.shape && typeof def.shape === "object") {
+        } else if (def.shape && typeof def.shape === 'object') {
           shape = def.shape;
         } else {
           return {};
@@ -477,7 +445,7 @@ function generateExample(def: any): any {
           }
         }
       } catch (error) {
-        logger.warn("Failed to generate object example", "ExampleGeneration", {
+        logger.warn('Failed to generate object example', 'ExampleGeneration', {
           error,
         });
         return {};
@@ -486,31 +454,31 @@ function generateExample(def: any): any {
       return example;
     }
 
-    case "ZodArray":
+    case 'ZodArray':
       if (def.type && def.type._def) {
         const itemExample = generateExample(def.type._def);
         return [itemExample];
       }
-      return ["item"];
+      return ['item'];
 
-    case "ZodEnum":
+    case 'ZodEnum':
       return def.values && Array.isArray(def.values) && def.values.length > 0
         ? def.values[0]
-        : "enum-value";
+        : 'enum-value';
 
-    case "ZodOptional":
+    case 'ZodOptional':
       return generateExample(def.innerType._def);
 
-    case "ZodDefault":
+    case 'ZodDefault':
       // Handle both function and property forms of defaultValue
-      if (typeof def.defaultValue === "function") {
+      if (typeof def.defaultValue === 'function') {
         try {
           return def.defaultValue();
         } catch (error) {
           logger.warn(
-            "Failed to get default value from function in example generation",
-            "ExampleGeneration",
-            { error },
+            'Failed to get default value from function in example generation',
+            'ExampleGeneration',
+            { error }
           );
           return null;
         }
@@ -520,10 +488,10 @@ function generateExample(def: any): any {
         return null;
       }
 
-    case "ZodUnion":
+    case 'ZodUnion':
       return generateExample(def.options[0]._def);
 
-    case "ZodLiteral":
+    case 'ZodLiteral':
       return def.value;
 
     default: