api-core-lib 12.0.57 → 12.0.59

package/dist/cli.cjs

@@ -6,6 +6,9 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -23,42 +26,161 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// node_modules/openapi-types/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/openapi-types/dist/index.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.OpenAPIV2 = exports2.OpenAPIV3 = void 0;
+    var OpenAPIV32;
+    (function(OpenAPIV33) {
+      var HttpMethods;
+      (function(HttpMethods2) {
+        HttpMethods2["GET"] = "get";
+        HttpMethods2["PUT"] = "put";
+        HttpMethods2["POST"] = "post";
+        HttpMethods2["DELETE"] = "delete";
+        HttpMethods2["OPTIONS"] = "options";
+        HttpMethods2["HEAD"] = "head";
+        HttpMethods2["PATCH"] = "patch";
+        HttpMethods2["TRACE"] = "trace";
+      })(HttpMethods = OpenAPIV33.HttpMethods || (OpenAPIV33.HttpMethods = {}));
+    })(OpenAPIV32 = exports2.OpenAPIV3 || (exports2.OpenAPIV3 = {}));
+    var OpenAPIV2;
+    (function(OpenAPIV22) {
+      var HttpMethods;
+      (function(HttpMethods2) {
+        HttpMethods2["GET"] = "get";
+        HttpMethods2["PUT"] = "put";
+        HttpMethods2["POST"] = "post";
+        HttpMethods2["DELETE"] = "delete";
+        HttpMethods2["OPTIONS"] = "options";
+        HttpMethods2["HEAD"] = "head";
+        HttpMethods2["PATCH"] = "patch";
+      })(HttpMethods = OpenAPIV22.HttpMethods || (OpenAPIV22.HttpMethods = {}));
+    })(OpenAPIV2 = exports2.OpenAPIV2 || (exports2.OpenAPIV2 = {}));
+  }
+});
+
 // src/cli.ts
 var import_commander = require("commander");
-var import_path3 = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
 // src/generator/index.ts
-var import_path2 = __toESM(require("path"), 1);
-var import_axios = __toESM(require("axios"), 1);
-var import_chalk2 = __toESM(require("chalk"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_chalk = __toESM(require("chalk"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
-var import_json_schema_ref_parser = __toESM(require("@apidevtools/json-schema-ref-parser"), 1);
-
-// src/generator/spec-parser.ts
+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");
+function preprocessSpec(spec) {
+  if (!spec.components) spec.components = {};
+  if (!spec.components.schemas) spec.components.schemas = {};
+  const schemas = spec.components.schemas;
+  for (const apiPath in spec.paths) {
+    const pathItem = spec.paths[apiPath];
+    if (!pathItem) continue;
+    for (const method in pathItem) {
+      if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
+      const endpoint = pathItem[method];
+      const baseName = _generateBaseNameForSchema(method, apiPath, endpoint.operationId);
+      const requestBody = endpoint.requestBody;
+      if (requestBody?.content?.["application/json"]?.schema) {
+        requestBody.content["application/json"].schema = _normalizeSchema(
+          requestBody.content["application/json"].schema,
+          schemas,
+          baseName,
+          "Request"
+        );
+      }
+      if (endpoint.responses) {
+        for (const statusCode in endpoint.responses) {
+          const response = endpoint.responses[statusCode];
+          const mediaTypeObject = response.content?.["application/json"];
+          if (mediaTypeObject?.schema) {
+            mediaTypeObject.schema = _normalizeSchema(
+              mediaTypeObject.schema,
+              // مرر المخطط الأصلي
+              schemas,
+              baseName,
+              `Response${statusCode}`
+            );
+          }
+        }
+      }
+    }
+  }
+  return spec;
+}
+function _normalizeSchema(schema, schemas, baseName, suffix) {
+  if (!schema || "$ref" in schema) {
+    return schema;
+  }
+  if (schema.type === "array" && schema.items) {
+    schema.items = _normalizeSchema(schema.items, schemas, baseName, suffix.replace("[]", "Item"));
+    return schema;
+  }
+  if (schema.type === "object" && schema.properties) {
+    const typeName = `${_toPascalCase(baseName)}${_toPascalCase(suffix)}Dto`;
+    if (!schemas[typeName]) {
+      schemas[typeName] = schema;
+      for (const propName in schema.properties) {
+        schema.properties[propName] = _normalizeSchema(
+          schema.properties[propName],
+          schemas,
+          baseName,
+          `${_toPascalCase(propName)}Property`
+        );
+      }
+    }
+    return { $ref: `#/components/schemas/${typeName}` };
+  }
+  return schema;
+}
+function _generateBaseNameForSchema(method, path3, operationId) {
+  if (operationId) return _toPascalCase(operationId.replace(/_v\d+$/, ""));
+  const pathPart = path3.replace(/[\/{}]/g, " ").trim();
+  return `${_toPascalCase(method)} ${_toPascalCase(pathPart)}`;
+}
 function parseSpecToModules(spec) {
   const modules = {};
   for (const apiPath in spec.paths) {
-    for (const method in spec.paths[apiPath]) {
-      const endpoint = spec.paths[apiPath][method];
+    const pathItem = spec.paths[apiPath];
+    if (!pathItem) continue;
+    for (const method in pathItem) {
+      if (!Object.values(import_openapi_types.OpenAPIV3.HttpMethods).includes(method)) continue;
+      const endpoint = pathItem[method];
       if (!endpoint.tags || endpoint.tags.length === 0) continue;
       const tagName = endpoint.tags[0];
-      const moduleName = sanitizeTagName(tagName) + "Api";
+      const moduleName = _sanitizeTagName(tagName) + "Api";
       if (!modules[moduleName]) {
-        const commonPath = apiPath.substring(0, apiPath.lastIndexOf("/"));
-        modules[moduleName] = { baseEndpoint: commonPath || "/", actions: {}, types: /* @__PURE__ */ new Set() };
+        modules[moduleName] = { baseEndpoint: _findCommonBasePath(spec, tagName), actions: {}, types: /* @__PURE__ */ new Set() };
+      }
+      const currentModule = modules[moduleName];
+      const successResponseKey = Object.keys(endpoint.responses).find((code) => code.startsWith("2"));
+      const successResponse = successResponseKey ? endpoint.responses[successResponseKey] : void 0;
+      const responseSchema = successResponse?.content?.["application/json"]?.schema;
+      const outputType = successResponseKey === "204" ? "void" : _extractTypeNameFromSchema(responseSchema);
+      const requestBody = endpoint.requestBody;
+      const requestSchema = requestBody?.content?.["application/json"]?.schema;
+      let inputType = "undefined";
+      if (requestSchema) {
+        inputType = _extractTypeNameFromSchema(requestSchema);
+      } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
+        inputType = "QueryOptions";
       }
-      const { inputType, outputType } = getInputOutputTypes(endpoint);
       [inputType, outputType].forEach((t) => {
-        if (t && !["unknown", "undefined", "any", "QueryOptions", "Promise"].includes(t)) {
-          modules[moduleName].types.add(t.replace("[]", ""));
+        if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
+          currentModule.types.add(t.replace("[]", ""));
         }
       });
-      const actionName = sanitizeActionName(endpoint.operationId);
-      const relativePath = apiPath.replace(modules[moduleName].baseEndpoint, "") || "/";
-      modules[moduleName].actions[actionName] = {
+      const actionName = _sanitizeActionName(endpoint.operationId, method, apiPath);
+      const relativePath = apiPath.replace(currentModule.baseEndpoint, "").replace(/^\//, "");
+      currentModule.actions[actionName] = {
         method: method.toUpperCase(),
-        path: relativePath,
-        description: endpoint.summary || "No description available.",
+        path: relativePath === "" ? "/" : relativePath,
+        description: endpoint.summary || "",
         hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
         autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
         invalidates: [],
@@ -69,104 +191,77 @@ function parseSpecToModules(spec) {
   }
   return modules;
 }
-function getInputOutputTypes(endpoint) {
-  const requestBodySchema = endpoint.requestBody?.content?.["application/json"]?.schema;
-  const successResponseSchema = endpoint.responses?.["200"]?.content?.["application/json"]?.schema || endpoint.responses?.["201"]?.content?.["application/json"]?.schema;
-  let outputType = "unknown";
-  if (successResponseSchema) {
-    if (successResponseSchema.$ref) {
-      outputType = refToTypeName(successResponseSchema.$ref);
-    } else if (successResponseSchema.type === "array" && successResponseSchema.items?.$ref) {
-      outputType = `${refToTypeName(successResponseSchema.items.$ref)}[]`;
+function _extractTypeNameFromSchema(schema) {
+  if (!schema) return "unknown";
+  if ("$ref" in schema && schema.$ref) return _refToTypeName(schema.$ref);
+  if (!("$ref" in schema)) {
+    if (schema.type === "array" && schema.items) {
+      const itemType = _extractTypeNameFromSchema(schema.items);
+      return itemType !== "unknown" ? `${itemType}[]` : "unknown[]";
     }
-  }
-  let inputType = "undefined";
-  if (requestBodySchema) {
-    if (requestBodySchema.$ref) {
-      inputType = refToTypeName(requestBodySchema.$ref);
-    } else if (requestBodySchema.type === "object") {
-      inputType = "any";
+    if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
+      return schema.type === "integer" ? "number" : schema.type;
     }
-  } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
-    inputType = "QueryOptions";
   }
-  return { inputType, outputType };
+  return "unknown";
 }
-function sanitizeTagName(tagName) {
-  return tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "");
-}
-function sanitizeActionName(operationId) {
-  if (!operationId) return `unnamedAction_${Date.now()}`;
-  const name = operationId.split("_").slice(1).join("_");
-  return name.charAt(0).toLowerCase() + name.slice(1).replace(/_v\d+$/, "");
-}
-function refToTypeName(ref) {
-  if (!ref) return "unknown";
-  return ref.split("/").pop() || "unknown";
-}
-
-// src/generator/file-generator.ts
-var import_fs = __toESM(require("fs"), 1);
-var import_path = __toESM(require("path"), 1);
-var import_chalk = __toESM(require("chalk"), 1);
-var import_json_schema_to_typescript = require("json-schema-to-typescript");
 async function generateModuleFiles(moduleName, moduleData, spec, outputDir) {
-  console.log(import_chalk.default.cyan(`
-Generating module: ${moduleName}`));
+  console.log(import_chalk.default.gray(`  Generating files for module: ${import_chalk.default.bold(moduleName)}...`));
   const moduleFolderPath = import_path.default.join(outputDir, moduleName);
   if (!import_fs.default.existsSync(moduleFolderPath)) {
     import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
   }
-  await generateTypesFile(moduleFolderPath, moduleName, moduleData.types, spec);
-  await generateConfigFile(moduleFolderPath, moduleName, moduleData);
+  await _generateTypesFile(moduleFolderPath, moduleName, moduleData.types, spec);
+  await _generateConfigFile(moduleFolderPath, moduleName, moduleData);
 }
-async function generateTypesFile(moduleFolderPath, moduleName, typeNames, spec) {
-  const typesCount = typeNames.size;
-  if (typesCount === 0) {
-    console.log(import_chalk.default.yellow(`  - No types found for this module. types.ts will be empty.`));
-  } else {
-    console.log(import_chalk.default.gray(`  - Found ${typesCount} types to generate for types.ts...`));
+async function _generateTypesFile(moduleFolderPath, moduleName, typeNames, spec) {
+  if (typeNames.size === 0) {
+    console.log(import_chalk.default.yellow(`    - No types found for module "${moduleName}". Skipping types.ts generation.`));
+    const typesFilePath2 = import_path.default.join(moduleFolderPath, "types.ts");
+    import_fs.default.writeFileSync(typesFilePath2, `// No types found for this module.
+`);
+    return;
   }
+  console.log(import_chalk.default.gray(`    - Generating types.ts with ${typeNames.size} types...`));
   let typesContent = `// This file is auto-generated by the API generator. Do not edit.
 
 `;
   const allSchemas = spec.components?.schemas || {};
-  for (const typeName of typeNames) {
-    const schema = allSchemas[typeName];
-    if (schema) {
+  const compilationOptions = {
+    bannerComment: "",
+    style: { bracketSpacing: true, printWidth: 120, semi: true, singleQuote: true, tabWidth: 2, trailingComma: "es5", useTabs: false },
+    additionalProperties: false,
+    declareExternallyReferenced: true
+  };
+  const rootSchemaForCompilation = {
+    $id: "allSchemas",
+    definitions: allSchemas,
+    type: "object",
+    // <-- الإصلاح هنا
+    properties: {}
+  };
+  for (const typeName of Array.from(typeNames).sort()) {
+    if (allSchemas[typeName]) {
       try {
-        const tsType = await (0, import_json_schema_to_typescript.compile)(schema, typeName, {
-          bannerComment: "",
-          additionalProperties: false,
-          style: {
-            bracketSpacing: true,
-            printWidth: 120,
-            semi: true,
-            singleQuote: true,
-            tabWidth: 2,
-            trailingComma: "es5",
-            useTabs: false
-          }
-        });
+        const tsType = await (0, import_json_schema_to_typescript.compile)(rootSchemaForCompilation, typeName, compilationOptions);
         typesContent += tsType + "\n";
       } catch (compileError) {
-        console.error(import_chalk.default.red(`  - Error compiling type "${typeName}" for module "${moduleName}":`));
-        console.error(import_chalk.default.red(`    ${compileError.message}`));
+        console.error(import_chalk.default.red(`    - Error compiling type "${typeName}": ${compileError.message}`));
       }
     } else {
-      console.log(import_chalk.default.yellow(`  - Warning: Schema for type "${typeName}" not found in dereferenced spec, skipping.`));
+      console.log(import_chalk.default.yellow(`    - Warning: Schema for type "${typeName}" not found, skipping.`));
     }
   }
   const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
-  import_fs.default.writeFileSync(typesFilePath, typesContent);
+  import_fs.default.writeFileSync(typesFilePath, typesContent, { encoding: "utf-8" });
 }
-async function generateConfigFile(moduleFolderPath, moduleName, moduleData) {
-  const typeNamesArray = [...moduleData.types];
+async function _generateConfigFile(moduleFolderPath, moduleName, moduleData) {
   const actionsCount = Object.keys(moduleData.actions).length;
-  console.log(import_chalk.default.gray(`  - Found ${actionsCount} actions to generate for config.ts...`));
-  const typesImportStatement = typeNamesArray.length > 0 ? `import type { ${typeNamesArray.join(", ")} } from './types';` : ``;
+  console.log(import_chalk.default.gray(`    - Generating config.ts with ${actionsCount} actions...`));
+  const typeNamesArray = [...moduleData.types].sort();
+  const typesImportStatement = typeNamesArray.length > 0 ? `import type { ${typeNamesArray.join(", ")} } from './types';` : `// No types to import for this module`;
   const actionsTypeParts = Object.entries(moduleData.actions).map(
-    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
+    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType || "undefined"}, ${actionData._outputType || "unknown"}>;`
   );
   const actionsTypeDefinition = `{
 ${actionsTypeParts.join("\n")}
@@ -180,8 +275,10 @@ ${actionsTypeParts.join("\n")}
   const actionsValueDefinition = `{
 ${actionsValueParts.join(",\n")}
   }`;
-  const configContent = `
-import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
+  const configContent = `/* eslint-disable */
+// This file is auto-generated by the API generator. Do not edit.
+
+import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib'; // \u0627\u0641\u062A\u0631\u0636 \u0623\u0646 \u0647\u0630\u0627 \u0627\u0644\u0645\u0633\u0627\u0631 \u0635\u062D\u064A\u062D
 ${typesImportStatement}
 
 export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
@@ -190,104 +287,77 @@ export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
 };
 `;
   const configFilePath = import_path.default.join(moduleFolderPath, "config.ts");
-  import_fs.default.writeFileSync(configFilePath, configContent);
+  import_fs.default.writeFileSync(configFilePath, configContent.trim(), { encoding: "utf-8" });
 }
-
-// src/generator/spec-preprocessor.ts
-function toPascalCase(str) {
-  return str.replace(/_v\d+$/, "").split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+function _toPascalCase(str) {
+  return str.replace(/[^a-zA-Z0-9]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase()).replace(/\s+/g, "");
 }
-function normalizeSchema(schema, schemas, baseName, suffix) {
-  if (!schema) return schema;
-  if (schema.$ref) return schema;
-  if (schema.type === "object" && schema.properties) {
-    const typeName = `${toPascalCase(baseName)}${suffix}Dto`;
-    if (!schemas[typeName]) {
-      schemas[typeName] = schema;
-    }
-    return { $ref: `#/components/schemas/${typeName}` };
-  }
-  if (schema.type === "array" && schema.items) {
-    schema.items = normalizeSchema(schema.items, schemas, baseName, suffix.replace("[]", ""));
-    return schema;
+function _refToTypeName(ref) {
+  if (!ref) return "unknown";
+  return ref.split("/").pop() || "unknown";
+}
+function _sanitizeTagName(tagName) {
+  return tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "");
+}
+function _sanitizeActionName(operationId, method, path3) {
+  if (operationId) {
+    const name = operationId.split("_").slice(1).join("_");
+    const sanitized = name.charAt(0).toLowerCase() + name.slice(1).replace(/_v\d+$/, "");
+    return sanitized || "action";
   }
-  return schema;
+  const pathPart = path3.replace(/[\/{}]/g, "_").replace(/^_|_$/g, "");
+  return `${method.toLowerCase()}_${pathPart}`;
 }
-function preprocessSpec(spec) {
-  if (!spec.components) spec.components = {};
-  if (!spec.components.schemas) spec.components.schemas = {};
-  for (const apiPath in spec.paths) {
-    for (const method in spec.paths[apiPath]) {
-      const endpoint = spec.paths[apiPath][method];
-      const operationId = endpoint.operationId;
-      if (!operationId) continue;
-      const requestBodySchema = endpoint.requestBody?.content?.["application/json"]?.schema;
-      if (requestBodySchema) {
-        endpoint.requestBody.content["application/json"].schema = normalizeSchema(
-          requestBodySchema,
-          spec.components.schemas,
-          operationId,
-          "Request"
-        );
-      }
-      if (endpoint.responses) {
-        for (const statusCode in endpoint.responses) {
-          const responseSchema = endpoint.responses[statusCode]?.content?.["application/json"]?.schema;
-          if (responseSchema) {
-            endpoint.responses[statusCode].content["application/json"].schema = normalizeSchema(
-              responseSchema,
-              spec.components.schemas,
-              operationId,
-              "Response"
-            );
-          }
-        }
-      }
+function _findCommonBasePath(spec, tagName) {
+  const paths = Object.keys(spec.paths).filter((p) => {
+    const pathItem = spec.paths[p];
+    if (!pathItem) return false;
+    for (const method in pathItem) {
+      const endpoint = pathItem[method];
+      if (endpoint.tags?.includes(tagName)) return true;
+    }
+    return false;
+  });
+  if (paths.length === 0) return "/";
+  let commonPrefix = paths[0];
+  for (let i = 1; i < paths.length; i++) {
+    while (paths[i].indexOf(commonPrefix) !== 0) {
+      commonPrefix = commonPrefix.substring(0, commonPrefix.length - 1);
     }
   }
-  return spec;
+  return commonPrefix.substring(0, commonPrefix.lastIndexOf("/") + 1) || "/";
 }
-
-// src/generator/index.ts
 async function runGenerator(options) {
-  console.log(import_chalk2.default.cyan.bold("\u{1F680} Starting API Core Lib Code Generator..."));
-  console.log(import_chalk2.default.gray(`Output directory: ${options.output}`));
-  console.log(import_chalk2.default.gray(`.env path: ${options.envPath}`));
-  console.log("\n" + import_chalk2.default.blue("Step 1: Loading environment variables..."));
+  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Core Lib Code Generator..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = getSpecUrl();
-  console.log(import_chalk2.default.green("\u2713 Environment variables loaded."));
+  console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
-    console.log("\n" + import_chalk2.default.blue(`Step 2: Fetching OpenAPI spec from ${specUrl}...`));
-    const response = await import_axios.default.get(specUrl, { timeout: 15e3 });
-    const originalSpec = response.data;
-    if (!originalSpec.openapi || !originalSpec.paths) {
-      throw new Error('Invalid OpenAPI specification file. "openapi" or "paths" property is missing.');
-    }
-    console.log(import_chalk2.default.green("\u2713 OpenAPI spec fetched successfully."));
-    console.log(import_chalk2.default.blue("Step 2.2: Preprocessing spec to normalize schemas..."));
-    const normalizedSpec = preprocessSpec(originalSpec);
-    console.log(import_chalk2.default.green("\u2713 Spec has been normalized successfully."));
-    console.log(import_chalk2.default.blue("Step 2.5: Dereferencing all $refs in the spec..."));
-    const dereferencedSpec = await import_json_schema_ref_parser.default.dereference(normalizedSpec);
-    console.log(import_chalk2.default.green("\u2713 Spec dereferenced successfully."));
-    console.log("\n" + import_chalk2.default.blue("Step 3: Parsing spec and generating API modules..."));
+    console.log(import_chalk.default.blue(`
+\u23F3 Step 2: Fetching and validating spec from ${specUrl}...`));
+    const initialSpec = await import_swagger_parser.default.validate(specUrl, {
+      dereference: { circular: "ignore" }
+    });
+    console.log(import_chalk.default.green("\u2713 Spec fetched and validated successfully."));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Preprocessing spec to normalize inline schemas..."));
+    const normalizedSpec = preprocessSpec(initialSpec);
+    console.log(import_chalk.default.green("\u2713 Spec has been normalized successfully."));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Parsing spec and generating API modules structure..."));
     const modules = parseSpecToModules(normalizedSpec);
     const modulesCount = Object.keys(modules).length;
-    console.log(import_chalk2.default.gray(`Found ${modulesCount} modules to generate...`));
+    console.log(import_chalk.default.green(`\u2713 Found ${modulesCount} modules to generate.`));
     if (modulesCount === 0) {
-      console.log(import_chalk2.default.yellow("Warning: No modules found."));
+      console.log(import_chalk.default.yellow("Warning: No modules were found in the spec."));
     }
-    const modulesOutputPath = import_path2.default.join(options.output, "modules");
+    console.log(import_chalk.default.blue("\n\u23F3 Step 5: Generating module files..."));
+    const modulesOutputPath = import_path.default.join(options.output, "modules");
     for (const moduleName in modules) {
       const moduleData = modules[moduleName];
-      await generateModuleFiles(moduleName, moduleData, dereferencedSpec, modulesOutputPath);
-    }
-    if (modulesCount > 0) {
-      console.log(import_chalk2.default.green("\u2713 All custom modules generated."));
+      await generateModuleFiles(moduleName, moduleData, normalizedSpec, modulesOutputPath);
     }
-    console.log(import_chalk2.default.bold.green("\n\u{1F389} API generation complete! All files are located in:"));
-    console.log(import_chalk2.default.bold.cyan(options.output));
+    console.log(import_chalk.default.green("\u2713 All module files generated."));
+    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete!"));
+    console.log(import_chalk.default.bold.cyan(`   Output directory: ${options.output}`));
   } catch (error) {
     handleGenerationError(error);
   }
@@ -295,24 +365,24 @@ async function runGenerator(options) {
 function getSpecUrl() {
   const specUrl = process.env.OPENAPI_SPEC_URL || (process.env.API_URL ? `${process.env.API_URL}/docs-json` : null) || (process.env.NEXT_PUBLIC_API_URL ? `${process.env.NEXT_PUBLIC_API_URL}/docs-json` : null);
   if (!specUrl) {
-    console.error(import_chalk2.default.red.bold("\n\u274C Error: API specification URL not found."));
+    console.error(import_chalk.default.red.bold("\n\u274C Error: API specification URL not found."));
     process.exit(1);
   }
   return specUrl;
 }
 function handleGenerationError(error) {
-  console.error(import_chalk2.default.red.bold("\n\u274C An error occurred during generation:"));
-  console.error(import_chalk2.default.red(`Error Message: ${error.message}`));
+  console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
+  console.error(import_chalk.default.red(`Error Message: ${error.message}`));
   if (error.stack) {
-    console.error(import_chalk2.default.gray(error.stack));
+    console.error(import_chalk.default.gray(error.stack));
   }
   process.exit(1);
 }
 
 // src/cli.ts
 console.log("API Core Lib - Code Generator");
-import_commander.program.option("-o, --output <path>", "Output directory for generated files", "src/lib/api-generated").option("--env-path <path>", ".env file path", import_path3.default.resolve(process.cwd(), ".env")).action((options) => {
-  const absoluteOutputPath = import_path3.default.resolve(process.cwd(), options.output);
+import_commander.program.option("-o, --output <path>", "Output directory for generated files", "src/lib/api-generated").option("--env-path <path>", ".env file path", import_path2.default.resolve(process.cwd(), ".env")).action((options) => {
+  const absoluteOutputPath = import_path2.default.resolve(process.cwd(), options.output);
   runGenerator({ ...options, output: absoluteOutputPath });
 });
 import_commander.program.parse(process.argv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.57",
+  "version": "12.0.59",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {
@@ -36,6 +36,7 @@
   },
   "dependencies": {
     "@apidevtools/json-schema-ref-parser": "^14.2.0",
+    "@apidevtools/swagger-parser": "^12.0.0",
     "axios": "^1.6.8",
     "axios-retry": "^4.1.0",
     "chalk": "^4.1.2",
@@ -46,6 +47,7 @@
     "fs-extra": "^11.3.1",
     "json-schema-to-typescript": "^15.0.4",
     "openapi-typescript": "^6.2.4",
+    "openapi-typescript-codegen": "^0.29.0",
     "path": "^0.12.7",
     "uuid": "^9.0.1"
   },