api-core-lib 12.0.58 → 12.0.60

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,43 +26,340 @@ 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_path = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
 // src/generator/index.ts
+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_openapi_typescript_codegen = require("openapi-typescript-codegen");
+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) {
+    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";
+      if (!modules[moduleName]) {
+        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";
+      }
+      [inputType, outputType].forEach((t) => {
+        if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
+          currentModule.types.add(t.replace("[]", ""));
+        }
+      });
+      const actionName = _sanitizeActionName(endpoint.operationId, method, apiPath);
+      const relativePath = apiPath.replace(currentModule.baseEndpoint, "").replace(/^\//, "");
+      currentModule.actions[actionName] = {
+        method: method.toUpperCase(),
+        path: relativePath === "" ? "/" : relativePath,
+        description: endpoint.summary || "",
+        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
+        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
+        invalidates: [],
+        _inputType: inputType,
+        _outputType: outputType
+      };
+    }
+  }
+  return modules;
+}
+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[]";
+    }
+    if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
+      return schema.type === "integer" ? "number" : schema.type;
+    }
+  }
+  return "unknown";
+}
+async function generateModuleFiles(moduleName, moduleData, spec, outputDir) {
+  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);
+}
+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 || {};
+  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", قم ببناء المسار الصحيح
+    components: {
+      schemas: 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)(rootSchemaForCompilation, typeName, compilationOptions);
+        typesContent += tsType + "\n";
+      } catch (compileError) {
+        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, skipping.`));
+    }
+  }
+  const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
+  import_fs.default.writeFileSync(typesFilePath, typesContent, { encoding: "utf-8" });
+}
+async function _generateConfigFile(moduleFolderPath, moduleName, moduleData) {
+  const actionsCount = Object.keys(moduleData.actions).length;
+  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 || "undefined"}, ${actionData._outputType || "unknown"}>;`
+  );
+  const actionsTypeDefinition = `{
+${actionsTypeParts.join("\n")}
+}`;
+  const actionsValueParts = Object.entries(moduleData.actions).map(
+    ([actionName, actionData]) => {
+      const { _inputType, _outputType, ...config } = actionData;
+      return `    ${actionName}: ${JSON.stringify(config, null, 2).replace(/\n/g, "\n    ")}`;
+    }
+  );
+  const actionsValueDefinition = `{
+${actionsValueParts.join(",\n")}
+  }`;
+  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}> = {
+  baseEndpoint: '${moduleData.baseEndpoint}',
+  actions: ${actionsValueDefinition},
+};
+`;
+  const configFilePath = import_path.default.join(moduleFolderPath, "config.ts");
+  import_fs.default.writeFileSync(configFilePath, configContent.trim(), { encoding: "utf-8" });
+}
+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 _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";
+  }
+  const pathPart = path3.replace(/[\/{}]/g, "_").replace(/^_|_$/g, "");
+  return `${method.toLowerCase()}_${pathPart}`;
+}
+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 commonPrefix.substring(0, commonPrefix.lastIndexOf("/") + 1) || "/";
+}
 async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Client Generation..."));
-  console.log(import_chalk.default.gray(`Output directory: ${options.output}`));
-  console.log(import_chalk.default.gray(`.env path: ${options.envPath}`));
-  console.log("\n" + import_chalk.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_chalk.default.green("\u2713 Environment variables loaded successfully."));
-  console.log(import_chalk.default.gray(`Fetching spec from: ${specUrl}`));
+  console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
-    console.log("\n" + import_chalk.default.blue("Step 2: Generating API client from OpenAPI spec..."));
-    await (0, import_openapi_typescript_codegen.generate)({
-      input: specUrl,
-      // مسار ملف المواصفات أو الرابط المباشر
-      output: options.output,
-      // مجلد المخرجات الرئيسي
-      clientName: "ApiClient",
-      // يمكنك تسمية العميل الرئيسي (اختياري)
-      useOptions: true,
-      // يضيف خيارات إضافية للدوال (مثل الفلاتر والترتيب)
-      useUnionTypes: false,
-      // استخدم الواجهات (interfaces) بدلاً من أنواع الاتحاد (union types)
-      exportSchemas: true,
-      // يقوم بتصدير جميع الـ schemas في ملف models.ts
-      exportServices: true
-      // يقوم بتوليد services بناءً على الـ tags
+    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.bold.green("\n\u{1F389} API client generation complete!"));
-    console.log(import_chalk.default.bold.cyan(`All files are located in: ${options.output}`));
+    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_chalk.default.green(`\u2713 Found ${modulesCount} modules to generate.`));
+    if (modulesCount === 0) {
+      console.log(import_chalk.default.yellow("Warning: No modules were found in the spec."));
+    }
+    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, normalizedSpec, modulesOutputPath);
+    }
+    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);
   }
@@ -68,14 +368,13 @@ 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_chalk.default.red.bold("\n\u274C Error: API specification URL not found."));
-    console.log(import_chalk.default.yellow("Please set OPENAPI_SPEC_URL, API_URL, or NEXT_PUBLIC_API_URL in your .env file."));
     process.exit(1);
   }
   return specUrl;
 }
 function handleGenerationError(error) {
   console.error(import_chalk.default.red.bold("\n\u274C An error occurred during generation:"));
-  console.error(import_chalk.default.red(error.message || "An unknown error occurred."));
+  console.error(import_chalk.default.red(`Error Message: ${error.message}`));
   if (error.stack) {
     console.error(import_chalk.default.gray(error.stack));
   }
@@ -84,8 +383,8 @@ function handleGenerationError(error) {
 
 // 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_path.default.resolve(process.cwd(), ".env")).action((options) => {
-  const absoluteOutputPath = import_path.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.58",
+  "version": "12.0.60",
   "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",