api-core-lib 12.0.47 → 12.0.49

package/dist/cli.cjs

@@ -33,74 +33,7 @@ var import_path = __toESM(require("path"), 1);
 var import_axios = __toESM(require("axios"), 1);
 var import_chalk = __toESM(require("chalk"), 1);
 var import_dotenv = __toESM(require("dotenv"), 1);
-var import_child_process = require("child_process");
-
-// src/generator/module-parser.ts
-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";
-}
-function parseSpecToModules(spec) {
-  const modules = {};
-  for (const apiPath in spec.paths) {
-    for (const method in spec.paths[apiPath]) {
-      const endpoint = spec.paths[apiPath][method];
-      if (!endpoint.tags || endpoint.tags.length === 0) continue;
-      const tagName = endpoint.tags[0];
-      const moduleName = tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "") + "Api";
-      if (!modules[moduleName]) {
-        const commonPath = apiPath.substring(0, apiPath.lastIndexOf("/"));
-        modules[moduleName] = { baseEndpoint: commonPath || "/", actions: {}, types: /* @__PURE__ */ new Set() };
-      }
-      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)}[]`;
-        }
-      }
-      let inputType = "undefined";
-      if (requestBody) {
-        if (requestBody.$ref) {
-          inputType = refToTypeName(requestBody.$ref);
-        } else if (requestBody.type === "object") {
-          inputType = "any";
-        }
-      } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
-        inputType = "QueryOptions";
-      }
-      [inputType, outputType].forEach((t) => {
-        if (t && t !== "unknown" && t !== "undefined" && t !== "any" && t !== "QueryOptions") {
-          modules[moduleName].types.add(t.replace("[]", ""));
-        }
-      });
-      const actionName = sanitizeActionName(endpoint.operationId);
-      const relativePath = apiPath.replace(modules[moduleName].baseEndpoint, "") || "/";
-      modules[moduleName].actions[actionName] = {
-        method: method.toUpperCase(),
-        path: relativePath,
-        description: endpoint.summary || "No description available.",
-        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
-        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
-        invalidates: [],
-        _inputType: inputType,
-        _outputType: outputType
-      };
-    }
-  }
-  return modules;
-}
-
-// src/generator/index.ts
+var import_json_schema_to_typescript = require("json-schema-to-typescript");
 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}`));
@@ -110,33 +43,20 @@ async function runGenerator(options) {
   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 (recommended) or API_URL/NEXT_PUBLIC_API_URL in your .env file."));
+    console.error(import_chalk.default.red("Please define either OPENAPI_SPEC_URL or API_URL/NEXT_PUBLIC_API_URL in your .env file."));
     process.exit(1);
   }
   console.log(import_chalk.default.green("\u2713 Environment variables loaded."));
   let tempSpecPath = "";
-  let ignoreFilePath = "";
   try {
     console.log("\n" + import_chalk.default.blue(`Step 2: Fetching OpenAPI spec from ${specUrl}...`));
-    tempSpecPath = import_path.default.join(process.cwd(), `swagger-${Date.now()}.json`);
     const response = await import_axios.default.get(specUrl, { timeout: 15e3 });
     const spec = response.data;
-    if (!spec.openapi || !spec.paths) {
-      throw new Error('Invalid OpenAPI specification file. "openapi" or "paths" property is missing.');
+    if (!spec.openapi || !spec.paths || !spec.components?.schemas) {
+      throw new Error('Invalid OpenAPI specification file. "openapi", "paths", or "components.schemas" property is missing.');
     }
-    import_fs.default.writeFileSync(tempSpecPath, JSON.stringify(spec, null, 2));
-    console.log(import_chalk.default.green(`\u2713 OpenAPI spec saved temporarily to ${tempSpecPath}`));
-    console.log("\n" + import_chalk.default.blue("Step 3: Generating organized TypeScript types..."));
-    const typesOutputPath = import_path.default.join(options.output, "types");
-    const generatorCommand = [
-      "npx --yes openapi-typescript",
-      `"${tempSpecPath}"`,
-      `--output "${import_path.default.join(typesOutputPath, "schema.d.ts")}"`
-    ].join(" ");
-    console.log(import_chalk.default.gray(`Executing command: npx openapi-typescript...`));
-    (0, import_child_process.execSync)(generatorCommand, { stdio: "inherit" });
-    console.log(import_chalk.default.green(`\u2713 Types generated successfully at ${typesOutputPath}`));
-    console.log("\n" + import_chalk.default.blue("Step 4: Generating custom API modules..."));
+    console.log(import_chalk.default.green(`\u2713 OpenAPI spec fetched successfully.`));
+    console.log("\n" + import_chalk.default.blue("Step 3: Parsing spec and generating API modules..."));
     const modules = parseSpecToModules(spec);
     const modulesOutputPath = import_path.default.join(options.output, "modules");
     if (!import_fs.default.existsSync(modulesOutputPath)) {
@@ -149,8 +69,31 @@ async function runGenerator(options) {
         import_fs.default.mkdirSync(moduleFolderPath, { recursive: true });
       }
       const typesFilePath = import_path.default.join(moduleFolderPath, "types.ts");
-      const typesContent = moduleData.types.size ? `export type { ${[...moduleData.types].join(", ")} } from '../../types';` : `// No types used in this module`;
+      let typesContent = `// This file is auto-generated by the API generator. Do not edit.
+
+`;
+      const allModuleTypes = getAllReferencedTypes(moduleData.types, spec.components.schemas);
+      for (const typeName of allModuleTypes) {
+        const schema = spec.components.schemas[typeName];
+        if (schema) {
+          const tsType = await (0, import_json_schema_to_typescript.compile)(spec, typeName, {
+            bannerComment: "",
+            additionalProperties: false,
+            style: {
+              bracketSpacing: true,
+              printWidth: 120,
+              semi: true,
+              singleQuote: true,
+              tabWidth: 2,
+              trailingComma: "es5",
+              useTabs: false
+            }
+          });
+          typesContent += tsType + "\n";
+        }
+      }
       import_fs.default.writeFileSync(typesFilePath, typesContent);
+      const allTypeNames = [...allModuleTypes];
       const actionsTypeParts = Object.entries(moduleData.actions).map(
         ([actionName, actionData]) => `  ${actionName}: ActionConfigModule<${actionData._inputType}, ${actionData._outputType}>;`
       );
@@ -167,9 +110,10 @@ ${actionsTypeParts.join("\n")}
 ${actionsValueParts.join(",\n")}
   }`;
       const configFilePath = import_path.default.join(moduleFolderPath, "config.ts");
+      const typesImportStatement = allTypeNames.length > 0 ? `import type { ${allTypeNames.join(", ")} } from './types';` : `// No custom types used in this module.`;
       const configContent = `
 import type { ApiModuleConfig, ActionConfigModule, QueryOptions } from 'api-core-lib';
-import type { ${[...moduleData.types].join(", ")} } from './types';
+${typesImportStatement}
 
 export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
   baseEndpoint: '${moduleData.baseEndpoint}',
@@ -177,7 +121,7 @@ export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
 };
 `;
       import_fs.default.writeFileSync(configFilePath, configContent);
-      console.log(import_chalk.default.green(`\u2713 Module generated: ${moduleName}/`));
+      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:"));
@@ -195,14 +139,90 @@ export const ${moduleName}Module: ApiModuleConfig<${actionsTypeDefinition}> = {
     process.exit(1);
   } finally {
     if (tempSpecPath && import_fs.default.existsSync(tempSpecPath)) {
-      import_fs.default.unlinkSync(tempSpecPath);
       console.log(import_chalk.default.gray("\nTemporary spec file cleaned up."));
     }
-    if (ignoreFilePath && import_fs.default.existsSync(ignoreFilePath)) {
-      import_fs.default.unlinkSync(ignoreFilePath);
-      console.log(import_chalk.default.gray("Temporary ignore file cleaned up."));
+  }
+}
+function parseSpecToModules(spec) {
+  const modules = {};
+  for (const apiPath in spec.paths) {
+    for (const method in spec.paths[apiPath]) {
+      const endpoint = spec.paths[apiPath][method];
+      if (!endpoint.tags || endpoint.tags.length === 0) continue;
+      const tagName = endpoint.tags[0];
+      const moduleName = tagName.replace(/[^a-zA-Z0-9]/g, "").replace(/Central|Tenant/g, "") + "Api";
+      if (!modules[moduleName]) {
+        const commonPath = apiPath.substring(0, apiPath.lastIndexOf("/"));
+        modules[moduleName] = { baseEndpoint: commonPath || "/", actions: {}, types: /* @__PURE__ */ new Set() };
+      }
+      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)}[]`;
+        }
+      }
+      let inputType = "undefined";
+      if (requestBody) {
+        if (requestBody.$ref) {
+          inputType = refToTypeName(requestBody.$ref);
+        } else if (requestBody.type === "object") {
+          inputType = "any";
+        }
+      } else if ((endpoint.parameters || []).some((p) => p.in === "query")) {
+        inputType = "QueryOptions";
+      }
+      [inputType, outputType].forEach((t) => {
+        if (t && t !== "unknown" && t !== "undefined" && t !== "any" && t !== "QueryOptions") {
+          modules[moduleName].types.add(t.replace("[]", ""));
+        }
+      });
+      const actionName = sanitizeActionName(endpoint.operationId);
+      const relativePath = apiPath.replace(modules[moduleName].baseEndpoint, "") || "/";
+      modules[moduleName].actions[actionName] = {
+        method: method.toUpperCase(),
+        path: relativePath,
+        description: endpoint.summary || "No description available.",
+        hasQuery: (endpoint.parameters || []).some((p) => p.in === "query"),
+        autoFetch: method.toUpperCase() === "GET" && !apiPath.includes("{"),
+        invalidates: [],
+        _inputType: inputType,
+        _outputType: outputType
+      };
+    }
+  }
+  return modules;
+}
+function getAllReferencedTypes(initialTypes, allSchemas) {
+  const finalTypes = new Set(initialTypes);
+  const queue = [...initialTypes];
+  while (queue.length > 0) {
+    const typeName = queue.shift();
+    if (!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 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/cli.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "api-core-lib",
-  "version": "12.0.47",
+  "version": "12.0.49",
   "description": "A flexible and powerful API client library for modern web applications.",
   "type": "module",
   "exports": {
@@ -43,6 +43,7 @@
     "dotenv": "^16.0.3",
     "fast-deep-equal": "^3.1.3",
     "fs-extra": "^11.3.1",
+    "json-schema-to-typescript": "^15.0.4",
     "openapi-typescript": "^6.2.4",
     "path": "^0.12.7",
     "uuid": "^9.0.1"