api-core-lib 12.0.72 → 12.0.74

package/dist/cli.cjs

@@ -74,16 +74,142 @@ var import_chalk = __toESM(require("chalk"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
 var import_swagger_parser = __toESM(require("@apidevtools/swagger-parser"), 1);
 var import_openapi_types = __toESM(require_dist(), 1);
+
+// src/generator/core/_propToZod.ts
+function _propToZod(prop) {
+  const getMessages = (keys, customErrorMessages) => {
+    const messages = {};
+    const keyMap = {
+      required: "required_error",
+      invalid_type: "invalid_type_error"
+    };
+    for (const key of keys) {
+      const zodKey = keyMap[key] || "message";
+      const customMessage = customErrorMessages?.[key];
+      messages[zodKey] = customMessage || `validation.${key}`;
+    }
+    return messages;
+  };
+  let zodChain;
+  switch (prop.type) {
+    case "string": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.string(${JSON.stringify(messages)})`;
+      if (prop.enum && prop.enum.length > 0) {
+        zodChain = `z.enum(${JSON.stringify(prop.enum)}, ${JSON.stringify(messages)})`;
+      } else {
+        if (prop.minLength !== void 0) {
+          const msg = { message: prop.errorMessages?.minLength || "validation.string.min" };
+          zodChain += `.min(${prop.minLength}, ${JSON.stringify(msg)})`;
+        } else if (prop.isRequired) {
+          const msg = { message: prop.errorMessages?.minLength || "validation.string.nonempty" };
+          zodChain += `.min(1, ${JSON.stringify(msg)})`;
+        }
+        if (prop.maxLength !== void 0) {
+          const msg = { message: prop.errorMessages?.maxLength || "validation.string.max" };
+          zodChain += `.max(${prop.maxLength}, ${JSON.stringify(msg)})`;
+        }
+        if (prop.pattern) {
+          const msg = { message: prop.errorMessages?.pattern || "validation.string.regex" };
+          zodChain += `.regex(/${prop.pattern}/, ${JSON.stringify(msg)})`;
+        }
+        if (prop.format) {
+          const msg = { message: prop.errorMessages?.format || `validation.string.${prop.format}` };
+          if (prop.format === "email") zodChain += `.email(${JSON.stringify(msg)})`;
+          if (prop.format === "url") zodChain += `.url(${JSON.stringify(msg)})`;
+          if (prop.format === "uuid") zodChain += `.uuid(${JSON.stringify(msg)})`;
+          if (prop.format === "datetime") zodChain += `.datetime(${JSON.stringify(msg)})`;
+        }
+      }
+      break;
+    }
+    case "integer": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      const intMessage = { message: prop.errorMessages?.integer || "validation.number.integer" };
+      zodChain = `z.number(${JSON.stringify(messages)}).int(${JSON.stringify(intMessage)})`;
+      if (prop.minimum !== void 0) {
+        const msg = { message: prop.errorMessages?.minimum || "validation.number.min" };
+        zodChain += `.min(${prop.minimum}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maximum !== void 0) {
+        const msg = { message: prop.errorMessages?.maximum || "validation.number.max" };
+        zodChain += `.max(${prop.maximum}, ${JSON.stringify(msg)})`;
+      }
+      break;
+    }
+    case "number": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.number(${JSON.stringify(messages)})`;
+      if (prop.minimum !== void 0) {
+        const msg = { message: prop.errorMessages?.minimum || "validation.number.min" };
+        zodChain += `.min(${prop.minimum}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maximum !== void 0) {
+        const msg = { message: prop.errorMessages?.maximum || "validation.number.max" };
+        zodChain += `.max(${prop.maximum}, ${JSON.stringify(msg)})`;
+      }
+      break;
+    }
+    case "boolean": {
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.boolean(${JSON.stringify(messages)})`;
+      break;
+    }
+    case "array": {
+      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
+      const messages = getMessages(["required", "invalid_type"], prop.errorMessages);
+      zodChain = `z.array(${itemSchema}, ${JSON.stringify(messages)})`;
+      if (prop.minItems !== void 0) {
+        const msg = { message: prop.errorMessages?.minItems || "validation.array.min" };
+        zodChain += `.min(${prop.minItems}, ${JSON.stringify(msg)})`;
+      }
+      if (prop.maxItems !== void 0) {
+        const msg = { message: prop.errorMessages?.maxItems || "validation.array.max" };
+        zodChain += `.max(${prop.maxItems}, ${JSON.stringify(msg)})`;
+      }
+      break;
+    }
+    case "object": {
+      if (prop.properties && prop.properties.length > 0) {
+        const shape = prop.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
+        zodChain = `z.object({
+${shape}
+})`;
+      } else {
+        zodChain = "z.record(z.unknown())";
+      }
+      break;
+    }
+    default:
+      zodChain = "z.any()";
+      break;
+  }
+  if (prop.description) {
+    zodChain += `.describe(${JSON.stringify(prop.description)})`;
+  }
+  if (!prop.isRequired) {
+    zodChain += ".optional()";
+  }
+  if (prop.isNullable) {
+    zodChain += ".nullable()";
+  }
+  if (prop.defaultValue !== void 0) {
+    zodChain += `.default(${JSON.stringify(prop.defaultValue)})`;
+  }
+  return zodChain;
+}
+
+// src/generator/index.ts
 var DEBUG_MODE = process.env.DEBUG === "true";
 var debugLog = (title, data) => DEBUG_MODE && console.log(import_chalk.default.yellow(`
-[DEBUG: ${title}]`), import_util.default.inspect(data, { depth: 4, colors: true }));
+[DEBUG: ${title}]`), import_util.default.inspect(data, { depth: 5, colors: true }));
 var toPascalCase = (str) => str.replace(/[^a-zA-Z0-9_]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
 var toCamelCase = (str) => {
   const s = toPascalCase(str);
   return s.charAt(0).toLowerCase() + s.slice(1);
 };
-var getModuleName = (opId) => `${opId.split("_")[0].replace(/Controller$/, "")}Api`;
-var getActionName = (opId) => toCamelCase(opId.split("_")[1] || opId);
+var sanitizeForModuleName = (tagName) => `${toPascalCase(tagName.replace(/[^a-zA-Z0-9]/g, " "))}Api`;
+var getActionName = (opId) => toCamelCase(opId.replace(/^(central|tenant)/i, "").replace(/_v\d+$/, ""));
 var findCommonPath = (paths) => {
   if (!paths || paths.length === 0) return "/";
   const sorted = [...paths].sort();
@@ -94,14 +220,21 @@ var findCommonPath = (paths) => {
   const prefix = first.substring(0, i);
   return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
 };
-function parseSchema(name, schema) {
+function parseSchema(name, schema, allEnums) {
   const properties = [];
+  const enums = {};
   if (schema.properties) {
     for (const propName in schema.properties) {
       const propSchema = schema.properties[propName];
-      let items = void 0;
+      let itemSchema;
       if (propSchema.type === "array" && propSchema.items) {
-        items = parseSchema("item", propSchema.items).properties[0];
+        const itemTypeName = `${toPascalCase(name)}${toPascalCase(propName)}Item`;
+        itemSchema = parseSchema(itemTypeName, propSchema.items, allEnums).properties[0];
+      }
+      if (propSchema.enum) {
+        const enumName = `${toPascalCase(name)}${toPascalCase(propName)}Enum`;
+        enums[propName] = propSchema.enum;
+        if (!allEnums.has(enumName)) allEnums.set(enumName, { name: enumName, values: propSchema.enum });
       }
       properties.push({
         name: propName,
@@ -112,24 +245,29 @@ function parseSchema(name, schema) {
         example: propSchema.example,
         enum: propSchema.enum,
         format: propSchema.format,
-        items,
-        // نستخدم المتغير الذي تم حسابه بأمان
-        properties: propSchema.properties ? parseSchema("sub-object", propSchema).properties : void 0
+        items: itemSchema,
+        properties: propSchema.properties ? parseSchema(`${name}${toPascalCase(propName)}`, propSchema, allEnums).properties : void 0
       });
     }
   }
-  return { name, description: schema.description, properties };
+  return { name, description: schema.description, properties, enums };
 }
 function parseSpecToModules(spec) {
   const modules = /* @__PURE__ */ new Map();
   const allSchemas = /* @__PURE__ */ new Map();
+  const allEnums = /* @__PURE__ */ new Map();
   const modulePaths = /* @__PURE__ */ new Map();
   const registerSchema = (schema, baseName) => {
     if (!schema) return "unknown";
-    if (schema.type === "array" && schema.items) return `${registerSchema(schema.items, `${baseName}Item`)}[]`;
+    if (schema.type === "array" && schema.items) {
+      const itemSchema = schema.items;
+      const itemBaseName = `${baseName}Item`;
+      if (itemSchema.properties || itemSchema.type === "object") return `${registerSchema(itemSchema, itemBaseName)}[]`;
+      return `${itemSchema.type || "unknown"}[]`;
+    }
     if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
       const typeName = toPascalCase(baseName.replace(/_v\d+(Request|Response)$/, "$1"));
-      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema));
+      if (!allSchemas.has(typeName)) allSchemas.set(typeName, parseSchema(typeName, schema, allEnums));
       return typeName;
     }
     return schema.type === "integer" ? "number" : schema.type || "unknown";
@@ -140,10 +278,11 @@ function parseSpecToModules(spec) {
     for (const method in pathItem) {
       if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
       const endpoint = pathItem[method];
-      if (!endpoint.operationId) continue;
-      const moduleName = getModuleName(endpoint.operationId);
+      if (!endpoint.tags || endpoint.tags.length === 0 || !endpoint.operationId) continue;
+      const tagName = endpoint.tags[0];
+      const moduleName = sanitizeForModuleName(tagName);
       if (!modules.has(moduleName)) {
-        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set() });
+        modules.set(moduleName, { moduleName, baseEndpoint: "", actions: {}, schemas: /* @__PURE__ */ new Set(), enums: /* @__PURE__ */ new Set() });
         modulePaths.set(moduleName, []);
       }
       const currentModule = modules.get(moduleName);
@@ -159,6 +298,8 @@ function parseSpecToModules(spec) {
         const cleanType = t.replace("[]", "");
         if (cleanType && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(cleanType)) {
           currentModule.schemas.add(cleanType);
+          const schemaDef = allSchemas.get(cleanType);
+          if (schemaDef) Object.keys(schemaDef.enums).forEach((propName) => currentModule.enums.add(`${toPascalCase(cleanType)}${toPascalCase(propName)}Enum`));
         }
       });
       const actionName = getActionName(endpoint.operationId);
@@ -166,28 +307,28 @@ function parseSpecToModules(spec) {
     }
   }
   modules.forEach((mod, name) => {
-    const basePath = findCommonPath(modulePaths.get(name));
-    mod.baseEndpoint = basePath;
-    Object.values(mod.actions).forEach((action) => {
-      const relativePath = action.path.replace(basePath, "").replace(/^\//, "");
-      action.path = relativePath === "" ? "/" : relativePath;
-    });
+    mod.baseEndpoint = findCommonPath(modulePaths.get(name));
+    Object.values(mod.actions).forEach((action) => action.path = action.path.replace(mod.baseEndpoint, "").replace(/^\//, "") || "/");
   });
   debugLog("Final Parsed Modules", Object.fromEntries(modules));
-  return { modules, allSchemas };
+  return { modules, allSchemas, allEnums };
 }
-async function generateModuleFiles(module2, allSchemas, outputDir) {
+async function generateModuleFiles(module2, allSchemas, allEnums, outputDir) {
   const moduleOutputPath = import_path.default.join(outputDir, module2.moduleName);
   if (!import_fs.default.existsSync(moduleOutputPath)) import_fs.default.mkdirSync(moduleOutputPath, { recursive: true });
   console.log(import_chalk.default.cyan(`
   Generating module: ${import_chalk.default.bold(module2.moduleName)}`));
-  const typesToImport = [...module2.schemas].sort();
+  const schemasToImport = [...module2.schemas].sort();
+  const enumsToImport = [...module2.enums].sort();
+  const indexContent = [`// This file is auto-generated.
+
+export * from './config';`];
   let configContent = `/* eslint-disable */
 // This file is auto-generated.
 
 import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
 `;
-  if (typesToImport.length > 0) configContent += `import type { ${typesToImport.join(", ")} } from './types';
+  if (schemasToImport.length > 0) configContent += `import type { ${schemasToImport.join(", ")} } from './types';
 `;
   const actionsType = Object.values(module2.actions).map((a) => `  ${a.name}: ActionConfigModule<${a.inputType}, ${a.outputType}>;`).join("\n");
   const actionsValue = Object.values(module2.actions).map((a) => {
@@ -206,14 +347,32 @@ ${actionsValue}
 `;
   import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim());
   console.log(import_chalk.default.gray(`    \u2713 config.ts`));
-  const indexContent = [`// This file is auto-generated.
+  if (schemasToImport.length > 0) {
+    if (enumsToImport.length > 0) {
+      let enumsContent = `// This file is auto-generated.
 
-export * from './config';`];
-  if (typesToImport.length > 0) {
+`;
+      for (const enumName of enumsToImport) {
+        const enumDef = allEnums.get(enumName);
+        if (enumDef) {
+          enumsContent += `export const ${enumName} = ${JSON.stringify(enumDef.values)} as const;
+`;
+          enumsContent += `export type ${enumName} = typeof ${enumName}[number];
+
+`;
+        }
+      }
+      import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "enums.ts"), enumsContent);
+      console.log(import_chalk.default.gray(`    \u2713 enums.ts`));
+      indexContent.push(`export * from './enums';`);
+    }
     let typesContent = `// This file is auto-generated.
 
 `;
-    for (const typeName of typesToImport) {
+    if (enumsToImport.length > 0) typesContent += `import type { ${enumsToImport.join(", ")} } from './enums';
+
+`;
+    for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         if (parsedSchema.description) typesContent += `/**
@@ -228,7 +387,10 @@ export * from './config';`];
 ${prop.example ? `   * @example ${JSON.stringify(prop.example)}
 ` : ""}   */
 `;
-          const propType = prop.enum ? prop.enum.map((e) => typeof e === "string" ? `'${e}'` : e).join(" | ") : prop.items ? `${toPascalCase(prop.items.name)}[]` : prop.type;
+          let propType = prop.type;
+          if (prop.enum) propType = `${toPascalCase(typeName)}${toPascalCase(prop.name)}Enum`;
+          else if (prop.items) propType = prop.items.name ? `${toPascalCase(prop.items.name)}[]` : `${prop.items.type || "unknown"}[]`;
+          else if (prop.type === "object") propType = prop.properties && prop.properties.length > 0 ? `Record<string, unknown>` : `Record<string, unknown>`;
           typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
 `;
         }
@@ -242,9 +404,11 @@ ${prop.example ? `   * @example ${JSON.stringify(prop.example)}
     indexContent.push(`export * from './types';`);
     let validationContent = `// This file is auto-generated.
 import { z } from 'zod';
+`;
+    if (enumsToImport.length > 0) validationContent += `import { ${enumsToImport.join(", ")} } from './enums';
 
 `;
-    for (const typeName of typesToImport) {
+    for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
@@ -259,10 +423,12 @@ ${zodShape}
     console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
     indexContent.push(`export * from './validation';`);
     let mocksContent = `// This file is auto-generated.
-import type { ${typesToImport.join(", ")} } from './types';
+import type { ${schemasToImport.join(", ")} } from './types';
+`;
+    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.join(", ")} } from './enums';
 
 `;
-    for (const typeName of typesToImport) {
+    for (const typeName of schemasToImport) {
       const parsedSchema = allSchemas.get(typeName);
       if (parsedSchema) {
         let mockObject = {};
@@ -281,144 +447,34 @@ import type { ${typesToImport.join(", ")} } from './types';
   import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent.join("\n"));
   console.log(import_chalk.default.gray(`    \u2713 index.ts`));
 }
-function _propToZod(prop) {
-  let chain;
-  const requiredErrorMessage = { required_error: `${prop.name} is required.` };
-  switch (prop.type) {
-    case "string":
-      chain = `z.string({ ...requiredErrorMessage, invalid_type_error: "Expected a string for ${prop.name}" })`;
-      if (prop.format === "email") chain += `.email({ message: "Invalid email address for ${prop.name}" })`;
-      if (prop.format === "uuid") chain += `.uuid({ message: "Invalid UUID for ${prop.name}" })`;
-      if (prop.format === "url") chain += `.url({ message: "Invalid URL for ${prop.name}" })`;
-      if (prop.format === "datetime") chain += `.datetime({ message: "Invalid datetime format for ${prop.name}" })`;
-      if (prop.minLength !== void 0) chain += `.min(${prop.minLength}, { message: "${prop.name} must be at least ${prop.minLength} characters long" })`;
-      if (prop.maxLength !== void 0) chain += `.max(${prop.maxLength}, { message: "${prop.name} must be at most ${prop.maxLength} characters long" })`;
-      if (prop.pattern) chain += `.regex(/${prop.pattern}/, { message: "Invalid format for ${prop.name}" })`;
-      if (prop.enum) {
-        if (prop.enum.length > 0) {
-          chain = `z.enum(${JSON.stringify(prop.enum)})`;
-        } else {
-          chain = `z.string().refine(() => false, { message: "Enum for ${prop.name} is empty" })`;
-        }
-      }
-      break;
-    case "integer":
-      chain = `z.number({ ...requiredErrorMessage, invalid_type_error: "Expected a number for ${prop.name}" }).int({ message: "${prop.name} must be an integer" })`;
-      if (prop.minimum !== void 0) chain += `.min(${prop.minimum}, { message: "${prop.name} must be at least ${prop.minimum}" })`;
-      if (prop.maximum !== void 0) chain += `.max(${prop.maximum}, { message: "${prop.name} must be at most ${prop.maximum}" })`;
-      break;
-    case "number":
-      chain = `z.number({ ...requiredErrorMessage, invalid_type_error: "Expected a number for ${prop.name}" })`;
-      if (prop.minimum !== void 0) chain += `.min(${prop.minimum}, { message: "${prop.name} must be at least ${prop.minimum}" })`;
-      if (prop.maximum !== void 0) chain += `.max(${prop.maximum}, { message: "${prop.name} must be at most ${prop.maximum}" })`;
-      break;
-    case "boolean":
-      chain = `z.boolean({ ...requiredErrorMessage, invalid_type_error: "Expected a boolean for ${prop.name}" })`;
-      break;
-    case "array":
-      const itemSchema = prop.items ? _propToZod(prop.items) : "z.any()";
-      chain = `z.array(${itemSchema})`;
-      if (prop.minItems !== void 0) chain += `.min(${prop.minItems}, { message: "${prop.name} must contain at least ${prop.minItems} item(s)" })`;
-      if (prop.maxItems !== void 0) chain += `.max(${prop.maxItems}, { message: "${prop.name} must contain at most ${prop.maxItems} item(s)" })`;
-      break;
-    case "object":
-      if (prop.properties && prop.properties.length > 0) {
-        const shape = prop.properties.map((p) => `  ${p.name}: ${_propToZod(p)}`).join(",\n");
-        chain = `z.object({
-${shape}
-})`;
-      } else {
-        chain = "z.record(z.unknown())";
-      }
-      break;
-    default:
-      chain = "z.any()";
-      break;
-  }
-  if (prop.description) {
-    chain += `.describe(${JSON.stringify(prop.description)})`;
-  }
-  if (!prop.isRequired) {
-    chain += ".optional()";
-  }
-  if (prop.isNullable) {
-    chain += ".nullable()";
-  }
-  return chain;
-}
-function _generateUUID() {
-  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
-    const r = Math.random() * 16 | 0;
-    const v = c === "x" ? r : r & 3 | 8;
-    return v.toString(16);
-  });
-}
-function _getRandomInt(min, max) {
-  min = Math.ceil(min);
-  max = Math.floor(max);
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-var _firstNames = ["Ahmed", "Fatima", "Mohammed", "Zainab", "Ali", "Nour"];
-var _lastNames = ["Al-Masri", "Khan", "Hassan", "Abbas", "Said"];
 function _propToMock(prop) {
-  if (prop.example !== void 0) {
-    return prop.example;
-  }
-  if (prop.enum && prop.enum.length > 0) {
-    return prop.enum[_getRandomInt(0, prop.enum.length - 1)];
-  }
+  if (prop.example) return prop.example;
+  if (prop.name.match(/image|avatar|logo|url/i)) return "https://via.placeholder.com/150";
+  if (prop.enum) return prop.enum[0];
   switch (prop.type) {
     case "string":
-      if (prop.format === "email") return `user${_getRandomInt(1, 1e3)}@example.com`;
-      if (prop.format === "uuid") return _generateUUID();
-      if (prop.format === "url") return "https://www.example.com";
-      if (prop.format === "datetime") return (/* @__PURE__ */ new Date()).toISOString();
-      const name = prop.name.toLowerCase();
-      if (name.includes("image") || name.includes("avatar") || name.includes("logo") || name.includes("picture")) return `https://via.placeholder.com/${_getRandomInt(150, 400)}`;
-      if (name.includes("firstname")) return _firstNames[_getRandomInt(0, _firstNames.length - 1)];
-      if (name.includes("lastname")) return _lastNames[_getRandomInt(0, _lastNames.length - 1)];
-      if (name.includes("name")) return `${_firstNames[_getRandomInt(0, _firstNames.length - 1)]} ${_lastNames[_getRandomInt(0, _lastNames.length - 1)]}`;
-      if (name.includes("city")) return "Riyadh";
-      if (name.includes("country")) return "Saudi Arabia";
-      if (name.includes("phone")) return `+1-${_getRandomInt(100, 999)}-${_getRandomInt(100, 999)}-${_getRandomInt(1e3, 9999)}`;
-      if (name.includes("description") || name.includes("comment")) return "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-      const minLen = prop.minLength || 8;
-      const maxLen = prop.maxLength || 16;
-      return `Mock${toPascalCase(prop.name)}`.padEnd(_getRandomInt(minLen, maxLen), "x");
+      if (prop.format === "email") return "test@example.com";
+      if (prop.format === "uuid") return "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
+      return `Mock ${toPascalCase(prop.name)}`;
     case "integer":
     case "number":
-      const min = prop.minimum === void 0 ? 1 : prop.minimum;
-      const max = prop.maximum === void 0 ? 1e3 : prop.maximum;
-      const randomNum = _getRandomInt(min, max);
-      return prop.type === "integer" ? Math.floor(randomNum) : randomNum + Math.random();
+      return 1;
     case "boolean":
-      return Math.random() > 0.5;
+      return true;
     case "array":
-      const minItems = prop.minItems || 1;
-      const maxItems = prop.maxItems || 3;
-      const count = _getRandomInt(minItems, maxItems);
-      if (!prop.items) return [];
-      const items = [];
-      for (let i = 0; i < count; i++) {
-        items.push(_propToMock(prop.items));
-      }
-      return items;
+      return prop.items ? [_propToMock(prop.items)] : [];
     case "object":
       const mock = {};
-      if (prop.properties) {
-        prop.properties.forEach((p) => {
-          if (p.isRequired || Math.random() > 0.3) {
-            mock[p.name] = _propToMock(p);
-          }
-        });
-      }
+      if (prop.properties) prop.properties.forEach((p) => {
+        mock[p.name] = _propToMock(p);
+      });
       return mock;
     default:
       return null;
   }
 }
 async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Phoenix Edition)..."));
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Sapphire Edition)..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
   try {
@@ -426,13 +482,12 @@ async function runGenerator(options) {
 \u23F3 Step 1: Dereferencing spec from ${specUrl}...`));
     const spec = await import_swagger_parser.default.dereference(specUrl);
     console.log(import_chalk.default.green("\u2713 Spec fully dereferenced."));
-    debugLog("Dereferenced Spec", spec);
     console.log(import_chalk.default.blue("\n\u23F3 Step 2: Parsing spec with intelligent grouping..."));
-    const { modules, allSchemas } = parseSpecToModules(spec);
+    const { modules, allSchemas, allEnums } = parseSpecToModules(spec);
     console.log(import_chalk.default.green(`\u2713 Found and grouped ${modules.size} logical modules.`));
     console.log(import_chalk.default.blue("\n\u23F3 Step 3: Generating all module files..."));
     for (const module2 of modules.values()) {
-      await generateModuleFiles(module2, allSchemas, options.output);
+      await generateModuleFiles(module2, allSchemas, allEnums, options.output);
     }
     console.log(import_chalk.default.green("\n\u2713 All module files generated successfully."));
     console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete! Your development platform is ready."));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.72",
+  "version": "12.0.74",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {