next-arch-map 0.1.30 → 0.1.31

package/dist/analyzers/endpointsToDb.js

@@ -1,11 +1,12 @@
 import path from "node:path";
 import ts from "typescript";
-import { buildDbNode, buildEdgeKey, buildEndpointNode, buildHandlerNode, ensureNode, getEndpointRouteFromFile, getExistingDirectories, getSourceFile, isIgnoredSourceFile, isRouteHandlerFile, resolveLocalModulePath, resolveProjectRoot, walkDirectory, } from "../utils.js";
+import { buildDbNode, buildEdgeKey, buildEndpointNode, buildHandlerNode, ensureNode, getEndpointRouteFromFile, getExistingDirectories, getSourceFile, isIgnoredSourceFile, isRouteHandlerFile, loadPathAliases, resolveLocalModulePath, resolveProjectRoot, walkDirectory, } from "../utils.js";
 const DEFAULT_API_DIRS = ["app", "src/app", "app/api", "src/app/api", "src/server", "src/api"];
 const DEFAULT_DB_CLIENT_IDENTIFIERS = ["prisma"];
 const ROUTE_METHOD_EXPORTS = new Set(["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]);
 export async function analyzeEndpointsToDb(options) {
     const projectRoot = resolveProjectRoot(options.projectRoot);
+    const aliases = loadPathAliases(projectRoot);
     const scanRoots = getExistingDirectories(projectRoot, options.apiDirs ?? DEFAULT_API_DIRS);
     const dbClientIdentifiers = new Set(options.dbClientIdentifiers ?? DEFAULT_DB_CLIENT_IDENTIFIERS);
     const nodes = [];
@@ -25,7 +26,7 @@ export async function analyzeEndpointsToDb(options) {
             seenRouteFiles.add(filePath);
             try {
                 const endpointPath = getEndpointRouteFromFile(scanRoot, filePath);
-                const { availableMethods, dbUsageByModel } = analyzeEndpoint(filePath, projectRoot, moduleCache, sourceFileCache, dbClientIdentifiers);
+                const { availableMethods, dbUsageByModel } = analyzeEndpoint(filePath, projectRoot, aliases, moduleCache, sourceFileCache, dbClientIdentifiers);
                 const endpointNode = ensureNode(nodes, nodeIds, buildEndpointNode(endpointPath, filePath));
                 const handlerMethods = availableMethods.size > 0 ? [...availableMethods] : [undefined];
                 for (const methodName of handlerMethods) {
@@ -70,9 +71,10 @@ export async function analyzeEndpointsToDb(options) {
             left.to.localeCompare(right.to)),
     };
 }
-function analyzeEndpoint(routeFilePath, projectRoot, moduleCache, sourceFileCache, dbClientIdentifiers) {
+function analyzeEndpoint(routeFilePath, projectRoot, aliases, moduleCache, sourceFileCache, dbClientIdentifiers) {
     const state = {
         projectRoot,
+        aliases,
         moduleCache,
         sourceFileCache,
         visitedDeclarationKeys: new Set(),
@@ -273,7 +275,7 @@ function getModuleInfo(filePath, state) {
             continue;
         }
         if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
-            const resolvedImportPath = resolveLocalModulePath(filePath, statement.moduleSpecifier.text, state.projectRoot);
+            const resolvedImportPath = resolveLocalModulePath(filePath, statement.moduleSpecifier.text, state.projectRoot, state.aliases);
             if (!resolvedImportPath || !statement.importClause) {
                 continue;
             }
@@ -298,7 +300,7 @@ function getModuleInfo(filePath, state) {
             statement.exportClause &&
             ts.isNamedExports(statement.exportClause)) {
             const resolvedModulePath = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
-                ? resolveLocalModulePath(filePath, statement.moduleSpecifier.text, state.projectRoot)
+                ? resolveLocalModulePath(filePath, statement.moduleSpecifier.text, state.projectRoot, state.aliases)
                 : null;
             for (const element of statement.exportClause.elements) {
                 const exportName = element.name.text;

package/dist/analyzers/pagesToEndpoints.js

@@ -1,6 +1,6 @@
 import path from "node:path";
 import ts from "typescript";
-import { buildActionNode, buildEdgeKey, buildEndpointNode, buildPageNode, buildServiceNode, collectStringConstants, ensureNode, getExistingDirectories, getPageRouteFromFile, getSourceFile, getStringLiteralValue, isIgnoredSourceFile, isPageFile, resolveLocalModulePath, resolveProjectRoot, walkDirectory, } from "../utils.js";
+import { buildActionNode, buildEdgeKey, buildEndpointNode, buildPageNode, buildServiceNode, collectStringConstants, ensureNode, getExistingDirectories, getPageRouteFromFile, getSourceFile, getStringLiteralValue, isIgnoredSourceFile, isPageFile, loadPathAliases, resolveLocalModulePath, resolveProjectRoot, walkDirectory, } from "../utils.js";
 const DEFAULT_APP_DIRS = ["app", "src/app"];
 const DEFAULT_EXTRA_SCAN_DIRS = ["src/features", "src/services", "src/lib", "src/hooks"];
 const DEFAULT_HTTP_CLIENT_IDENTIFIERS = ["fetch", "axios", "apiClient"];
@@ -8,6 +8,7 @@ const DEFAULT_HTTP_CLIENT_METHODS = ["get", "post", "put", "patch", "delete", "h
 const DEFAULT_SDK_CLIENT_IDENTIFIERS = ["supabase"];
 export async function analyzePagesToEndpoints(options) {
     const projectRoot = resolveProjectRoot(options.projectRoot);
+    const aliases = loadPathAliases(projectRoot);
     const appDirs = getExistingDirectories(projectRoot, options.appDirs ?? DEFAULT_APP_DIRS);
     if (appDirs.length === 0) {
         throw new Error("Could not find an app/ or src/app/ directory.");
@@ -44,7 +45,7 @@ export async function analyzePagesToEndpoints(options) {
                 }
                 // For page files, follow imports transitively to find HTTP calls
                 // in hooks, utilities, and other local modules.
-                const httpCalls = collectHttpCallsTransitively(filePath, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache);
+                const httpCalls = collectHttpCallsTransitively(filePath, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache, aliases);
                 const route = getPageRouteFromFile(appDir, filePath);
                 ensureNode(nodes, nodeIds, buildPageNode(route, filePath));
                 for (const call of httpCalls) {
@@ -152,7 +153,7 @@ function collectImportSpecifiers(sourceFile) {
     }
     return specifiers;
 }
-function collectHttpCallsTransitively(filePath, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache, visited) {
+function collectHttpCallsTransitively(filePath, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache, aliases, visited) {
     const resolvedPath = path.resolve(filePath);
     const seen = visited ?? new Set();
     if (seen.has(resolvedPath)) {
@@ -165,11 +166,11 @@ function collectHttpCallsTransitively(filePath, projectRoot, httpClientIdentifie
     }
     const calls = collectHttpCalls(sourceFile, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers);
     for (const specifier of collectImportSpecifiers(sourceFile)) {
-        const resolved = resolveLocalModulePath(filePath, specifier, projectRoot);
+        const resolved = resolveLocalModulePath(filePath, specifier, projectRoot, aliases);
         if (!resolved) {
             continue;
         }
-        const transitiveCalls = collectHttpCallsTransitively(resolved, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache, seen);
+        const transitiveCalls = collectHttpCallsTransitively(resolved, projectRoot, httpClientIdentifiers, httpClientMethods, sdkClientIdentifiers, sourceFileCache, aliases, seen);
         calls.push(...transitiveCalls);
     }
     return calls;

package/dist/analyzers/prismaSchema.js

@@ -1,18 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 const MODEL_BLOCK_PATTERN = /^model\s+(\w+)\s*\{/;
-const ENUM_BLOCK_PATTERN = /^enum\s+(\w+)\s*\{/;
-const SCALAR_TYPES = new Set([
-    "String",
-    "Int",
-    "Float",
-    "Boolean",
-    "DateTime",
-    "Json",
-    "Bytes",
-    "Decimal",
-    "BigInt",
-]);
 export async function analyzePrismaSchema(projectRoot) {
     const schemaPath = path.join(projectRoot, "prisma", "schema.prisma");
     if (!fs.existsSync(schemaPath)) {
@@ -26,7 +14,6 @@ export async function analyzePrismaSchema(projectRoot) {
         return { nodes: [], edges: [] };
     }
     const models = parseModels(content);
-    const enumNames = parseEnumNames(content);
     const nodes = [];
     const edges = [];
     const edgeKeys = new Set();
@@ -78,22 +65,10 @@ export async function analyzePrismaSchema(projectRoot) {
         edges: edges.sort((a, b) => a.kind.localeCompare(b.kind) || a.from.localeCompare(b.from) || a.to.localeCompare(b.to)),
     };
 }
-function parseEnumNames(content) {
-    const names = new Set();
-    const lines = content.split("\n");
-    for (const line of lines) {
-        const match = ENUM_BLOCK_PATTERN.exec(line.trim());
-        if (match) {
-            names.add(match[1]);
-        }
-    }
-    return names;
-}
 function parseModels(content) {
     const models = [];
     const lines = content.split("\n");
     const modelNames = new Set();
-    const enumNames = parseEnumNames(content);
     // First pass: collect all model names
     for (const line of lines) {
         const match = MODEL_BLOCK_PATTERN.exec(line.trim());
@@ -129,7 +104,7 @@ function parseModels(content) {
         if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@@")) {
             continue;
         }
-        const field = parseField(trimmed, modelNames, enumNames);
+        const field = parseField(trimmed, modelNames);
         if (!field) {
             continue;
         }
@@ -145,7 +120,7 @@ function parseModels(content) {
     }
     return models;
 }
-function parseField(line, modelNames, enumNames) {
+function parseField(line, modelNames) {
     // Tokenize: split on whitespace but respect parentheses content
     const tokens = tokenizeLine(line);
     if (tokens.length < 2) {

package/dist/serve.js

@@ -140,9 +140,14 @@ export async function serve(options) {
         }
     });
     const server = http.createServer((req, res) => {
-        res.setHeader("Access-Control-Allow-Origin", "*");
+        const origin = req.headers.origin ?? "";
+        const isLocalOrigin = /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/.test(origin);
+        if (isLocalOrigin) {
+            res.setHeader("Access-Control-Allow-Origin", origin);
+        }
         res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
         res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        res.setHeader("Vary", "Origin");
         if (req.method === "OPTIONS") {
             res.statusCode = 204;
             res.end();
@@ -217,7 +222,7 @@ export async function serve(options) {
     });
     await new Promise((resolve, reject) => {
         server.once("error", reject);
-        server.listen(port, () => {
+        server.listen(port, "127.0.0.1", () => {
             server.off("error", reject);
             console.log(`next-arch-map serve listening on http://localhost:${port}`);
             resolve();

package/dist/utils.d.ts

@@ -13,7 +13,12 @@ export declare function getPageRouteFromFile(appDir: string, filePath: string):
 export declare function getEndpointRouteFromFile(scanRoot: string, filePath: string): string;
 export declare function getScriptKind(filePath: string): ts.ScriptKind;
 export declare function getSourceFile(filePath: string, sourceFileCache?: Map<string, ts.SourceFile>): ts.SourceFile | null;
-export declare function resolveLocalModulePath(importerFilePath: string, specifier: string, projectRoot: string): string | null;
+export type PathAlias = {
+    prefix: string;
+    replacement: string;
+};
+export declare function loadPathAliases(projectRoot: string): PathAlias[];
+export declare function resolveLocalModulePath(importerFilePath: string, specifier: string, projectRoot: string, aliases?: PathAlias[]): string | null;
 export declare function ensureDirectory(directoryPath: string): void;
 export declare function readJsonFile<T>(filePath: string): T;
 export declare function writeJsonFile(filePath: string, value: unknown): void;

package/dist/utils.js

@@ -126,12 +126,62 @@ export function getSourceFile(filePath, sourceFileCache) {
         return null;
     }
 }
-export function resolveLocalModulePath(importerFilePath, specifier, projectRoot) {
+export function loadPathAliases(projectRoot) {
+    for (const configName of ["tsconfig.json", "jsconfig.json"]) {
+        const configPath = path.join(projectRoot, configName);
+        if (!fileExists(configPath)) {
+            continue;
+        }
+        try {
+            const raw = fs.readFileSync(configPath, "utf8");
+            // Strip single-line comments (tsconfig allows them) before parsing
+            const stripped = raw.replace(/\/\/.*$/gm, "");
+            const config = JSON.parse(stripped);
+            const baseUrl = config.compilerOptions?.baseUrl ?? ".";
+            const paths = config.compilerOptions?.paths;
+            if (!paths) {
+                break;
+            }
+            const aliases = [];
+            for (const [pattern, targets] of Object.entries(paths)) {
+                if (!pattern.endsWith("/*") || targets.length === 0) {
+                    continue;
+                }
+                const target = targets[0];
+                if (!target.endsWith("/*")) {
+                    continue;
+                }
+                const prefix = pattern.slice(0, -1); // "@/*" → "@/"
+                const targetDir = target.slice(0, -2); // "./src/*" → "./src"
+                const replacement = path.resolve(projectRoot, baseUrl, targetDir);
+                aliases.push({ prefix, replacement });
+            }
+            // Sort longest prefix first so more specific aliases match first
+            aliases.sort((a, b) => b.prefix.length - a.prefix.length);
+            return aliases;
+        }
+        catch {
+            break;
+        }
+    }
+    // Fallback: default @/ → src/ for projects without tsconfig paths
+    return [{ prefix: "@/", replacement: path.join(projectRoot, "src") }];
+}
+export function resolveLocalModulePath(importerFilePath, specifier, projectRoot, aliases) {
     let basePath = null;
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
         basePath = path.resolve(path.dirname(importerFilePath), specifier);
     }
+    else if (aliases) {
+        for (const alias of aliases) {
+            if (specifier.startsWith(alias.prefix)) {
+                basePath = path.join(alias.replacement, specifier.slice(alias.prefix.length));
+                break;
+            }
+        }
+    }
     else if (specifier.startsWith("@/")) {
+        // Legacy fallback when no aliases provided
         basePath = path.join(projectRoot, "src", specifier.slice(2));
     }
     if (!basePath) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-arch-map",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "description": "Static analyzer that builds a multi-layer architecture graph for Next.js-style apps.",
   "type": "module",
   "bin": {