api-core-lib 12.0.64 → 12.0.66

package/dist/cli.cjs

@@ -74,112 +74,36 @@ 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");
-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 = {};
+  const modulePaths = {};
+  if (!spec.components) spec.components = {};
+  if (!spec.components.schemas) spec.components.schemas = {};
+  const allSchemas = 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];
-      if (!endpoint.tags || endpoint.tags.length === 0) continue;
-      const tagName = endpoint.tags[0];
-      const moduleName = _sanitizeTagName(tagName) + "Api";
+      if (!endpoint.operationId) continue;
+      const moduleName = _getModuleNameFromOperationId(endpoint.operationId);
       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";
+        modules[moduleName] = { baseEndpoint: "", actions: {}, types: /* @__PURE__ */ new Set() };
+        modulePaths[moduleName] = [];
       }
+      modulePaths[moduleName].push(apiPath);
+      const { inputType, outputType } = _extractInputOutputTypes(endpoint, allSchemas);
       [inputType, outputType].forEach((t) => {
         if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
-          currentModule.types.add(t.replace("[]", ""));
+          modules[moduleName].types.add(t.replace("[]", ""));
         }
       });
-      const actionName = _sanitizeActionName(endpoint.operationId, method, apiPath);
-      const relativePath = apiPath.replace(currentModule.baseEndpoint, "").replace(/^\//, "");
-      currentModule.actions[actionName] = {
+      const actionName = _sanitizeActionName(endpoint.operationId);
+      modules[moduleName].actions[actionName] = {
         method: method.toUpperCase(),
-        path: relativePath === "" ? "/" : relativePath,
+        path: apiPath,
+        // سنقوم بتعديل هذا لاحقًا ليصبح نسبيًا
         description: endpoint.summary || "",
         hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
         autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
@@ -189,74 +113,90 @@ function parseSpecToModules(spec) {
       };
     }
   }
+  for (const moduleName in modules) {
+    const basePath = _findCommonBasePath(modulePaths[moduleName]);
+    modules[moduleName].baseEndpoint = basePath;
+    for (const actionName in modules[moduleName].actions) {
+      const action = modules[moduleName].actions[actionName];
+      const relativePath = action.path.replace(basePath, "").replace(/^\//, "");
+      action.path = relativePath === "" ? "/" : relativePath;
+    }
+  }
   return modules;
 }
-function _extractTypeNameFromSchema(schema) {
+function _extractInputOutputTypes(endpoint, schemas) {
+  const operationId = endpoint.operationId || "UnnamedOperation";
+  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" : _schemaToTypeName(responseSchema, `${operationId}Response`, schemas);
+  const requestBody = endpoint.requestBody;
+  const requestSchema = requestBody?.content?.["application/json"]?.schema;
+  let inputType = "undefined";
+  if (requestSchema) {
+    inputType = _schemaToTypeName(requestSchema, `${operationId}Request`, schemas);
+  } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
+    inputType = "QueryOptions";
+  }
+  return { inputType, outputType };
+}
+function _schemaToTypeName(schema, name, schemas) {
   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 === "array" && schema.items) {
+    const itemTypeName = _schemaToTypeName(schema.items, `${name}Item`, schemas);
+    return `${itemTypeName}[]`;
+  }
+  if (schema.type === "object" || schema.properties || schema.allOf) {
+    const typeName = _toPascalCase(name);
+    if (!schemas[typeName]) {
+      schemas[typeName] = schema;
     }
-    if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
-      return schema.type === "integer" ? "number" : schema.type;
+    return typeName;
+  }
+  if (schema.type && ["string", "number", "boolean", "integer"].includes(schema.type)) {
+    return schema.type === "integer" ? "number" : schema.type;
+  }
+  if (Object.keys(schema).length === 0) {
+    const typeName = _toPascalCase(name);
+    if (!schemas[typeName]) {
+      schemas[typeName] = { type: "object", properties: {}, description: "Represents a dynamic or empty object." };
     }
+    return typeName;
   }
   return "unknown";
 }
-async function generateModuleFiles(moduleName, moduleData, spec, outputDir) {
+async function generateModuleFiles(moduleName, moduleData, allSchemas, 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);
+  if (!import_fs.default.existsSync(moduleFolderPath)) import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
+  await _generateTypesFile(moduleFolderPath, moduleName, moduleData.types, allSchemas);
   await _generateConfigFile(moduleFolderPath, moduleName, moduleData);
 }
-async function _generateTypesFile(moduleFolderPath, moduleName, typeNames, spec) {
+async function _generateTypesFile(moduleFolderPath, moduleName, typeNames, allSchemas) {
   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.
-`);
+    console.log(import_chalk.default.yellow(`    - No types for module "${moduleName}". Skipping types.ts.`));
     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 schemaContainer = {
-    components: {
-      schemas: allSchemas
-    }
+    additionalProperties: false
   };
   for (const typeName of Array.from(typeNames).sort()) {
-    if (allSchemas[typeName]) {
+    const schema = allSchemas[typeName];
+    if (schema) {
       try {
-        const tempSchemaToCompile = {
-          $ref: `#/components/schemas/${typeName}`
-        };
-        const finalSchema = { ...schemaContainer, ...tempSchemaToCompile };
-        const tsType = await (0, import_json_schema_to_typescript.compile)(
-          finalSchema,
-          typeName,
-          // <-- هذا الاسم سيُستخدم الآن بنجاح!
-          compilationOptions
-        );
+        const tsType = await (0, import_json_schema_to_typescript.compile)(schema, 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.`));
+      console.log(import_chalk.default.yellow(`    - Warning: Schema for type "${typeName}" not found.`));
     }
   }
   const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
@@ -266,26 +206,24 @@ 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 typesImportStatement = typeNamesArray.length > 0 ? `import type { ${typeNamesArray.join(", ")} } from './types';` : ``;
   const actionsTypeParts = Object.entries(moduleData.actions).map(
-    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType || "undefined"}, ${actionData._outputType || "unknown"}>;`
+    ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
   );
   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 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.
+// This file is auto-generated...
 
-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
+import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
 ${typesImportStatement}
 
 export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
@@ -297,91 +235,60 @@ export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
   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, "");
+  return str.replace(/[^a-zA-Z0-9]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
 }
-function _refToTypeName(ref) {
-  if (!ref) return "unknown";
-  return ref.split("/").pop() || "unknown";
+function _getModuleNameFromOperationId(operationId) {
+  const controllerName = operationId.split("_")[0].replace(/Controller$/, "");
+  return `${controllerName}Api`;
 }
-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 _sanitizeActionName(operationId) {
+  const nameParts = operationId.split("_");
+  if (nameParts.length <= 1) return operationId;
+  const actionPart = nameParts[1];
+  return actionPart.charAt(0).toLowerCase() + actionPart.slice(1);
 }
-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);
-    }
+function _findCommonBasePath(paths) {
+  if (!paths || paths.length === 0) return "/";
+  const sortedPaths = [...paths].sort();
+  const first = sortedPaths[0];
+  const last = sortedPaths[sortedPaths.length - 1];
+  let i = 0;
+  while (i < first.length && first.charAt(i) === last.charAt(i)) {
+    i++;
   }
-  return commonPrefix.substring(0, commonPrefix.lastIndexOf("/") + 1) || "/";
+  let prefix = first.substring(0, i);
+  return prefix.substring(0, prefix.lastIndexOf("/") + 1) || "/";
 }
 async function runGenerator(options) {
   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();
+  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, validating, and bundling spec from ${specUrl}...`));
-    const bundledSpec = await import_swagger_parser.default.bundle(specUrl);
-    console.log(import_chalk.default.green("\u2713 Spec fetched and fully bundled successfully."));
-    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Preprocessing spec to normalize any remaining inline schemas..."));
-    const normalizedSpec = preprocessSpec(bundledSpec);
-    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);
+\u23F3 Step 2: Fetching and fully dereferencing spec from ${specUrl}...`));
+    const dereferencedSpec = await import_swagger_parser.default.dereference(specUrl);
+    console.log(import_chalk.default.green("\u2713 Spec fetched and fully dereferenced successfully."));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 3: Parsing spec using intelligent grouping..."));
+    const modules = parseSpecToModules(dereferencedSpec);
     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..."));
+    console.log(import_chalk.default.green(`\u2713 Found and grouped ${modulesCount} logical modules.`));
+    console.log(import_chalk.default.blue("\n\u23F3 Step 4: Generating module files..."));
     const modulesOutputPath = import_path.default.join(options.output, "modules");
+    const allSchemas = dereferencedSpec.components?.schemas || {};
     for (const moduleName in modules) {
       const moduleData = modules[moduleName];
-      await generateModuleFiles(moduleName, moduleData, normalizedSpec, modulesOutputPath);
+      await generateModuleFiles(moduleName, moduleData, allSchemas, 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);
-  }
-}
-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.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_chalk.default.gray(error.stack));
     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: ${error.message}`));
-  if (error.stack) {
-    console.error(import_chalk.default.gray(error.stack));
-  }
-  process.exit(1);
 }
 
 // src/cli.ts

package/package.json

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