apiforge-analyzer 1.2.1 → 1.3.1

package/dist/cjs/export.js

@@ -92,6 +92,8 @@ function enrichRoute(route, index) {
         routeKey,
         tag,
         tags: route.tags?.length ? route.tags : [tag],
+        module: route.module,
+        service: route.service,
         summary: route.summary || generateSummary(route.method, route.path),
         description: route.description || generateDescription(route.method, route.path, tag),
         authRequired,

package/dist/cjs/frameworks/nestjs.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeNestJS = analyzeNestJS;
+const express_js_1 = require("./express.js");
+const nestjs_js_1 = require("../modules/nestjs.js");
+const express_js_2 = require("../modules/express.js");
+/**
+ * Analyze a NestJS application by extracting the underlying Express (or Fastify)
+ * HTTP adapter and reusing the existing Express route-walker.
+ *
+ * NestJS wraps an inner Express app under app.getHttpServer()._events.request.
+ * When that's available we get full runtime accuracy. Otherwise we warn and
+ * fall back to an empty array so the CLI can report the limitation.
+ */
+async function analyzeNestJS(app, rootDir) {
+    if (!app || typeof app.getHttpServer !== 'function') {
+        console.warn('⚠️  APIForge: NestJS app instance required. Pass the Nest application object.');
+        return [];
+    }
+    const httpServer = app.getHttpServer();
+    // NestJS wraps Express under _events.request when using the default adapter
+    const innerApp = httpServer?._events?.request ||
+        httpServer?._events?.['request'] ||
+        null;
+    if (!innerApp || typeof innerApp !== 'function') {
+        console.warn('⚠️  APIForge: Could not access inner Express adapter from NestJS app.');
+        return [];
+    }
+    const routes = await (0, express_js_1.analyzeExpress)(innerApp);
+    if (routes.length === 0)
+        return [];
+    // Detect module structure and annotate each route
+    const dir = rootDir || process.cwd();
+    const modules = (0, nestjs_js_1.detectNestModules)(dir).length > 0
+        ? (0, nestjs_js_1.detectNestModules)(dir)
+        : (0, express_js_2.detectExpressModules)(dir);
+    return (0, express_js_2.annotateRoutesWithModules)(routes, modules);
+}

package/dist/cjs/index.js

@@ -3,7 +3,7 @@
  * APIForge Analyzer — main entry point (dual ESM/CJS)
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
+exports.detectArchitectureType = exports.detectFramework = exports.uploadRoutes = exports.exportToJSON = exports.analyzeNestJS = exports.analyzeReactRouter = exports.analyzeVite = exports.analyzeNextApp = exports.analyzeNextPages = exports.analyzeExpress = void 0;
 exports.analyze = analyze;
 const fs_1 = require("fs");
 const path_1 = require("path");
@@ -17,9 +17,14 @@ const vite_js_1 = require("./frameworks/vite.js");
 Object.defineProperty(exports, "analyzeVite", { enumerable: true, get: function () { return vite_js_1.analyzeVite; } });
 const react_router_js_1 = require("./frameworks/react-router.js");
 Object.defineProperty(exports, "analyzeReactRouter", { enumerable: true, get: function () { return react_router_js_1.analyzeReactRouter; } });
+const nestjs_js_1 = require("./frameworks/nestjs.js");
+Object.defineProperty(exports, "analyzeNestJS", { enumerable: true, get: function () { return nestjs_js_1.analyzeNestJS; } });
 const detect_js_1 = require("./detect.js");
 const export_js_1 = require("./export.js");
 const uploader_js_1 = require("./uploader.js");
+const arch_detect_js_1 = require("./arch-detect.js");
+const express_js_2 = require("./modules/express.js");
+const nestjs_js_2 = require("./modules/nestjs.js");
 // ─── Env file loader — no dotenv dependency ───────────────────────────────────
 /**
  * Read a single variable from a .env-style file.
@@ -75,8 +80,10 @@ async function analyze(app, options) {
     if (options.skipInProduction !== false && process.env.NODE_ENV === 'production') {
         return [];
     }
-    // File-based debounce — survives nodemon restarts
-    if (options.runOnce !== false) {
+    // File-based debounce — survives nodemon restarts.
+    // Skipped in collection mode (statusFile set) because the CLI controls each service start
+    // and the shared .apiforge-last-run.json would cause services 2+ to be skipped.
+    if (options.runOnce !== false && !options.statusFile) {
         const elapsed = Date.now() - readLastRunMs();
         if (elapsed < DEBOUNCE_MS) {
             console.log(`⚡ APIForge: skipped (last run ${Math.round(elapsed / 1000)}s ago)`);
@@ -112,6 +119,9 @@ async function analyze(app, options) {
     }
     try {
         switch (framework) {
+            case 'nestjs':
+                routes = await (0, nestjs_js_1.analyzeNestJS)(app, options.nextDir || process.cwd());
+                break;
             case 'express':
                 if (!app) {
                     const msg = 'Express app instance required — pass your app object to analyze()';
@@ -120,6 +130,16 @@ async function analyze(app, options) {
                     return [];
                 }
                 routes = await (0, express_js_1.analyzeExpress)(app);
+                // For modular-monolithic: annotate each route with its module name
+                if (options.architectureType === 'modular-monolithic') {
+                    const dir = options.nextDir || process.cwd();
+                    const modules = (0, nestjs_js_2.detectNestModules)(dir).length > 0
+                        ? (0, nestjs_js_2.detectNestModules)(dir)
+                        : (0, express_js_2.detectExpressModules)(dir);
+                    if (modules.length > 0) {
+                        routes = (0, express_js_2.annotateRoutesWithModules)(routes, modules);
+                    }
+                }
                 break;
             case 'nextjs-pages':
                 routes = await (0, nextjs_pages_js_1.analyzeNextPages)(options.nextDir || 'pages/api');
@@ -156,12 +176,26 @@ async function analyze(app, options) {
     if (options.saveJson) {
         await (0, export_js_1.exportToJSON)(routes, options.projectName, options.jsonPath || 'api-export.json', options.baseUrl);
     }
+    // Stamp service name on routes if running in microservices mode
+    if (options.service) {
+        routes = routes.map(r => ({ ...r, service: options.service }));
+    }
+    // Multi-service collection mode: write routes to a per-service file for the CLI to aggregate.
+    // The CLI spawns each service individually, collects via this file, then uploads once.
+    if (options.statusFile) {
+        try {
+            (0, fs_1.writeFileSync)((0, path_1.join)(process.cwd(), options.statusFile), JSON.stringify({ status: 'collected', service: options.service, routes, routeCount: routes.length }), 'utf-8');
+        }
+        catch { }
+        return routes;
+    }
     if (options.upload !== false && options.apiKey) {
         await (0, uploader_js_1.uploadRoutes)(routes, {
             projectName: options.projectName,
             apiKey: options.apiKey,
             baseUrl: options.baseUrl,
             apiForgeUrl: options.apiForgeUrl,
+            architectureType: options.architectureType,
         });
     }
     return routes;
@@ -172,6 +206,8 @@ var uploader_js_2 = require("./uploader.js");
 Object.defineProperty(exports, "uploadRoutes", { enumerable: true, get: function () { return uploader_js_2.uploadRoutes; } });
 var detect_js_2 = require("./detect.js");
 Object.defineProperty(exports, "detectFramework", { enumerable: true, get: function () { return detect_js_2.detectFramework; } });
+var arch_detect_js_2 = require("./arch-detect.js");
+Object.defineProperty(exports, "detectArchitectureType", { enumerable: true, get: function () { return arch_detect_js_2.detectArchitectureType; } });
 exports.default = {
     analyze,
     analyzeExpress: express_js_1.analyzeExpress,
@@ -179,7 +215,9 @@ exports.default = {
     analyzeNextApp: nextjs_app_js_1.analyzeNextApp,
     analyzeVite: vite_js_1.analyzeVite,
     analyzeReactRouter: react_router_js_1.analyzeReactRouter,
+    analyzeNestJS: nestjs_js_1.analyzeNestJS,
     exportToJSON: export_js_1.exportToJSON,
     uploadRoutes: uploader_js_1.uploadRoutes,
     detectFramework: detect_js_1.detectFramework,
+    detectArchitectureType: arch_detect_js_1.detectArchitectureType,
 };

package/dist/cjs/modules/express.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectExpressModules = detectExpressModules;
+exports.resolveModuleForPath = resolveModuleForPath;
+exports.annotateRoutesWithModules = annotateRoutesWithModules;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect Express feature-module structure by scanning standard directory patterns.
+ * Works for: src/modules/, src/features/, src/domains/ conventions.
+ */
+function detectExpressModules(rootDir) {
+    const modules = [];
+    const srcDir = (0, path_1.join)(rootDir, 'src');
+    for (const parentDir of ['modules', 'features', 'domains']) {
+        const dir = (0, fs_1.existsSync)(srcDir)
+            ? (0, path_1.join)(srcDir, parentDir)
+            : (0, path_1.join)(rootDir, parentDir);
+        if (!(0, fs_1.existsSync)(dir))
+            continue;
+        const subdirs = (0, fs_1.readdirSync)(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory())
+            .map(entry => entry.name);
+        for (const name of subdirs) {
+            const routePrefix = `/${name}`;
+            modules.push({ name, routePrefix });
+        }
+        if (modules.length > 0)
+            break;
+    }
+    return modules;
+}
+/**
+ * Given a route path, return the module name it belongs to.
+ * Falls back to the tag (first meaningful path segment) when no module matches.
+ */
+function resolveModuleForPath(routePath, modules) {
+    if (modules.length === 0)
+        return undefined;
+    // Strip /api/v1/ etc. prefixes before matching
+    const normalized = routePath.replace(/^\/(api\/)?(v\d+\/)?/, '/');
+    for (const mod of modules) {
+        if (normalized.startsWith(mod.routePrefix + '/') || normalized === mod.routePrefix) {
+            return mod.name;
+        }
+    }
+    // Fallback: first non-param, non-version segment
+    const segment = normalized.split('/').filter(s => s && !s.startsWith(':'))[0];
+    return segment || undefined;
+}
+/**
+ * Annotate a list of routes with their module names using path-prefix matching.
+ */
+function annotateRoutesWithModules(routes, modules) {
+    return routes.map(route => ({
+        ...route,
+        module: resolveModuleForPath(route.path, modules) || inferModuleFromPath(route.path),
+    }));
+}
+function inferModuleFromPath(routePath) {
+    const skip = new Set(['api', 'v1', 'v2', 'v3']);
+    return (routePath
+        .split('/')
+        .filter(s => s && !s.startsWith(':') && !skip.has(s))[0] || 'general');
+}

package/dist/cjs/modules/nestjs.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectNestModules = detectNestModules;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect NestJS modules by scanning for *.module.ts files and extracting
+ * their declared controllers with the @Module() decorator.
+ */
+function detectNestModules(rootDir) {
+    const srcDir = (0, path_1.join)(rootDir, 'src');
+    const searchDir = (0, fs_1.existsSync)(srcDir) ? srcDir : rootDir;
+    const moduleFiles = findModuleFiles(searchDir);
+    if (moduleFiles.length === 0)
+        return [];
+    const modules = [];
+    for (const filePath of moduleFiles) {
+        const name = (0, path_1.basename)(filePath).replace('.module.ts', '');
+        // Skip the root AppModule — it's the container, not a domain module
+        if (name === 'app')
+            continue;
+        const routePrefix = inferPrefixFromModuleName(name);
+        modules.push({ name, routePrefix });
+    }
+    return modules;
+}
+function findModuleFiles(dir, depth = 0) {
+    if (depth > 8)
+        return [];
+    const results = [];
+    try {
+        const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (['node_modules', 'dist', '.next'].includes(entry.name))
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...findModuleFiles((0, path_1.join)(dir, entry.name), depth + 1));
+            }
+            else if (entry.isFile() && entry.name.endsWith('.module.ts')) {
+                results.push((0, path_1.join)(dir, entry.name));
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function inferPrefixFromModuleName(name) {
+    // user-profile → /user-profile, users → /users
+    return `/${name}`;
+}

package/dist/cjs/uploader.js

@@ -42,13 +42,15 @@ async function uploadRoutes(routes, options) {
         routes: enrichedRoutes,
         baseUrl: options.baseUrl,
         framework: enrichedRoutes[0]?.framework || 'unknown',
+        architectureType: options.architectureType || 'monolithic',
+        services: options.services || [],
     };
     try {
         const response = await axios_1.default.post(`${backendUrl}/api/cli/submit`, payload, {
             headers: {
                 'Content-Type': 'application/json',
                 'X-API-Key': options.apiKey,
-                'User-Agent': 'apiforge-analyzer/1.2.0',
+                'User-Agent': 'apiforge-analyzer/1.3.0',
             },
             timeout: 30000,
         });

package/dist/esm/arch-detect.js

@@ -0,0 +1,151 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, basename } from 'path';
+export function detectArchitectureType(rootDir) {
+    let microScore = 0;
+    let modularScore = 0;
+    const evidence = [];
+    const servicePaths = [];
+    const moduleNames = [];
+    // ── Microservices signals ────────────────────────────────────────────────────
+    // Definitive: config file lists services[]
+    const configPaths = [join(rootDir, 'apiforge.config.ts'), join(rootDir, '.apiforge.json')];
+    for (const configPath of configPaths) {
+        if (existsSync(configPath)) {
+            try {
+                const raw = readFileSync(configPath, 'utf-8');
+                if (raw.includes('"services"') || raw.includes("'services'") || raw.includes('services:')) {
+                    microScore += 50;
+                    evidence.push(`Config file with services[]: ${basename(configPath)}`);
+                }
+            }
+            catch { }
+        }
+    }
+    // docker-compose.yml with multiple node service entries
+    const composePath = join(rootDir, 'docker-compose.yml');
+    if (existsSync(composePath)) {
+        try {
+            const compose = readFileSync(composePath, 'utf-8');
+            const serviceMatches = compose.match(/^\s{2}\w[\w-]+:/gm) || [];
+            if (serviceMatches.length >= 3) {
+                microScore += 35;
+                evidence.push(`docker-compose.yml with ${serviceMatches.length} services`);
+            }
+        }
+        catch { }
+    }
+    // Multiple sibling package.json at depth 1
+    const siblingPackages = findSiblingPackages(rootDir);
+    if (siblingPackages.length >= 2) {
+        microScore += 40;
+        siblingPackages.forEach(p => servicePaths.push(p));
+        evidence.push(`${siblingPackages.length} sibling package.json files (${siblingPackages.join(', ')})`);
+    }
+    // services/, apps/, or microservices/ dir containing 2+ independently-built
+    // subdirs (own Dockerfile and/or package.json) — the common Docker-Compose
+    // microservices layout, where each service lives one level deeper than the
+    // sibling-package check above looks.
+    for (const parentDir of ['services', 'apps', 'microservices']) {
+        const parentPath = join(rootDir, parentDir);
+        if (!existsSync(parentPath))
+            continue;
+        try {
+            const subdirs = readdirSync(parentPath, { withFileTypes: true }).filter(d => d.isDirectory());
+            const ownedServices = subdirs.filter(d => existsSync(join(parentPath, d.name, 'Dockerfile')) ||
+                existsSync(join(parentPath, d.name, 'package.json')));
+            if (ownedServices.length >= 2) {
+                microScore += 45;
+                ownedServices.forEach(d => servicePaths.push(`./${parentDir}/${d.name}`));
+                evidence.push(`${parentDir}/ has ${ownedServices.length} independently-built services: ${ownedServices.map(d => d.name).join(', ')}`);
+                break;
+            }
+        }
+        catch { }
+    }
+    // ── Modular Monolithic signals ────────────────────────────────────────────────
+    // NestJS module files anywhere in src/
+    const srcDir = join(rootDir, 'src');
+    if (existsSync(srcDir)) {
+        const nestModules = findFilesRecursive(srcDir, '.module.ts');
+        if (nestModules.length > 0) {
+            modularScore += 40;
+            nestModules.forEach(f => {
+                const name = basename(f).replace('.module.ts', '');
+                if (!moduleNames.includes(name))
+                    moduleNames.push(name);
+            });
+            evidence.push(`NestJS @Module files: ${nestModules.map(f => basename(f)).join(', ')}`);
+        }
+        // src/modules/, src/features/, or src/domains/
+        for (const dir of ['modules', 'features', 'domains']) {
+            if (existsSync(join(srcDir, dir))) {
+                modularScore += 35;
+                evidence.push(`Feature-based directory: src/${dir}/`);
+                const subdirs = readdirSync(join(srcDir, dir), { withFileTypes: true })
+                    .filter(d => d.isDirectory())
+                    .map(d => d.name);
+                subdirs.forEach(name => { if (!moduleNames.includes(name))
+                    moduleNames.push(name); });
+                break;
+            }
+        }
+    }
+    // nest-cli.json at root
+    if (existsSync(join(rootDir, 'nest-cli.json'))) {
+        modularScore += 20;
+        evidence.push('nest-cli.json found');
+    }
+    // Classify
+    let type = 'monolithic';
+    let confidence = 0.6;
+    if (microScore >= 40) {
+        type = 'microservices';
+        confidence = Math.min(0.5 + microScore / 100, 0.98);
+    }
+    else if (modularScore >= 35) {
+        type = 'modular-monolithic';
+        confidence = Math.min(0.5 + modularScore / 100, 0.95);
+    }
+    if (evidence.length === 0) {
+        evidence.push('Single package.json, flat route structure');
+    }
+    return { type, confidence, evidence, moduleNames, servicePaths };
+}
+function findSiblingPackages(rootDir) {
+    const results = [];
+    try {
+        const entries = readdirSync(rootDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (['node_modules', '.git', 'dist', '.next', 'build'].includes(entry.name))
+                continue;
+            const pkgPath = join(rootDir, entry.name, 'package.json');
+            if (existsSync(pkgPath)) {
+                results.push(`./${entry.name}`);
+            }
+        }
+    }
+    catch { }
+    return results;
+}
+function findFilesRecursive(dir, suffix, maxDepth = 6, depth = 0) {
+    if (depth > maxDepth)
+        return [];
+    const results = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'node_modules' || entry.name === 'dist')
+                continue;
+            if (entry.isDirectory()) {
+                results.push(...findFilesRecursive(join(dir, entry.name), suffix, maxDepth, depth + 1));
+            }
+            else if (entry.isFile() && entry.name.endsWith(suffix)) {
+                results.push(join(dir, entry.name));
+            }
+        }
+    }
+    catch { }
+    return results;
+}