api-core-lib 12.0.51 → 12.0.53

package/dist/cli.cjs

@@ -30,7 +30,7 @@ var import_path3 = __toESM(require("path"), 1);
 // src/generator/index.ts
 var import_path2 = __toESM(require("path"), 1);
 var import_axios = __toESM(require("axios"), 1);
-var import_chalk = __toESM(require("chalk"), 1);
+var import_chalk2 = __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);
 
@@ -49,7 +49,7 @@ function parseSpecToModules(spec) {
       }
       const { inputType, outputType } = getInputOutputTypes(endpoint);
       [inputType, outputType].forEach((t) => {
-        if (t && !["unknown", "undefined", "any", "QueryOptions"].includes(t)) {
+        if (t && !["unknown", "undefined", "any", "QueryOptions", "Promise"].includes(t)) {
           modules[moduleName].types.add(t.replace("[]", ""));
         }
       });
@@ -69,23 +69,28 @@ function parseSpecToModules(spec) {
   }
   return modules;
 }
-function getInputOutputTypes(endpoint) {
-  const requestBody = endpoint.requestBody?.content?.["application/json"]?.schema;
-  const successResponse = endpoint.responses["200"] || endpoint.responses["201"];
-  const responseSchema = successResponse?.content?.["application/json"]?.schema;
-  let outputType = "unknown";
-  if (responseSchema) {
-    if (responseSchema.$ref) {
-      outputType = refToTypeName(responseSchema.$ref);
-    } else if (responseSchema.type === "array" && responseSchema.items?.$ref) {
-      outputType = `${refToTypeName(responseSchema.items.$ref)}[]`;
-    }
+function extractTypeNameFromSchema(schema) {
+  if (!schema) return "unknown";
+  if (schema.title && schema.type === "object") {
+    return schema.title;
+  }
+  if (schema.type === "array" && schema.items) {
+    const itemTypeName = extractTypeNameFromSchema(schema.items);
+    return itemTypeName !== "unknown" ? `${itemTypeName}[]` : "unknown";
+  }
+  if (schema.$ref) {
+    return refToTypeName(schema.$ref);
   }
+  return "unknown";
+}
+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 = extractTypeNameFromSchema(successResponseSchema);
   let inputType = "undefined";
-  if (requestBody) {
-    if (requestBody.$ref) {
-      inputType = refToTypeName(requestBody.$ref);
-    } else if (requestBody.type === "object") {
+  if (requestBodySchema) {
+    inputType = extractTypeNameFromSchema(requestBodySchema);
+    if (inputType === "unknown" && requestBodySchema.type === "object") {
       inputType = "any";
     }
   } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
@@ -93,24 +98,6 @@ function getInputOutputTypes(endpoint) {
   }
   return { inputType, outputType };
 }
-function getAllReferencedTypes(initialTypes, allSchemas) {
-  const finalTypes = new Set(initialTypes);
-  const queue = [...initialTypes];
-  while (queue.length > 0) {
-    const typeName = queue.shift();
-    if (!typeName || !allSchemas[typeName]) continue;
-    const schemaString = JSON.stringify(allSchemas[typeName]);
-    const references = schemaString.match(/"\$ref":\s*"#\/components\/schemas\/([^"]+)"/g) || [];
-    for (const ref of references) {
-      const referencedTypeName = ref.split("/").pop()?.replace(/"/g, "") || "";
-      if (referencedTypeName && !finalTypes.has(referencedTypeName)) {
-        finalTypes.add(referencedTypeName);
-        queue.push(referencedTypeName);
-      }
-    }
-  }
-  return finalTypes;
-}
 function sanitizeTagName(tagName) {
   return tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "");
 }
@@ -127,44 +114,62 @@ function refToTypeName(ref) {
 // 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}`));
   const moduleFolderPath = import_path.default.join(outputDir, moduleName);
   if (!import_fs.default.existsSync(moduleFolderPath)) {
     import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
   }
-  const allTypeNames = getAllReferencedTypes(moduleData.types, spec.components.schemas);
-  await generateTypesFile(moduleFolderPath, allTypeNames, spec);
-  await generateConfigFile(moduleFolderPath, moduleName, moduleData, allTypeNames);
+  await generateTypesFile(moduleFolderPath, moduleName, moduleData.types, spec);
+  await generateConfigFile(moduleFolderPath, moduleName, moduleData);
 }
-async function generateTypesFile(moduleFolderPath, allTypeNames, spec) {
+async function generateTypesFile(moduleFolderPath, moduleName, typeNames, spec) {
+  const typesCount = typeNames.size;
+  if (typesCount === 0) {
+    console.log(import_chalk.default.yellow(`  - Warning: 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...`));
+  }
   let typesContent = `// This file is auto-generated by the API generator. Do not edit.
 
 `;
-  for (const typeName of allTypeNames) {
-    const schema = spec.components?.schemas?.[typeName];
+  const allSchemas = spec.components?.schemas || {};
+  for (const typeName of typeNames) {
+    const schema = allSchemas[typeName];
     if (schema) {
-      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
-        }
-      });
-      typesContent += tsType + "\n";
+      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
+          }
+        });
+        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}`));
+      }
+    } else {
+      console.log(import_chalk.default.yellow(`  - Warning: Schema not found for type "${typeName}", skipping.`));
     }
   }
   const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
   import_fs.default.writeFileSync(typesFilePath, typesContent);
 }
-async function generateConfigFile(moduleFolderPath, moduleName, moduleData, allTypeNames) {
-  const typeNamesArray = [...allTypeNames];
+async function generateConfigFile(moduleFolderPath, moduleName, moduleData) {
+  const typeNamesArray = [...moduleData.types];
+  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';` : ``;
   const actionsTypeParts = Object.entries(moduleData.actions).map(
     ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
@@ -196,35 +201,41 @@ export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
 
 // src/generator/index.ts
 async function runGenerator(options) {
-  console.log(import_chalk.default.cyan.bold("\u{1F680} Starting API Core Lib Code Generator..."));
-  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_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..."));
   import_dotenv.default.config({ path: options.envPath });
   const specUrl = getSpecUrl();
-  console.log(import_chalk.default.green("\u2713 Environment variables loaded."));
+  console.log(import_chalk2.default.green("\u2713 Environment variables loaded."));
   try {
-    console.log("\n" + import_chalk.default.blue(`Step 2: Fetching OpenAPI spec from ${specUrl}...`));
+    console.log("\n" + import_chalk2.default.blue(`Step 2: Fetching OpenAPI spec from ${specUrl}...`));
     const response = await import_axios.default.get(specUrl, { timeout: 15e3 });
     let spec = response.data;
     if (!spec.openapi || !spec.paths) {
       throw new Error('Invalid OpenAPI specification file. "openapi" or "paths" property is missing.');
     }
-    console.log(import_chalk.default.green("\u2713 OpenAPI spec fetched successfully."));
-    console.log(import_chalk.default.blue("Step 2.5: Dereferencing all $refs in the spec..."));
+    console.log(import_chalk2.default.green("\u2713 OpenAPI spec fetched successfully."));
+    console.log(import_chalk2.default.blue("Step 2.5: Dereferencing all $refs in the spec..."));
     spec = await import_json_schema_ref_parser.default.dereference(spec);
-    console.log(import_chalk.default.green("\u2713 Spec dereferenced successfully."));
-    console.log("\n" + import_chalk.default.blue("Step 3: Parsing spec and generating API modules..."));
+    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..."));
     const modules = parseSpecToModules(spec);
+    const modulesCount = Object.keys(modules).length;
+    console.log(import_chalk2.default.gray(`Found ${modulesCount} modules to generate...`));
+    if (modulesCount === 0) {
+      console.log(import_chalk2.default.yellow("Warning: No modules found based on tags in the OpenAPI spec. No files will be generated."));
+    }
     const modulesOutputPath = import_path2.default.join(options.output, "modules");
     for (const moduleName in modules) {
       const moduleData = modules[moduleName];
       await generateModuleFiles(moduleName, moduleData, spec, modulesOutputPath);
-      console.log(import_chalk.default.green(`\u2713 Module generated: ${moduleName}/ (config.ts, types.ts)`));
     }
-    console.log(import_chalk.default.green("\u2713 All custom modules generated."));
-    console.log(import_chalk.default.bold.green("\n\u{1F389} API generation complete! All files are located in:"));
-    console.log(import_chalk.default.bold.cyan(options.output));
+    if (modulesCount > 0) {
+      console.log(import_chalk2.default.green("\u2713 All custom modules generated."));
+    }
+    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));
   } catch (error) {
     handleGenerationError(error);
   }
@@ -232,23 +243,17 @@ 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_chalk.default.red.bold("\n\u274C Error: API specification URL not found."));
-    console.error(import_chalk.default.red("Please define either OPENAPI_SPEC_URL or API_URL/NEXT_PUBLIC_API_URL in your .env file."));
+    console.error(import_chalk2.default.red.bold("\n\u274C Error: API specification URL not found."));
+    console.error(import_chalk2.default.red("Please define either OPENAPI_SPEC_URL or API_URL/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:"));
-  if (error.message.includes("$ref")) {
-    console.error(import_chalk.default.red(error.message));
-  } else if (error.response) {
-    console.error(import_chalk.default.red(`Network Error: ${error.message} (Status: ${error.response.status})`));
-  } else if (error.stderr) {
-    console.error(import_chalk.default.red(`Command Execution Error: ${error.message}`));
-    console.error(import_chalk.default.gray(error.stderr.toString()));
-  } else {
-    console.error(import_chalk.default.red(error.message));
+  console.error(import_chalk2.default.red.bold("\n\u274C An error occurred during generation:"));
+  console.error(import_chalk2.default.red(`Error Message: ${error.message}`));
+  if (error.stack) {
+    console.error(import_chalk2.default.gray(error.stack));
   }
   process.exit(1);
 }

package/package.json

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