api-core-lib 12.0.63 → 12.0.65

package/dist/cli.cjs

@@ -74,77 +74,10 @@ 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 = {};
+  if (!spec.components) spec.components = {};
+  if (!spec.components.schemas) spec.components.schemas = {};
   for (const apiPath in spec.paths) {
     const pathItem = spec.paths[apiPath];
     if (!pathItem) continue;
@@ -158,18 +91,7 @@ function parseSpecToModules(spec) {
         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 } = _extractInputOutputTypes(endpoint, spec.components.schemas);
       [inputType, outputType].forEach((t) => {
         if (t && !["unknown", "undefined", "void", "any", "QueryOptions", "Promise"].includes(t)) {
           currentModule.types.add(t.replace("[]", ""));
@@ -191,66 +113,66 @@ function parseSpecToModules(spec) {
   }
   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 && ["string", "number", "boolean", "integer"].includes(schema.type)) {
-      return schema.type === "integer" ? "number" : schema.type;
+  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) + "Dto";
+    if (!schemas[typeName]) {
+      schemas[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(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.
-`);
     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}`));
@@ -266,26 +188,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,11 +217,7 @@ 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, "");
-}
-function _refToTypeName(ref) {
-  if (!ref) return "unknown";
-  return ref.split("/").pop() || "unknown";
+  return str.replace(/[^a-zA-Z0-9]/g, " ").replace(/(?:^\w|[A-Z]|\b\w)/g, (w) => w.toUpperCase()).replace(/\s+/g, "");
 }
 function _sanitizeTagName(tagName) {
   return tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "");
@@ -341,26 +257,22 @@ async function runGenerator(options) {
   console.log(import_chalk.default.blue("\u2713 Step 1: Environment variables loaded."));
   try {
     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);
+\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 and generating API modules structure..."));
+    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.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!"));
@@ -370,7 +282,7 @@ 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);
+  const specUrl = process.env.OPENAPI_SPEC_URL || "./swagger.json";
   if (!specUrl) {
     console.error(import_chalk.default.red.bold("\n\u274C Error: API specification URL not found."));
     process.exit(1);

package/package.json

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