@cmflow/atlas 3.4.0-beta.22 → 3.4.0-beta.24

package/dist/{routeBackendTopologyService-CQyRyoSN.mjs → routeBackendTopologyService-NPO-ZHyY.mjs}

@@ -1,7 +1,7 @@
 import { fileURLToPath as __atlasFileURLToPath } from "node:url";
 const __filename = __atlasFileURLToPath(import.meta.url);
 import { n as __require, r as __toESM, t as __commonJSMin } from "./rolldown-runtime-CGR6nZuH.mjs";
-import { t as taskProgressService, u as getUserConfig } from "./taskProgressService-CAC_RIoa.mjs";
+import { d as setUserConfig, f as userConfig, t as taskProgressService, u as getUserConfig } from "./taskProgressService-BRoIJQbK.mjs";
 import { on, once } from "node:events";
 import { execFile } from "node:child_process";
 import path from "node:path";
@@ -8078,7 +8078,7 @@ function isExcludedAnalysisFile(repoRoot, filePath, excludedPatterns) {
 //#region src/services/analysisFileService.ts
 function shouldKeepAnalysisFile(filePath) {
 	const config = getUserConfig();
-	return !isExcludedAnalysisFile(config.repoRoot, filePath, config.analysis.excluded);
+	return !isExcludedAnalysisFile(process.cwd(), filePath, config.analysis.excluded);
 }
 function filterAnalysisFiles(filePaths) {
 	return filePaths.filter(shouldKeepAnalysisFile);
@@ -8384,6 +8384,7 @@ function callableFromTopologyNode(cwd, project, node) {
 	} : void 0;
 }
 function collectBackendTopologyMappingContext(params) {
+	const workspaceRoot = params.workspaceRoot || params.cwd;
 	const handlerDeclaration = findLocalCallable(params.handlerFile, params.handlerName);
 	if (!handlerDeclaration) return [];
 	const handler = {
@@ -8408,15 +8409,15 @@ function collectBackendTopologyMappingContext(params) {
 			layer,
 			direction,
 			symbol: callable.declaration?.getSymbol()?.getName() || callable.symbol.split(".").at(-1),
-			source: normalizeSourcePath(params.cwd, callable.sourceFile.getFilePath()),
+			source: normalizeSourcePath(workspaceRoot, callable.sourceFile.getFilePath()),
 			line: callableLine(callable),
 			backend_path: backendPath,
 			backend_type: backendType
 		});
-		const expectedLayerPath = layer === "api" ? "app/_api/" : "app/_infra/back/";
+		const expectedLayerPath = layer === "api" ? "_api/" : "_infra/back/";
 		for (const call of callableCalls(callable)) {
 			const dependency = resolveReference(params.project, callable.sourceFile, call.getExpression(), params.resolvePath);
-			if (!dependency?.declaration || !normalizeSourcePath(params.cwd, dependency.sourceFile.getFilePath()).includes(expectedLayerPath)) continue;
+			if (!dependency?.declaration || !normalizeSourcePath(workspaceRoot, dependency.sourceFile.getFilePath()).includes(expectedLayerPath)) continue;
 			appendMapper(dependency, layer, direction, backendPath, backendType);
 		}
 	};
@@ -8432,7 +8433,7 @@ function collectBackendTopologyMappingContext(params) {
 	for (const [backendPath, topologyPath] of params.backendPaths.entries()) {
 		appendMapperCalls(handler, "api", backendPath, topologyPath.backend_type);
 		for (const node of topologyPath.nodes) {
-			if (!node.source.includes("app/_infra/back/")) continue;
+			if (!node.source.includes("_infra/back/")) continue;
 			const callable = callableFromTopologyNode(params.cwd, params.project, node);
 			if (callable) appendMapperCalls(callable, "backend", backendPath, topologyPath.backend_type);
 		}
@@ -8448,6 +8449,7 @@ function collectBackendTopologyMappingContext(params) {
 	].join(":"), context])).values()];
 }
 function traceBackendPaths(params) {
+	const workspaceRoot = params.workspaceRoot || params.cwd;
 	const handlerDeclaration = findLocalCallable(params.handlerFile, params.handlerName);
 	if (!handlerDeclaration) throw new Error(`Handler declaration not found: ${params.handlerName} in ${params.handlerFile.getFilePath()}`);
 	const handler = {
@@ -8461,7 +8463,7 @@ function traceBackendPaths(params) {
 		weight: 0,
 		nodes: [{
 			symbol: handler.symbol,
-			source: normalizeSourcePath(params.cwd, handler.sourceFile.getFilePath()),
+			source: normalizeSourcePath(workspaceRoot, handler.sourceFile.getFilePath()),
 			line: callableLine(handler),
 			depth: 0
 		}],
@@ -8484,7 +8486,7 @@ function traceBackendPaths(params) {
 			const backendType = inferBackendNameFromFile(resolved.sourceFile) || void 0;
 			const node = {
 				symbol: resolved.symbol,
-				source: normalizeSourcePath(params.cwd, resolved.sourceFile.getFilePath()),
+				source: normalizeSourcePath(workspaceRoot, resolved.sourceFile.getFilePath()),
 				line: callableLine(resolved),
 				depth: totalWeight,
 				backend_type: backendType
@@ -8493,7 +8495,7 @@ function traceBackendPaths(params) {
 				type: reference.type,
 				from: current.callable.symbol,
 				to: resolved.symbol,
-				source: normalizeSourcePath(params.cwd, current.callable.sourceFile.getFilePath()),
+				source: normalizeSourcePath(workspaceRoot, current.callable.sourceFile.getFilePath()),
 				line: call.getStartLineNumber(),
 				weight
 			};
@@ -8597,7 +8599,8 @@ async function collectBackendTopologyDependencyFiles(project, entryFilePath, res
 	return [...visited];
 }
 async function generateBackendTopologyArtifacts(params) {
-	const resolvePath = (sourceFilePath, moduleSpecifier) => resolveModulePath(sourceFilePath, moduleSpecifier, getUserConfig().resolver.alias, params.cwd);
+	const workspaceRoot = process.cwd();
+	const resolvePath = (sourceFilePath, moduleSpecifier) => resolveModulePath(sourceFilePath, moduleSpecifier, getUserConfig().resolver.alias, process.cwd());
 	const project = new Project({
 		skipAddingFilesFromTsConfig: true,
 		compilerOptions: {
@@ -8608,7 +8611,7 @@ async function generateBackendTopologyArtifacts(params) {
 		}
 	});
 	taskProgressService.report("Discovering route files");
-	const routeFiles = await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
+	const routeFiles = await globby(["_api/**/routes.@(js|ts)", "legacy/**/routes.@(js|ts)"], {
 		cwd: params.cwd,
 		absolute: true
 	});
@@ -8649,6 +8652,7 @@ async function generateBackendTopologyArtifacts(params) {
 		if (!params.onRouteProgress) taskProgressService.log(`${route.method} ${route.path} ... Tracing callable paths`);
 		const backendPaths = traceBackendPaths({
 			cwd: params.cwd,
+			workspaceRoot,
 			project,
 			handlerFile: handler.sourceFile,
 			handlerName: handler.symbol,
@@ -8656,6 +8660,7 @@ async function generateBackendTopologyArtifacts(params) {
 		});
 		const mappingContext = collectBackendTopologyMappingContext({
 			cwd: params.cwd,
+			workspaceRoot,
 			project,
 			handlerFile: handler.sourceFile,
 			handlerName: handler.symbol,
@@ -8669,14 +8674,14 @@ async function generateBackendTopologyArtifacts(params) {
 			route: {
 				method: route.method,
 				path: route.path,
-				source: normalizeSourcePath(params.cwd, route.sourceFile.getFilePath()),
+				source: normalizeSourcePath(workspaceRoot, route.sourceFile.getFilePath()),
 				handler: {
 					symbol: handler.symbol,
-					source: normalizeSourcePath(params.cwd, handler.sourceFile.getFilePath()),
+					source: normalizeSourcePath(workspaceRoot, handler.sourceFile.getFilePath()),
 					line: callableLine(handler)
 				}
 			},
-			analysis_files: [.../* @__PURE__ */ new Set([...dependencyFiles.map((filePath) => normalizeSourcePath(params.cwd, filePath)), ...backendPaths.flatMap((backendPath) => backendPath.nodes.map((node) => node.source))])].sort(),
+			analysis_files: [.../* @__PURE__ */ new Set([...dependencyFiles.map((filePath) => normalizeSourcePath(workspaceRoot, filePath)), ...backendPaths.flatMap((backendPath) => backendPath.nodes.map((node) => node.source))])].sort(),
 			mapping_context: mappingContext,
 			weights: backendTopologyWeights,
 			backend_paths: backendPaths
@@ -8695,7 +8700,7 @@ async function discoverBackendTopologyRouteSelectors(cwd) {
 			checkJs: false
 		}
 	});
-	return (await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
+	return (await globby(["_api/**/routes.@(js|ts)", "legacy/**/routes.@(js|ts)"], {
 		cwd,
 		absolute: true
 	})).flatMap((routeFile) => extractRouteDeclarations(project.addSourceFileAtPath(routeFile))).map((route) => ({
@@ -8703,6 +8708,9 @@ async function discoverBackendTopologyRouteSelectors(cwd) {
 		path: route.path
 	}));
 }
+async function initializeTopologyWorkerConfig(configPath, cwd) {
+	setUserConfig(await userConfig(configPath, cwd));
+}
 async function generateBackendTopologyArtifactsInWorkers(params) {
 	const selectors = params.routeSelector ? [params.routeSelector] : await discoverBackendTopologyRouteSelectors(params.cwd);
 	params.onRoutesDiscovered?.(selectors.length);
@@ -8719,7 +8727,8 @@ async function generateBackendTopologyArtifactsInWorkers(params) {
 			const worker = new Worker(new URL(workerFile, import.meta.url), {
 				workerData: {
 					cwd: params.cwd,
-					routeSelectors
+					routeSelectors,
+					configPath: getUserConfig().configPath
 				},
 				execArgv: process.execArgv
 			});
@@ -8756,5 +8765,5 @@ async function generateBackendTopologyArtifactsInWorkers(params) {
 }
 
 //#endregion
-export { inferBackendNameFromFile as a, shouldKeepAnalysisFile as c, resolveModulePath as i, normalizeFilePath as l, generateBackendTopologyArtifactsInWorkers as n, isKnownBackendType as o, matchesRouteSelector as r, filterAnalysisFiles as s, generateBackendTopologyArtifacts as t, globby as u };
-//# sourceMappingURL=routeBackendTopologyService-CQyRyoSN.mjs.map
+export { resolveModulePath as a, filterAnalysisFiles as c, globby as d, matchesRouteSelector as i, shouldKeepAnalysisFile as l, generateBackendTopologyArtifactsInWorkers as n, inferBackendNameFromFile as o, initializeTopologyWorkerConfig as r, isKnownBackendType as s, generateBackendTopologyArtifacts as t, normalizeFilePath as u };
+//# sourceMappingURL=routeBackendTopologyService-NPO-ZHyY.mjs.map