api-core-lib 12.0.67 → 12.0.69

package/dist/cli.cjs

@@ -74,19 +74,17 @@ 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);
-var import_json_schema_to_typescript = require("json-schema-to-typescript");
 var DEBUG_MODE = process.env.DEBUG === "true";
-var debugLog = (title, data) => {
-  if (DEBUG_MODE) {
-    console.log(import_chalk.default.yellow(`
-[DEBUG: ${title}]`));
-    console.log(import_util.default.inspect(data, { depth: null, colors: true }));
-  }
-};
+var debugLog = (title, data) => DEBUG_MODE && console.log(import_chalk.default.yellow(`
+[DEBUG: ${title}]`), import_util.default.inspect(data, { depth, 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 getModuleNameFromOpId = (opId) => `${opId.split("_")[0].replace(/Controller$/, "")}Api`;
-var getActionNameFromOpId = (opId) => (opId.split("_")[1] || opId).replace(/^\w/, (c) => c.toLowerCase());
-var findCommonBasePath = (paths) => {
+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 findCommonPath = (paths) => {
   if (!paths || paths.length === 0) return "/";
   const sorted = [...paths].sort();
   const first = sorted[0];
@@ -96,15 +94,52 @@ var findCommonBasePath = (paths) => {
   const prefix = first.substring(0, i);
   return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
 };
+var generateFriendlyMessage = (fieldName, validation) => {
+  const friendlyName = fieldName.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase());
+  return `${friendlyName} is required.`;
+};
+function parseSchema(name, schema, allEnums) {
+  const properties = [];
+  const enums = {};
+  if (schema.properties) {
+    for (const propName in schema.properties) {
+      const propSchema = schema.properties[propName];
+      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,
+        type: propSchema.type || "object",
+        isRequired: (schema.required || []).includes(propName),
+        isNullable: propSchema.nullable || false,
+        description: propSchema.description,
+        example: propSchema.example,
+        enum: propSchema.enum,
+        format: propSchema.format,
+        items: propSchema.type === "array" && propSchema.items ? parseSchema(`${name}${toPascalCase(propName)}Item`, propSchema.items, allEnums).properties[0] : void 0,
+        properties: propSchema.properties ? parseSchema(`${name}${toPascalCase(propName)}`, propSchema, allEnums).properties : void 0
+      });
+    }
+  }
+  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();
-  if (spec.components?.schemas) {
-    for (const schemaName in spec.components.schemas) {
-      allSchemas.set(schemaName, { name: schemaName, schema: spec.components.schemas[schemaName] });
+  const registerSchema = (schema, baseName) => {
+    if (!schema) return "unknown";
+    if (schema.type === "array" && schema.items) return `${registerSchema(schema.items, `${baseName}Item`)}[]`;
+    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, allEnums));
+      return typeName;
     }
-  }
+    return schema.type === "integer" ? "number" : schema.type || "unknown";
+  };
   for (const apiPath in spec.paths) {
     const pathItem = spec.paths[apiPath];
     if (!pathItem) continue;
@@ -112,100 +147,59 @@ function parseSpecToModules(spec) {
       if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
       const endpoint = pathItem[method];
       if (!endpoint.operationId) continue;
-      const moduleName = getModuleNameFromOpId(endpoint.operationId);
+      const moduleName = getModuleName(endpoint.operationId);
       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);
       modulePaths.get(moduleName).push(apiPath);
-      const { inputType, outputType } = _extractAndRegisterTypes(endpoint, allSchemas);
+      const successKey = Object.keys(endpoint.responses).find((c) => c.startsWith("2"));
+      const successRes = successKey ? endpoint.responses[successKey] : void 0;
+      const outputType = successKey === "204" ? "void" : registerSchema(successRes?.content?.["application/json"]?.schema, `${endpoint.operationId}Response`);
+      const reqBody = endpoint.requestBody;
+      let inputType = "undefined";
+      if (reqBody?.content?.["application/json"]?.schema) inputType = registerSchema(reqBody.content["application/json"].schema, `${endpoint.operationId}Request`);
+      else if ((endpoint.parameters || []).some((p) => p.in === "query")) inputType = "QueryOptions";
       [inputType, outputType].forEach((t) => {
         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 = getActionNameFromOpId(endpoint.operationId);
-      currentModule.actions[actionName] = {
-        method: method.toUpperCase(),
-        path: apiPath,
-        description: endpoint.summary || "",
-        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
-        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
-        requiresAuth: !!endpoint.security && endpoint.security.length > 0,
-        _inputType: inputType,
-        _outputType: outputType
-      };
-      debugLog("Parsed Action", { moduleName, actionName, ...currentModule.actions[actionName] });
+      currentModule.actions[getActionName(endpoint.operationId)] = { name: getActionName(endpoint.operationId), method: method.toUpperCase(), path: apiPath, description: endpoint.summary || "", hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"), autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"), requiresAuth: !!endpoint.security && endpoint.security.length > 0, inputType, outputType };
     }
   }
   modules.forEach((mod, name) => {
-    const basePath = findCommonBasePath(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(/^\//, "") || "/");
   });
-  return { modules, allSchemas };
-}
-function _extractAndRegisterTypes(endpoint, allSchemas) {
-  const opId = endpoint.operationId || "Unnamed";
-  const successKey = Object.keys(endpoint.responses).find((c) => c.startsWith("2"));
-  const successRes = successKey ? endpoint.responses[successKey] : void 0;
-  const resSchema = successRes?.content?.["application/json"]?.schema;
-  const outputType = successKey === "204" ? "void" : _schemaToTypeName(resSchema, `${opId}Response`, allSchemas);
-  const reqBody = endpoint.requestBody;
-  const reqSchema = reqBody?.content?.["application/json"]?.schema;
-  let inputType = "undefined";
-  if (reqSchema) {
-    inputType = _schemaToTypeName(reqSchema, `${opId}Request`, allSchemas);
-  } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
-    inputType = "QueryOptions";
-  }
-  return { inputType, outputType };
+  debugLog("Final Parsed Modules", Object.fromEntries(modules));
+  return { modules, allSchemas, allEnums };
 }
-function _schemaToTypeName(schema, name, allSchemas) {
-  if (!schema) return "unknown";
-  if (schema.type === "array" && schema.items) {
-    const itemTypeName = _schemaToTypeName(schema.items, `${name}Item`, allSchemas);
-    return `${itemTypeName}[]`;
-  }
-  if (schema.type === "object" || schema.properties || schema.allOf || !schema.type) {
-    const typeName = toPascalCase(name);
-    if (!allSchemas.has(typeName)) {
-      debugLog("Registering new inline schema", { assignedName: typeName, originalSchema: schema });
-      allSchemas.set(typeName, { name: typeName, schema });
-    }
-    return typeName;
-  }
-  if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
-    return schema.type === "integer" ? "number" : schema.type;
-  }
-  return "unknown";
-}
-async function generateModuleFiles(module2, allSchemas, outputDir) {
-  const moduleName = module2.moduleName;
-  const moduleOutputPath = import_path.default.join(outputDir, moduleName);
+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(moduleName)}`));
-  const typesToImport = [...module2.schemas].sort();
+  Generating module: ${import_chalk.default.bold(module2.moduleName)}`));
+  const schemasToImport = [...module2.schemas].sort();
+  const enumsToImport = [...module2.enums].sort();
   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) => `  ${getActionNameFromOpId(a.path)}: ActionConfigModule<${a._inputType}, ${a._outputType}>;`).join("\n");
+  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) => {
-    const { _inputType, _outputType, ...config } = a;
-    return `    ${getActionNameFromOpId(a.path)}: ${JSON.stringify(config, null, 2).replace(/\n/g, "\n    ")}`;
+    const { inputType, outputType, name, ...c } = a;
+    return `    ${name}: ${JSON.stringify(c, null, 2).replace(/\n/g, "\n    ")}`;
   }).join(",\n");
   configContent += `
-export const ${moduleName}Module: ApiModuleConfig<{
+export const ${module2.moduleName}Module: ApiModuleConfig<{
 ${actionsType}
 }> = {
   baseEndpoint: '${module2.baseEndpoint}',
@@ -214,154 +208,187 @@ ${actionsValue}
   },
 };
 `;
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim(), { encoding: "utf-8" });
+  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "config.ts"), configContent.trim());
   console.log(import_chalk.default.gray(`    \u2713 config.ts`));
-  if (typesToImport.length === 0) return;
-  let typesContent = `// This file is auto-generated.
+  const indexContent = [`// This file is auto-generated.
+
+export * from './config';`];
+  if (schemasToImport.length > 0) {
+    if (enumsToImport.length > 0) {
+      let enumsContent = `// This file is auto-generated.
 
 `;
-  const tsOptions = { bannerComment: "", style: { bracketSpacing: true, printWidth: 120, semi: true, singleQuote: true, tabWidth: 2 }, additionalProperties: false };
-  for (const typeName of typesToImport) {
-    const parsedSchema = allSchemas.get(typeName);
-    if (parsedSchema) {
-      try {
-        const tsType = await (0, import_json_schema_to_typescript.compile)(parsedSchema.schema, typeName, tsOptions);
-        typesContent += tsType + "\n";
-      } catch (e) {
-        console.error(import_chalk.default.red(`    - Error compiling type "${typeName}": ${e.message}`));
+      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';`);
     }
-  }
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent, { encoding: "utf-8" });
-  console.log(import_chalk.default.gray(`    \u2713 types.ts`));
-  let validationContent = `// This file is auto-generated.
-import { z } from 'zod';
+    let typesContent = `// This file is auto-generated.
 
 `;
-  for (const typeName of typesToImport) {
-    const parsedSchema = allSchemas.get(typeName);
-    if (parsedSchema?.schema.type === "object") {
-      validationContent += `export const ${typeName}Schema = ${_schemaToZod(parsedSchema.schema)};
+    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 += `/**
+ * ${parsedSchema.description}
+ */
+`;
+        typesContent += `export interface ${typeName} {
+`;
+        for (const prop of parsedSchema.properties) {
+          if (prop.description) typesContent += `  /**
+   * ${prop.description}
+${prop.example ? `   * @example ${JSON.stringify(prop.example)}
+` : ""}   */
+`;
+          let propType = prop.type;
+          if (prop.enum) propType = `${toPascalCase(typeName)}${toPascalCase(prop.name)}Enum`;
+          else if (prop.items) propType = prop.items.properties ? `${toPascalCase(`${typeName}${toPascalCase(prop.name)}Item`)}[]` : `${prop.items.type}[]`;
+          else if (prop.properties) propType = `Record<string, unknown>`;
+          typesContent += `  ${prop.name}${prop.isRequired ? "" : "?"}: ${propType};
+`;
+        }
+        typesContent += `}
+
+`;
+      }
     }
-  }
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent, { encoding: "utf-8" });
-  console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
-  let mocksContent = `// This file is auto-generated.
-import type { ${typesToImport.join(", ")} } from './types';
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "types.ts"), typesContent);
+    console.log(import_chalk.default.gray(`    \u2713 types.ts`));
+    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) {
-    const parsedSchema = allSchemas.get(typeName);
-    if (parsedSchema) {
-      mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(_schemaToMock(parsedSchema.schema), null, 2)};
+    for (const typeName of schemasToImport) {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        let zodShape = parsedSchema.properties.map((p) => `  ${p.name}: ${_propToZod(p, typeName)}`).join(",\n");
+        validationContent += `export const ${typeName}Schema = z.object({
+${zodShape}
+});
 
 `;
+      }
     }
-  }
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent, { encoding: "utf-8" });
-  console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
-  let indexContent = `// This file is auto-generated.
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "validation.ts"), validationContent);
+    console.log(import_chalk.default.gray(`    \u2713 validation.ts`));
+    indexContent.push(`export * from './validation';`);
+    let mocksContent = `// This file is auto-generated.
+import type { ${schemasToImport.join(", ")} } from './types';
+`;
+    if (enumsToImport.length > 0) mocksContent += `import { ${enumsToImport.map((e) => e.replace(/Enum$/, "")).join(", ")} } from './enums';
 
-export * from './config';
-export * from './types';
-export * from './validation';
-export * from './mocks';
 `;
-  import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "index.ts"), indexContent, { encoding: "utf-8" });
-  console.log(import_chalk.default.gray(`    \u2713 index.ts`));
-}
-function _schemaToZod(schema) {
-  const shape = [];
-  if (schema.properties) {
-    for (const [key, prop] of Object.entries(schema.properties)) {
-      shape.push(`  ${key}: ${_propToZod(prop, (schema.required || []).includes(key))}`);
+    for (const typeName of schemasToImport) {
+      const parsedSchema = allSchemas.get(typeName);
+      if (parsedSchema) {
+        let mockObject = {};
+        parsedSchema.properties.forEach((p) => {
+          mockObject[p.name] = _propToMock(p);
+        });
+        mocksContent += `export const mock${typeName}: ${typeName} = ${JSON.stringify(mockObject, null, 2)};
+
+`;
+      }
     }
+    import_fs.default.writeFileSync(import_path.default.join(moduleOutputPath, "mocks.ts"), mocksContent);
+    console.log(import_chalk.default.gray(`    \u2713 mocks.ts`));
+    indexContent.push(`export * from './mocks';`);
   }
-  return `z.object({
-${shape.join(",\n")}
-})`;
+  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, isRequired) {
+function _propToZod(prop, parentName) {
   let zodString = "z.any()";
+  const errorMapParams = { errorMap: () => ({ message: prop.description || generateFriendlyMessage(prop.name, "required") }) };
   switch (prop.type) {
     case "string":
-      zodString = "z.string()";
-      if (prop.format === "email") zodString += ".email()";
-      if (prop.format === "uuid") zodString += ".uuid()";
-      if (prop.enum) zodString = `z.enum(${JSON.stringify(prop.enum)})`;
+      zodString = `z.string(${JSON.stringify(errorMapParams)})`;
+      if (prop.format === "email") zodString += `.email({ message: "${generateFriendlyMessage(prop.name, "email")}" })`;
+      if (prop.format === "uuid") zodString += `.uuid()`;
+      if (prop.enum) zodString = `z.enum(${toPascalCase(parentName)}${toPascalCase(prop.name)}Enum)`;
       break;
     case "integer":
     case "number":
-      zodString = "z.number()";
-      if (prop.minimum !== void 0) zodString += `.min(${prop.minimum})`;
-      if (prop.maximum !== void 0) zodString += `.max(${prop.maximum})`;
+      zodString = `z.number(${JSON.stringify(errorMapParams)})`;
       break;
     case "boolean":
-      zodString = "z.boolean()";
+      zodString = `z.boolean(${JSON.stringify(errorMapParams)})`;
       break;
     case "array":
-      zodString = `z.array(${prop.items ? _propToZod(prop.items, true) : "z.any()"})`;
+      zodString = `z.array(${prop.items ? _propToZod(prop.items, `${parentName}${toPascalCase(prop.name)}Item`) : "z.any()"})`;
       break;
     case "object":
-      zodString = _schemaToZod(prop);
+      let shape = "z.record(z.unknown())";
+      if (prop.properties) shape = `z.object({
+${prop.properties.map((p) => `    ${p.name}: ${_propToZod(p, `${parentName}${toPascalCase(prop.name)}`)}`).join(",\n")}
+  })`;
+      zodString = shape;
       break;
   }
-  return isRequired ? zodString : `${zodString}.optional().nullable()`;
+  if (!prop.isRequired) zodString += ".optional()";
+  if (prop.isNullable) zodString += ".nullable()";
+  return zodString;
 }
-function _schemaToMock(schema) {
-  if (schema.example) return schema.example;
-  switch (schema.type) {
+function _propToMock(prop) {
+  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 (schema.format === "email") return "test@example.com";
-      if (schema.format === "uuid") return "a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11";
-      if (schema.enum) return schema.enum[0];
-      return "Mock String";
+      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":
       return 1;
     case "boolean":
       return true;
     case "array":
-      return schema.items ? [_schemaToMock(schema.items)] : [];
+      return prop.items ? [_propToMock(prop.items)] : [];
     case "object":
       const mock = {};
-      if (schema.properties) {
-        for (const [key, prop] of Object.entries(schema.properties)) {
-          mock[key] = _schemaToMock(prop);
-        }
-      }
+      if (prop.properties) prop.properties.forEach((p) => {
+        mock[p.name] = _propToMock(p);
+      });
       return mock;
     default:
       return null;
   }
 }
-async function runGenerator() {
-  const options = {
-    output: "src/lib/api",
-    envPath: ".env"
-  };
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator..."));
+async function runGenerator(options) {
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Development Platform Generator (Diamond Edition)..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
-  console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
     console.log(import_chalk.default.blue(`
-\u23F3 Step 2: Fetching and fully dereferencing spec from ${specUrl}...`));
+\u23F3 Step 1: Dereferencing spec from ${specUrl}...`));
     const spec = await import_swagger_parser.default.dereference(specUrl);
-    console.log(import_chalk.default.green("\u2713 Spec fetched and fully dereferenced successfully."));
-    debugLog("Dereferenced Spec", spec);
-    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Parsing spec using intelligent grouping..."));
-    const { modules, allSchemas } = parseSpecToModules(spec);
+    console.log(import_chalk.default.green("\u2713 Spec fully dereferenced."));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 2: Parsing spec with intelligent grouping..."));
+    const { modules, allSchemas, allEnums } = parseSpecToModules(spec);
     console.log(import_chalk.default.green(`\u2713 Found and grouped ${modules.size} logical modules.`));
-    debugLog("Parsed Modules", Object.fromEntries(modules));
-    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Generating all module files..."));
+    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!"));
+    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete! Your development platform is ready."));
     console.log(import_chalk.default.bold.cyan(`   Output directory: ${options.output}`));
   } catch (error) {
     console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));

package/package.json

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