@cmflow/atlas 3.4.0-beta.7 → 3.4.0-beta.9

package/README.md

@@ -59,11 +59,175 @@ export default defineConfig({
 });
 ```
 
-Atlas reads `compilerOptions.paths` from the project's `tsconfig.json` and uses them as module aliases. Add `resolver.alias` only to override or complement those aliases.
+Atlas reads `compilerOptions.paths` from the `tsconfig.json` in the directory where the command is run (`process.cwd()`) and uses them as module aliases. `repoRoot` only defines the source tree to analyze and may therefore point to a subdirectory. Add `resolver.alias` only to override or complement those aliases.
+
+## Backend sources
+
+Atlas extracts a candidate mapping from code, then optionally consolidates it against a strict backend field reference. Configure these references in the same `analysis.backends` list used to declare backends.
+
+A backend can be either a string or a `BackendSource` created with `defineBackendSource`:
+
+- a string (for example `"ICC"`) has no field reference; Atlas keeps the current code-analysis and optional inference flow;
+- a `BackendSource` provides a `resolve` function that returns the backend's known properties. Atlas assigns its `name` as `backend` on every resolved property.
+
+When a string and a source share the same name, the last declaration wins. This lets a source enrich a list of backend names, for example `[..., Object.values(BackendTypes), quableBackendSource]`.
+
+The resolver returns one of the following shapes. Document-oriented backends have no route; REST backends have no document.
+
+```ts
+type BackendProperty =
+  | {
+      document: string;
+      field: string;
+      description?: string;
+    }
+  | {
+      route: string;
+      method: string;
+      field: string;
+      description?: string;
+    };
+```
+
+The generated mapping preserves this shape. In particular, `document` is a separate property: Atlas does not turn a Quable field into an artificial path such as `products.product_geographical_area`.
+
+### Quable
+
+Attach rules that are specific to Quable directly to its source. They inherit the source backend automatically and their candidates are validated by the Quable property list.
+
+```ts
+import { defineBackendSource, httpClient, quableI18nFieldRule } from "@cmflow/atlas";
+
+export const quable = defineBackendSource({
+  name: "QUABLE",
+  rules: [quableI18nFieldRule],
+  resolve: async () => {
+    const documentTypes = await httpClient.get<QuableDocumentType[]>("https://quable.example/document-types");
+
+    return documentTypes.flatMap((document) =>
+      document.properties.map((property) => ({
+        document: document.code,
+        field: property.code,
+        description: "récupéré via le backend resolver"
+      }))
+    );
+  }
+});
+```
+
+For example, the resolver above may return:
+
+```ts
+{
+  backend: "QUABLE",
+  document: "products",
+  field: "product_geographical_area",
+  description: "récupéré via le backend resolver"
+}
+```
+
+### CMS Directus
+
+CMS Directus follows the same document-oriented contract. Its `cmsI18nFieldRule` is owned by the CMS source rather than registered as a global expression rule.
+
+```ts
+import { defineBackendSource, cmsI18nFieldRule } from "@cmflow/atlas";
+
+export const cmsDirectus = defineBackendSource({
+  name: "CMS",
+  rules: [cmsI18nFieldRule],
+  resolve: async () => directusResolver.listProperties()
+});
+```
+
+`directusResolver.listProperties()` returns items such as `{ document: "offers", field: "title", description: "…" }`.
+
+### CMS Legacy
+
+CMS Legacy is configured identically, with its own resolver and backend identifier. It may reuse `cmsI18nFieldRule` when the backend uses `CmsI18n` helpers.
+
+```ts
+import { defineBackendSource, cmsI18nFieldRule } from "@cmflow/atlas";
+
+export const cmsLegacy = defineBackendSource({
+  name: "CMS_LEGACY",
+  rules: [cmsI18nFieldRule],
+  resolve: async () => cmsLegacyResolver.listProperties()
+});
+```
+
+### Custom REST backend with OpenAPI
+
+`openapiSource` reuses Atlas's OpenAPI parsing utilities: downloading the document, resolving references, traversing operations, and extracting field descriptions. A project therefore only supplies the URL.
+
+```ts
+import { constant, defineBackendSource, openapiSource } from "@cmflow/atlas";
+
+export const xm = defineBackendSource({
+  name: "XM",
+  resolve: () =>
+    openapiSource({
+      url: constant<string>("XM_API_URL", "https://xm.example/openapi.json")
+    })
+});
+```
+
+`constant` resolves an environment variable directly from `process.env`, falling back to its second argument. No resolver context is required.
+
+### Environment constants
+
+Use `constant` when a backend source needs a configurable value such as a URL or an access token. The value is resolved when the source runs:
+
+1. Atlas uses `process.env[name]` when it is set.
+2. Otherwise, it returns the supplied default value.
+
+```ts
+import { constant, defineBackendSource, openapiSource } from "@cmflow/atlas";
+
+export const xmBackendSource = defineBackendSource({
+  name: "XM",
+  resolve: () =>
+    openapiSource({
+      url: constant<string>("XM_API_URL", "https://xm.example/openapi.json")
+    })
+});
+```
+
+For example, override the default in CI or locally:
+
+```bash
+XM_API_URL=https://xm.internal/openapi.json atlas backend-sources --backend XM
+```
+
+This returns entries such as:
+
+```ts
+{
+  backend: "XM",
+  route: "/path/to",
+  method: "GET",
+  field: "path.to.field",
+  description: "Description extraite du Swagger"
+}
+```
+
+Register strings and sources together:
+
+```ts
+import { defineConfig } from "@cmflow/atlas";
+import { cmsDirectus, cmsLegacy, quable, xm } from "./backend-sources";
+
+export default defineConfig({
+  // …other Atlas options
+  analysis: {
+    backends: ["ICC", quable, cmsDirectus, cmsLegacy, xm]
+  }
+});
+```
 
 ## Custom expression rules
 
-Use `defineExpressionRule` when a project-specific helper hides a backend field or wraps an expression that Atlas should follow. Add the rule to `analysis.rules` in `atlas.config.ts`.
+Use `defineExpressionRule` when a project-specific helper hides a backend field or wraps an expression that Atlas should follow. Add a cross-backend rule to `analysis.rules` in `atlas.config.ts`. Attach a backend-specific rule, such as `quableI18nFieldRule` or `cmsI18nFieldRule`, to `defineBackendSource({ rules: [...] })` instead.
 
 `match` is a cheap predicate that selects the `ts-morph` expression. `parse` returns the information Atlas should use: a backend field, a transparent wrapper, or both.
 
@@ -73,8 +237,7 @@ import { Node } from "ts-morph";
 
 const localizedFieldRule = defineExpressionRule({
   name: "localized-field",
-  match: (expression) =>
-    Node.isCallExpression(expression) && expression.getExpression().getText() === "localizedField",
+  match: (expression) => Node.isCallExpression(expression) && expression.getExpression().getText() === "localizedField",
   parse: (expression) => {
     if (!Node.isCallExpression(expression)) return undefined;
 
@@ -151,6 +314,7 @@ Without `--write`, the command performs a dry run. Use `clean-orphans` to inspec
 
 ```text
 atlas init                         Create atlas.config.ts
+atlas backend-sources              Execute backend sources and display resolved metadata
 atlas generate:graph               Trace API routes to backends
 atlas generate:catalog [route]     Generate route review documents
 atlas generate:test                Check configured coverage baselines

package/dist/bin/atlas.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
-import { a as isKnownBackendType, c as taskProgressService, d as setUserConfig, i as inferBackendNameFromFile, l as getUserConfig, n as generateBackendTopologyArtifactsInWorkers, o as filterAnalysisFiles, r as resolveModulePath, s as shouldKeepAnalysisFile, u as loadAtlasConfig } from "../routeBackendTopologyService-D_aIIBbX.mjs";
+import { a as isKnownBackendType, c as taskProgressService, d as setUserConfig, i as inferBackendNameFromFile, l as getUserConfig, n as generateBackendTopologyArtifactsInWorkers, o as filterAnalysisFiles, r as resolveModulePath, s as shouldKeepAnalysisFile, u as loadAtlasConfig } from "../routeBackendTopologyService-DElirHSh.mjs";
 import { Command, InvalidArgumentError, Option } from "commander";
 import path from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
-import { cancel, intro, log, note, outro, progress } from "@clack/prompts";
+import { cancel, intro, isCancel, log, note, outro, progress, select } from "@clack/prompts";
 import fs from "node:fs/promises";
 import { createDirectus, createItem, deleteItem, readItems, rest, staticToken, updateItem } from "@directus/sdk";
 import { globby } from "globby";
@@ -48,16 +48,16 @@ function getAggregationTarget(call) {
 	let current = call;
 	while (current) {
 		const parent = current.getParent();
-		if (!parent) return void 0;
+		if (!parent) return;
 		if (Node.isVariableDeclaration(parent)) return normalizeCodeText(parent.getName());
 		if (Node.isReturnStatement(parent)) return "return";
-		if (Node.isStatement(parent)) return void 0;
+		if (Node.isStatement(parent)) return;
 		current = parent;
 	}
 }
 function getAggregationCondition(call) {
 	const callback = call.getArguments().find((argument) => Node.isArrowFunction(argument) || Node.isFunctionExpression(argument));
-	if (!callback || !Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) return void 0;
+	if (!callback || !Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) return;
 	const body = callback.getBody();
 	if (!Node.isBlock(body)) return normalizeCodeText(body.getText());
 	const condition = body.getDescendantsOfKind(SyntaxKind.IfStatement)[0]?.getExpression();
@@ -135,29 +135,80 @@ var AnalysisCacheService = class {
 };
 const analysisCacheService = new AnalysisCacheService();
 //#endregion
-//#region src/services/openapi/downloadService.ts
-async function downloadOpenApiDocument(url, timeoutMs = getUserConfig().openapiTimeoutMs) {
-	const response = await fetch(url, {
-		headers: { accept: "application/json" },
-		signal: AbortSignal.timeout(timeoutMs)
+//#region src/services/backendPropertyService.ts
+const propertiesBySource = /* @__PURE__ */ new WeakMap();
+async function resolveBackendProperties(sources) {
+	const resolved = await Promise.all(sources.map(async (source) => {
+		if (!source.resolve) return [source.name, void 0];
+		let properties = propertiesBySource.get(source);
+		if (!properties) {
+			properties = source.resolve().then((result) => result.map((property) => ({
+				...property,
+				backend: source.name
+			})));
+			propertiesBySource.set(source, properties);
+		}
+		return [source.name, await properties];
+	}));
+	return new Map(resolved.filter((entry) => entry[1] !== void 0).map(([backend, properties]) => [backend, properties]));
+}
+function matchBackendProperty(field, properties) {
+	if (!properties) return;
+	const normalized = normalizeField(field);
+	return properties.find((property) => {
+		const reference = normalizeField(property.field);
+		return normalized === reference || normalized.endsWith(reference) || reference.endsWith(normalized);
 	});
-	if (!response.ok) throw new Error(`Unable to fetch OpenAPI document from ${url}: ${response.status} ${response.statusText}`);
-	const reader = response.body?.getReader();
-	if (!reader) return response.json();
-	const decoder = new TextDecoder();
-	let content = "";
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		content += decoder.decode(value, { stream: true });
-		taskProgressService.log(`Downloading (${(content.length / 1048576).toFixed(1)} MB)`);
-	}
-	taskProgressService.log("Parsing document");
-	return JSON.parse(content + decoder.decode());
 }
+function normalizeField(value) {
+	return value.replace(/\[locale\]/g, "").replace(/\[\]/g, "").replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+}
+//#endregion
+//#region src/services/http/httpClient.ts
+var HttpClient = class {
+	async fetch(url, init) {
+		const headers = {
+			accept: "application/json",
+			...init?.headers
+		};
+		const response = await fetch(url, {
+			...init,
+			headers
+		});
+		if (!response.ok) throw new Error(`Unable to fetch ${url}: ${response.status} ${response.statusText}`);
+		if (init?.onProgress) {
+			const reader = response.body?.getReader();
+			if (!reader) return response.json();
+			const decoder = new TextDecoder();
+			let content = "";
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				content += decoder.decode(value, { stream: true });
+				init.onProgress(content);
+			}
+			return content + decoder.decode();
+		}
+		return response;
+	}
+	async get(url, init) {
+		return (await this.fetch(url, init)).json();
+	}
+};
+const httpClient = new HttpClient();
+//#endregion
+//#region src/services/openapi/loadOpenApiDocument.ts
 async function loadOpenApiDocument(url, timeoutMs) {
 	try {
-		return await downloadOpenApiDocument(url, timeoutMs);
+		const content = await httpClient.fetch(url, {
+			signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : void 0,
+			onProgress(content) {
+				taskProgressService.log(`Downloading (${(content.length / 1048576).toFixed(1)} MB)`);
+			}
+		});
+		if (!content || typeof content === "object") return content;
+		taskProgressService.log("Parsing document");
+		return JSON.parse(content);
 	} catch (error) {
 		if (error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError")) throw new Error(`OpenAPI download timed out after ${timeoutMs}ms: ${url}`);
 		throw new Error(`Unable to fetch OpenAPI document from ${url}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1188,6 +1239,7 @@ async function collectDependencyFiles(project, entryFilePath, routeLabel, resolv
 }
 async function analyzeCodebaseRouteContracts(params) {
 	const { cwd, openApiDocument: swagger, selectedRouteKeys, routeContracts, onDocument, routeAnalysisScope } = params;
+	const backendProperties = await resolveBackendProperties(userConfig.analysis.backends);
 	taskProgressService.log("Discovering route files");
 	const routeFiles = await globby(["app/_api/**/routes.@(js|ts)", "app/legacy/**/routes.@(js|ts)"], {
 		cwd,
@@ -1277,7 +1329,15 @@ async function analyzeCodebaseRouteContracts(params) {
 		}), (item) => `${item.backend}:${item.method}:${item.route}:${item.sourceFile}`);
 		const backendGraphKey = `${backendSourceFiles.map((file) => file.getFilePath()).sort().join("|")}::${[...reachableBackendFunctionNames].sort().join("|")}`;
 		const backendFieldCandidates = backendFieldsByGraph.get(backendGraphKey) || (() => {
-			const candidates = extractRouteBackendFieldCandidates(backendSourceFiles, reachableBackendFunctionNames, [...apiSourceFiles, ...useCaseSourceFiles]);
+			const candidates = extractRouteBackendFieldCandidates(backendSourceFiles, reachableBackendFunctionNames, [...apiSourceFiles, ...useCaseSourceFiles]).flatMap((candidate) => {
+				const properties = backendProperties.get(candidate.backend);
+				if (!properties) return [candidate];
+				const resolvedProperty = matchBackendProperty(candidate.backendField, properties);
+				return resolvedProperty ? [{
+					...candidate,
+					resolvedProperty
+				}] : [];
+			});
 			backendFieldsByGraph.set(backendGraphKey, candidates);
 			return candidates;
 		})();
@@ -1426,6 +1486,31 @@ function resolveBackendRouteCandidate(document, match) {
 	const sameBackendCandidates = document.backendRouteCandidates.filter((candidate) => candidate.backend === match.backend);
 	return sameBackendCandidates.find((candidate) => candidate.sourceFile === match.sourceFile) || sameBackendCandidates[0];
 }
+function toBackendMapping(document, match) {
+	const resolved = match.resolvedProperty;
+	if (resolved && "document" in resolved) return {
+		backend: match.backend,
+		document: resolved.document,
+		field: resolved.field,
+		description: resolved.description,
+		source_file: backendFieldSource(match),
+		confidence: match.confidence,
+		mapper_type: match.mapperType,
+		reason: match.reviewReason
+	};
+	const backendRouteCandidate = resolved && "route" in resolved ? resolved : resolveBackendRouteCandidate(document, match);
+	return {
+		backend: match.backend,
+		method: backendRouteCandidate?.method || null,
+		route: backendRouteCandidate?.route || "unknown",
+		field: resolved?.field || match.backendField,
+		description: resolved?.description,
+		source_file: backendFieldSource(match),
+		confidence: match.confidence,
+		mapper_type: match.mapperType,
+		reason: match.reviewReason
+	};
+}
 async function buildCatalogue(documents) {
 	const routes = documents.map((document) => ({
 		key: document.key,
@@ -1467,19 +1552,7 @@ async function buildCatalogue(documents) {
 			const backendNames = dedupeByKey(matches.map((candidate) => candidate.backend), (value) => value);
 			const isTransverseWithoutMapping = isTransversalInput(property) && !matches.length;
 			const evidenceStatus = isTransverseWithoutMapping ? "confirmed" : evidenceStatusFromCandidates(matches);
-			const backendMappings = dedupeByKey(matches.map((match) => {
-				const backendRouteCandidate = resolveBackendRouteCandidate(document, match);
-				return {
-					backend: match.backend,
-					method: backendRouteCandidate?.method || null,
-					route: backendRouteCandidate?.route || "unknown",
-					field: match.backendField,
-					source_file: backendFieldSource(match),
-					confidence: match.confidence,
-					mapper_type: match.mapperType,
-					reason: match.reviewReason
-				};
-			}), (mapping) => `${mapping.backend}:${mapping.method || "CALL"}:${mapping.route}:${mapping.field}:${mapping.source_file}`);
+			const backendMappings = dedupeByKey(matches.map((match) => toBackendMapping(document, match)), (mapping) => `${mapping.backend}:${mapping.document || ""}:${mapping.method || "CALL"}:${mapping.route || ""}:${mapping.field}:${mapping.source_file}`);
 			routeInputProperties.push({
 				key: apiPropertyKey,
 				route_key: document.key,
@@ -1510,12 +1583,14 @@ async function buildCatalogue(documents) {
 					route: "unknown",
 					sourceFile: match.sourceFile
 				}).key;
-				const backendPropertyKey = stableKey$2(backendRouteKey, "input", match.backendField);
+				const backendPropertyKey = stableKey$2(backendRouteKey, "input", match.resolvedProperty?.field || match.backendField);
 				backendPropertiesByKey.set(backendPropertyKey, {
 					key: backendPropertyKey,
 					backend_route_key: backendRouteKey,
 					backend: match.backend,
-					field: match.backendField,
+					field: match.resolvedProperty?.field || match.backendField,
+					document: match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0,
+					description: match.resolvedProperty?.description,
 					direction: "input",
 					source_file: backendFieldSource(match),
 					provenance: "code_analysis"
@@ -1539,19 +1614,7 @@ async function buildCatalogue(documents) {
 			const apiPropertyKey = stableKey$2(document.key, "output", property.path);
 			const backendNames = dedupeByKey(matches.map((candidate) => candidate.backend), (value) => value);
 			const evidenceStatus = evidenceStatusFromCandidates(matches);
-			const backendMappings = dedupeByKey(matches.map((match) => {
-				const backendRouteCandidate = resolveBackendRouteCandidate(document, match);
-				return {
-					backend: match.backend,
-					method: backendRouteCandidate?.method || null,
-					route: backendRouteCandidate?.route || "unknown",
-					field: match.backendField,
-					source_file: backendFieldSource(match),
-					confidence: match.confidence,
-					mapper_type: match.mapperType,
-					reason: match.reviewReason
-				};
-			}), (mapping) => `${mapping.backend}:${mapping.method || "CALL"}:${mapping.route}:${mapping.field}:${mapping.source_file}`);
+			const backendMappings = dedupeByKey(matches.map((match) => toBackendMapping(document, match)), (mapping) => `${mapping.backend}:${mapping.document || ""}:${mapping.method || "CALL"}:${mapping.route || ""}:${mapping.field}:${mapping.source_file}`);
 			routeOutputProperties.push({
 				key: apiPropertyKey,
 				route_key: document.key,
@@ -1582,12 +1645,14 @@ async function buildCatalogue(documents) {
 					route: "unknown",
 					sourceFile: match.sourceFile
 				}).key;
-				const backendPropertyKey = stableKey$2(backendRouteKey, "output", match.backendField);
+				const backendPropertyKey = stableKey$2(backendRouteKey, "output", match.resolvedProperty?.field || match.backendField);
 				backendPropertiesByKey.set(backendPropertyKey, {
 					key: backendPropertyKey,
 					backend_route_key: backendRouteKey,
 					backend: match.backend,
-					field: match.backendField,
+					field: match.resolvedProperty?.field || match.backendField,
+					document: match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0,
+					description: match.resolvedProperty?.description,
 					direction: "output",
 					source_file: backendFieldSource(match),
 					provenance: "code_analysis"
@@ -1631,7 +1696,7 @@ async function buildCatalogue(documents) {
 	};
 }
 //#endregion
-//#region src/services/directusSyncService.ts
+//#region src/services/directus/directusSyncService.ts
 const ROUTE_STATUSES = { published: "published" };
 const LOCAL_SOURCE_FILE = "digital-api:tools/datasource-catalogue";
 const DIRECTUS_RETRY_MAX_ATTEMPTS = 6;
@@ -2167,10 +2232,10 @@ async function pushCatalogueToDirectus(catalogue, options) {
 	const removedOrphanedLinks = await cleanupOrphanedPropertyLinks(client);
 	taskProgressService.report("Finalizing Directus synchronization");
 	if (warnings.size) {
-		console.warn("========================================");
-		console.warn("BIG WARNING: missing predefined values or unresolved Directus links");
-		for (const warning of warnings) console.warn(`- ${warning}`);
-		console.warn("========================================");
+		taskProgressService.log("========================================");
+		taskProgressService.log("BIG WARNING: missing predefined values or unresolved Directus links");
+		for (const warning of warnings) taskProgressService.log(`- ${warning}`);
+		taskProgressService.log("========================================");
 	}
 	return {
 		pushedCollections,
@@ -2210,9 +2275,11 @@ function buildReviewProperty(property) {
 	const backends = property.backend_mappings.map((mapping) => ({
 		type: mapping.backend,
 		field: mapping.field,
+		document: mapping.document,
+		description: mapping.description,
 		source: mapping.source_file,
-		...mapping.route !== "unknown" || mapping.method ? { operation: {
-			method: mapping.method,
+		...mapping.route && (mapping.route !== "unknown" || mapping.method) ? { operation: {
+			method: mapping.method || null,
 			route: mapping.route
 		} } : {},
 		confidence: mapping.confidence,
@@ -2384,16 +2451,17 @@ async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.
 	};
 }
 function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backendRoutesByKey, backendPropertiesByKey, mappingEvidence) {
-	const backendRouteKey = stableKey$1(routeKey, mapping.backend, mapping.route);
-	const backendRoute = backendRoutesByKey.get(backendRouteKey) || {
+	const backendRoute = mapping.route || (mapping.document ? `DOCUMENT ${mapping.document}` : "unknown");
+	const backendRouteKey = stableKey$1(routeKey, mapping.backend, backendRoute);
+	const backendRouteRecord = backendRoutesByKey.get(backendRouteKey) || {
 		key: backendRouteKey,
 		backend: mapping.backend,
 		route_key: routeKey,
-		route: `${mapping.method || "CALL"} ${mapping.route}`,
+		route: `${mapping.method || "CALL"} ${backendRoute}`,
 		source_file: mapping.source_file,
 		provenance: "code_analysis"
 	};
-	backendRoutesByKey.set(backendRouteKey, backendRoute);
+	backendRoutesByKey.set(backendRouteKey, backendRouteRecord);
 	const backendPropertyKey = stableKey$1(backendRouteKey, direction, mapping.field);
 	backendPropertiesByKey.set(backendPropertyKey, {
 		key: backendPropertyKey,
@@ -2419,8 +2487,10 @@ function toCatalogueBackendMapping(mapping) {
 	return {
 		backend: mapping.type,
 		method: mapping.operation?.method || null,
-		route: mapping.operation?.route || "unknown",
+		...mapping.operation?.route ? { route: mapping.operation.route } : {},
 		field: mapping.field,
+		document: mapping.document,
+		description: mapping.description,
 		source_file: mapping.source,
 		confidence: mapping.confidence,
 		mapper_type: mapping.mapper_type,
@@ -2559,7 +2629,7 @@ async function readCatalogueFromDirectory(inputDir) {
 	};
 }
 //#endregion
-//#region src/services/directusPushService.ts
+//#region src/services/directus/directusPushService.ts
 async function pushCatalogueDirectoryToDirectus(params) {
 	const inputPath = path.resolve(params.cwd, params.catalogueDirectory);
 	taskProgressService.report("Loading and reconstructing route YAML documents");
@@ -2728,6 +2798,44 @@ var cleanOrphans_default = (program) => void program.command("clean-orphans").op
 	}
 });
 //#endregion
+//#region src/commands/backendSources.ts
+async function listBackendSourceMetadata(sources, backend) {
+	const resolvableSources = sources.filter((source) => Boolean(source.resolve));
+	const selectedSources = backend ? resolvableSources.filter((source) => source.name === backend) : resolvableSources;
+	if (backend && !selectedSources.length) throw new Error(`Unknown backend source with a resolver: ${backend}`);
+	if (!backend && !selectedSources.length) throw new Error("No backend source with a resolver is configured");
+	const propertiesByBackend = await resolveBackendProperties(selectedSources);
+	return selectedSources.map((source) => ({
+		backend: source.name,
+		properties: propertiesByBackend.get(source.name) || []
+	}));
+}
+var backendSources_default = (program) => void program.command("backend-sources").option("--backend <name>", "Only execute one backend source").description("Execute configured backend sources and display their resolved property metadata").action(async (options) => {
+	intro("Atlas backend source metadata");
+	try {
+		const sources = getUserConfig().analysis.backends.filter((source) => Boolean(source.resolve));
+		const selectedBackend = options.backend || await select({
+			message: "Which backend source do you want to execute?",
+			options: sources.map((source) => ({
+				value: source.name,
+				label: source.name,
+				hint: "resolver configured"
+			}))
+		});
+		if (isCancel(selectedBackend)) {
+			cancel("Backend source execution cancelled");
+			process.exitCode = 1;
+			return;
+		}
+		const metadata = await listBackendSourceMetadata(sources, selectedBackend);
+		log.message(JSON.stringify(metadata, null, 2));
+		outro("Backend source metadata generated");
+	} catch (error) {
+		cancel(error instanceof Error ? error.message : String(error));
+		process.exitCode = 1;
+	}
+});
+//#endregion
 //#region src/services/analysisProfileService.ts
 function createAnalysisProfile(enabled) {
 	const durations = /* @__PURE__ */ new Map();
@@ -3042,7 +3150,7 @@ var generateTest_default = (program) => void program.command("generate:test").de
 	}
 });
 //#endregion
-//#region src/services/aiSdkClient.ts
+//#region src/services/ai/aiSdkClient.ts
 var AISdkClient = class {
 	#config;
 	constructor(config) {
@@ -3073,7 +3181,7 @@ var AISdkClient = class {
 	}
 };
 //#endregion
-//#region src/services/inferenceService.ts
+//#region src/services/ai/inferenceService.ts
 const MAPPING_OUTPUT_SCHEMA = z.object({ mappings: z.array(z.object({
 	property_index: z.number().int(),
 	candidate_index: z.number().int(),
@@ -4209,6 +4317,7 @@ program.name("atlas").description("Manage the API-to-backend mapping catalogue")
 	setUserConfig(config);
 });
 init_default(program, program);
+backendSources_default(program);
 generate_default(program);
 generateGraph_default(program);
 generateTest_default(program);

package/dist/defineExpressionRule-Dfvzj6n2.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"defineExpressionRule-Dfvzj6n2.mjs","names":[],"sources":["../src/utils/defineExpressionRule.ts"],"sourcesContent":["import type { Expression } from \"ts-morph\";\nimport type { UserConfig } from \"../models/types\";\n\nexport type FieldExtractionRuleResult = {\n  backendField?: string;\n  transparent?: boolean;\n  mapperType?: string;\n  apiMapping?: boolean;\n};\n\nexport type FieldExtractionRule = {\n  name: string;\n  match: (expression: Expression, config: UserConfig) => boolean;\n  parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;\n};\n\nexport function defineExpressionRule(rule: FieldExtractionRule): FieldExtractionRule {\n  return rule;\n}\n"],"mappings":"AAgBA,SAAgB,EAAqB,EAAgD,CACnF,OAAO,CACT"}
+{"version":3,"file":"defineExpressionRule-Dfvzj6n2.mjs","names":[],"sources":["../src/utils/defineExpressionRule.ts"],"sourcesContent":["import type { Expression } from \"ts-morph\";\nimport type { UserConfig } from \"../models/types\";\n\nexport type FieldExtractionRuleResult = {\n  backendField?: string;\n  transparent?: boolean;\n  mapperType?: string;\n  apiMapping?: boolean;\n};\n\nexport type FieldExtractionRule = {\n  name: string;\n  /** Higher-priority rules are evaluated first. Defaults to 0. */\n  priority?: number;\n  match: (expression: Expression, config: UserConfig) => boolean;\n  parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;\n};\n\nexport function defineExpressionRule(rule: FieldExtractionRule): FieldExtractionRule {\n  return rule;\n}\n"],"mappings":"AAkBA,SAAgB,EAAqB,EAAgD,CACnF,OAAO,CACT"}

package/dist/index.d.mts

@@ -1,6 +1,36 @@
-import { r as defineExpressionRule, t as UserConfig } from "./types-3y34Gf8R.mjs";
+import { a as defineExpressionRule, n as BackendSource, r as UserConfig, t as BackendProperty } from "./types-cYprdLUO.mjs";
+import { cmsI18nFieldRule } from "./rules/cmsI18nFieldRule.mjs";
+import { quableI18nFieldRule } from "./rules/quableI18nFieldRule.mjs";
 //#region src/utils/defineConfig.d.ts
 declare function defineConfig(config: UserConfig): UserConfig;
 //#endregion
-export { type UserConfig, defineConfig, defineExpressionRule };
+//#region src/utils/defineBackendSource.d.ts
+declare function defineBackendSource(source: BackendSource): BackendSource;
+//#endregion
+//#region src/utils/constant.d.ts
+/**
+ * Resolves an environment variable, falling back to the supplied default value.
+ *
+ * This is intended for values declared directly in an Atlas configuration, such
+ * as URLs or tokens used by a backend source.
+ */
+declare function constant<T extends string = string>(name: string, defaultValue: T): string;
+//#endregion
+//#region src/services/http/httpClient.d.ts
+declare class HttpClient {
+  fetch(url: string, init: RequestInit & {
+    onProgress: (content: string) => void;
+  }): Promise<string | unknown>;
+  fetch(url: string, init?: RequestInit): Promise<Response>;
+  get<T>(url: string, init?: RequestInit): Promise<T>;
+}
+declare const httpClient: HttpClient;
+//#endregion
+//#region src/services/openapi/openapiSource.d.ts
+declare function openapiSource(params: {
+  url: string;
+  timeoutMs?: number;
+}): Promise<BackendProperty[]>;
+//#endregion
+export { type BackendProperty, type BackendSource, type UserConfig, cmsI18nFieldRule, constant, defineBackendSource, defineConfig, defineExpressionRule, httpClient, openapiSource, quableI18nFieldRule };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import{t as e}from"./defineExpressionRule-Dfvzj6n2.mjs";function t(e){return e}export{t as defineConfig,e as defineExpressionRule};
+import{t as e}from"./defineExpressionRule-Dfvzj6n2.mjs";import{cmsI18nFieldRule as t}from"./rules/cmsI18nFieldRule.mjs";import{quableI18nFieldRule as n}from"./rules/quableI18nFieldRule.mjs";import{AsyncLocalStorage as r}from"node:async_hooks";import{spinner as i}from"@clack/prompts";function a(e){return e}function o(e){return e}function s(e,t){return process.env[e]??t}const c=new class{async fetch(e,t){let n={accept:`application/json`,...t?.headers},r=await fetch(e,{...t,headers:n});if(!r.ok)throw Error(`Unable to fetch ${e}: ${r.status} ${r.statusText}`);if(t?.onProgress){let e=r.body?.getReader();if(!e)return r.json();let n=new TextDecoder,i=``;for(;;){let{done:r,value:a}=await e.read();if(r)break;i+=n.decode(a,{stream:!0}),t.onProgress(i)}return i+n.decode()}return r}async get(e,t){return(await this.fetch(e,t)).json()}};function l(e){return e<1e3?`${e}ms`:`${(e/1e3).toFixed(1)}s`}const u=new class{#e=new r;attach(e,t){return this.#e.run(e,t)}log(e){this.#e.getStore()?.log(e)}report(e){let t=this.#e.getStore();(t?.report||t?.log)?.(e)}createStepProgress(e=e=>({id:e,title:e})){let t=i(),n,r=e=>{if(!n)return;let r=l(Date.now()-n.startedAt);t.stop(`${e||n.completedTitle||`${n.title} completed`} (${r})`),n=void 0},a=e=>{if(n?.id===e.id){t.message(e.detail?`${e.title}: ${e.detail}`:e.title);return}r(),n={id:e.id,title:e.title,completedTitle:e.completedTitle,startedAt:Date.now()},t.start(e.detail?`${e.title}: ${e.detail}`:e.title)},o=r=>this.attach({log:e=>t.message(n?`${n.title}: ${e}`:e),report:t=>a(e(t))},r);return{report(t){a(e(t))},start:a,execute:o,run:async(e,t)=>{a(e),await new Promise(e=>setImmediate(e));let n=await o(t);return r(),n},finish(e){r(e)},fail(e){if(!n)return;let r=l(Date.now()-n.startedAt);t.stop(`${e} (${r})`),n=void 0}}}};async function d(e,t){try{let n=await c.fetch(e,{signal:t?AbortSignal.timeout(t):void 0,onProgress(e){u.log(`Downloading (${(e.length/1048576).toFixed(1)} MB)`)}});return!n||typeof n==`object`?n:(u.log(`Parsing document`),JSON.parse(n))}catch(n){throw n instanceof Error&&(n.name===`AbortError`||n.name===`TimeoutError`)?Error(`OpenAPI download timed out after ${t}ms: ${e}`):Error(`Unable to fetch OpenAPI document from ${e}: ${n instanceof Error?n.message:String(n)}`)}}function f(e,t){if(!e||typeof e!=`object`||typeof e.$ref!=`string`||!e.$ref.startsWith(`#/`))return e;let n=t;for(let t of e.$ref.replace(`#/`,``).split(`/`).map(e=>e.replace(/~1/g,`/`).replace(/~0/g,`~`)))if(n=n?.[t],n===void 0)return e;return n}function p(e){return/^\d+$/.test(e)&&Number(e)>=200&&Number(e)<=299}function m(e,t){if(!e||typeof e!=`object`)return;if(e[`application/json`]?.schema)return f(e[`application/json`].schema,t);let n=Object.values(e).find(e=>e?.schema);return n?f(n.schema,t):void 0}function h(e,t,n=``){let r=f(e,t);if(!r||typeof r!=`object`)return[];if(Array.isArray(r.allOf))return r.allOf.flatMap(e=>h(e,t,n));if(r.type===`array`||r.items){let e=n?`${n}[]`:`[]`;return h(r.items,t,e)}let i=r.properties||{};return Object.keys(i).length?Object.entries(i).flatMap(([e,r])=>h(r,t,n?`${n}.${e}`:e)):n?[{path:n,description:r.description,deprecated:r.deprecated}]:[]}function g(e){return e===`query`?`QUERY`:e===`path`?`PATH`:e===`header`?`HEADER`:null}function _(e,t){let n=new Map,r=Array.isArray(e.parameters)?e.parameters:[];for(let e of r){let r=f(e,t),i=g(r?.in);if(!r||!i||!r.name)continue;let a=h(r.schema,t,r.name),o=a.length?a:[{path:r.name,description:r.description,deprecated:r.deprecated}];for(let e of o)n.set(`${i}:${e.path}`,{path:e.path,description:e.description||r.description,deprecated:e.deprecated??r.deprecated??!1,type:i})}let i=f(e.requestBody,t);if(i?.content){let e=m(i.content,t);for(let r of h(e,t))n.set(`BODY:${r.path}`,{path:r.path,description:r.description||i.description,deprecated:r.deprecated??!1,type:`BODY`})}return[...n.values()]}function v(e,t){let n=new Map,r=e?.responses||{};for(let[e,i]of Object.entries(r)){if(!p(e))continue;let r=f(i,t),a=m(r?.content,t);for(let e of h(a,t))n.set(e.path,{path:e.path,description:e.description||r?.description,deprecated:e.deprecated??!1,type:`RESPONSE_BODY`})}return[...n.values()]}function y(e){let t=new Map;for(let[n,r]of Object.entries(e.paths||{}))for(let[i,a]of Object.entries(r||{})){if(!/^(get|post|put|patch|delete|head|options)$/i.test(i))continue;let r=i.toUpperCase();for(let i of[..._(a,e),...v(a,e)]){let e=`${r}:${n}:${i.path}`;t.has(e)||t.set(e,{route:n,method:r,field:i.path,description:i.description})}}return[...t.values()]}async function b(e){return y(await d(e.url,e.timeoutMs))}export{t as cmsI18nFieldRule,s as constant,o as defineBackendSource,a as defineConfig,e as defineExpressionRule,c as httpClient,b as openapiSource,n as quableI18nFieldRule};
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/utils/defineConfig.ts"],"sourcesContent":["import type { UserConfig } from \"../models/types\";\n\nexport function defineConfig(config: UserConfig): UserConfig {\n  return config;\n}\n"],"mappings":"wDAEA,SAAgB,EAAa,EAAgC,CAC3D,OAAO,CACT"}
+{"version":3,"file":"index.mjs","names":["#storage"],"sources":["../src/utils/defineConfig.ts","../src/utils/defineBackendSource.ts","../src/utils/constant.ts","../src/services/http/httpClient.ts","../src/services/tasks/taskProgressService.ts","../src/services/openapi/loadOpenApiDocument.ts","../src/services/openapi/schemaService.ts","../src/services/openapi/propertyExtractionService.ts","../src/services/openapi/openapiSource.ts"],"sourcesContent":["import type { UserConfig } from \"../models/types\";\n\nexport function defineConfig(config: UserConfig): UserConfig {\n  return config;\n}\n","import type { BackendSource } from \"../models/types\";\n\nexport function defineBackendSource(source: BackendSource): BackendSource {\n  return source;\n}\n","/**\n * Resolves an environment variable, falling back to the supplied default value.\n *\n * This is intended for values declared directly in an Atlas configuration, such\n * as URLs or tokens used by a backend source.\n */\nexport function constant<T extends string = string>(name: string, defaultValue: T): string {\n  return process.env[name] ?? defaultValue;\n}\n","class HttpClient {\n  async fetch(url: string, init: RequestInit & { onProgress: (content: string) => void }): Promise<string | unknown>;\n  async fetch(url: string, init?: RequestInit): Promise<Response>;\n  async fetch(url: string, init?: RequestInit & { onProgress?: (content: string) => void }): Promise<Response | string | unknown> {\n    const headers = { accept: \"application/json\", ...init?.headers };\n\n    const response = await fetch(url, {\n      ...init,\n      headers\n    });\n\n    if (!response.ok) {\n      throw new Error(`Unable to fetch ${url}: ${response.status} ${response.statusText}`);\n    }\n\n    if (init?.onProgress) {\n      const reader = response.body?.getReader();\n\n      if (!reader) {\n        return response.json() as unknown;\n      }\n\n      const decoder = new TextDecoder();\n      let content = \"\";\n\n      while (true) {\n        const { done, value } = await reader.read();\n        if (done) {\n          break;\n        }\n\n        content += decoder.decode(value, { stream: true });\n\n        init.onProgress(content);\n      }\n\n      return content + decoder.decode();\n    }\n\n    return response;\n  }\n\n  async get<T>(url: string, init?: RequestInit): Promise<T> {\n    const response = await this.fetch(url, init);\n    return response.json() as Promise<T>;\n  }\n}\n\nexport const httpClient = new HttpClient();\n","import { AsyncLocalStorage } from \"node:async_hooks\";\nimport { spinner } from \"@clack/prompts\";\n\nexport type StepDescriptor = {\n  id: string;\n  title: string;\n  completedTitle?: string;\n  detail?: string;\n};\n\ntype TaskProgressSink = {\n  log: (message: string) => void;\n  report?: (message: string) => void;\n};\n\nfunction formatDuration(durationMs: number): string {\n  if (durationMs < 1_000) {\n    return `${durationMs}ms`;\n  }\n  return `${(durationMs / 1_000).toFixed(1)}s`;\n}\n\nclass TaskProgressService {\n  readonly #storage = new AsyncLocalStorage<TaskProgressSink>();\n\n  attach<T>(sink: TaskProgressSink, task: () => Promise<T>): Promise<T> {\n    return this.#storage.run(sink, task);\n  }\n\n  log(message: string): void {\n    this.#storage.getStore()?.log(message);\n  }\n\n  report(message: string): void {\n    const sink = this.#storage.getStore();\n    const reporter = sink?.report || sink?.log;\n    reporter?.(message);\n  }\n\n  createStepProgress(classify: (message: string) => StepDescriptor = (message) => ({ id: message, title: message })) {\n    const progress = spinner();\n    let active: { id: string; title: string; completedTitle?: string; startedAt: number } | undefined;\n\n    const finishActive = (label?: string) => {\n      if (!active) {\n        return;\n      }\n      const duration = formatDuration(Date.now() - active.startedAt);\n      progress.stop(`${label || active.completedTitle || `${active.title} completed`} (${duration})`);\n      active = undefined;\n    };\n\n    const start = (step: StepDescriptor) => {\n      if (active?.id === step.id) {\n        progress.message(step.detail ? `${step.title}: ${step.detail}` : step.title);\n        return;\n      }\n\n      finishActive();\n      active = {\n        id: step.id,\n        title: step.title,\n        completedTitle: step.completedTitle,\n        startedAt: Date.now()\n      };\n      progress.start(step.detail ? `${step.title}: ${step.detail}` : step.title);\n    };\n\n    const execute = <T>(task: () => Promise<T>): Promise<T> =>\n      this.attach(\n        {\n          log: (message) => progress.message(active ? `${active.title}: ${message}` : message),\n          report: (message) => start(classify(message))\n        },\n        task\n      );\n\n    return {\n      report(message: string) {\n        start(classify(message));\n      },\n      start,\n      execute,\n      run: async <T>(step: StepDescriptor, task: () => Promise<T>): Promise<T> => {\n        start(step);\n        await new Promise<void>((resolve) => setImmediate(resolve));\n        const result = await execute(task);\n        finishActive();\n        return result;\n      },\n      finish(label?: string) {\n        finishActive(label);\n      },\n      fail(label: string) {\n        if (!active) {\n          return;\n        }\n        const duration = formatDuration(Date.now() - active.startedAt);\n        progress.stop(`${label} (${duration})`);\n        active = undefined;\n      }\n    };\n  }\n}\n\nexport const taskProgressService = new TaskProgressService();\n","import { httpClient } from \"../http/httpClient\";\nimport { taskProgressService } from \"../tasks/taskProgressService\";\n\nexport type OpenApiDocument = {\n  info?: { version?: string };\n  paths?: Record<string, Record<string, any>>;\n  components?: Record<string, any>;\n};\n\nexport async function loadOpenApiDocument(url: string, timeoutMs?: number): Promise<OpenApiDocument> {\n  try {\n    const content = await httpClient.fetch(url, {\n      signal: timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined,\n      onProgress(content) {\n        taskProgressService.log(`Downloading (${(content.length / 1_048_576).toFixed(1)} MB)`);\n      }\n    });\n\n    if (!content || typeof content === \"object\") {\n      return content as OpenApiDocument;\n    }\n\n    taskProgressService.log(\"Parsing document\");\n\n    return JSON.parse(content as string) as OpenApiDocument;\n  } catch (error) {\n    if (error instanceof Error && (error.name === \"AbortError\" || error.name === \"TimeoutError\")) {\n      throw new Error(`OpenAPI download timed out after ${timeoutMs}ms: ${url}`);\n    }\n\n    throw new Error(`Unable to fetch OpenAPI document from ${url}: ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n","import type { OpenApiDocument } from \"./loadOpenApiDocument\";\n\nexport function resolveOpenApiReference(value: any, swagger: OpenApiDocument): any {\n  if (!value || typeof value !== \"object\" || typeof value.$ref !== \"string\" || !value.$ref.startsWith(\"#/\")) {\n    return value;\n  }\n  let current: any = swagger;\n  for (const segment of value.$ref\n    .replace(\"#/\", \"\")\n    .split(\"/\")\n    .map((part: string) => part.replace(/~1/g, \"/\").replace(/~0/g, \"~\"))) {\n    current = current?.[segment];\n    if (current === undefined) {\n      return value;\n    }\n  }\n  return current;\n}\n","import type { BackendProperty, ExtractedApiProperty } from \"../../models/types\";\nimport type { OpenApiDocument } from \"./loadOpenApiDocument\";\nimport { resolveOpenApiReference } from \"./schemaService\";\n\ntype OpenApiLeafProperty = {\n  path: string;\n  description?: string;\n  deprecated?: boolean;\n};\n\nfunction isSuccessStatusCode(statusCode: string): boolean {\n  return /^\\d+$/.test(statusCode) && Number(statusCode) >= 200 && Number(statusCode) <= 299;\n}\n\nfunction selectPreferredSchema(content: any, swagger: OpenApiDocument): any {\n  if (!content || typeof content !== \"object\") {\n    return undefined;\n  }\n\n  if (content[\"application/json\"]?.schema) {\n    return resolveOpenApiReference(content[\"application/json\"].schema, swagger);\n  }\n\n  const firstSchema = Object.values(content).find((entry: any) => entry?.schema) as any;\n  return firstSchema ? resolveOpenApiReference(firstSchema.schema, swagger) : undefined;\n}\n\nfunction extractLeafProperties(schema: any, swagger: OpenApiDocument, currentPath = \"\"): OpenApiLeafProperty[] {\n  const resolvedSchema = resolveOpenApiReference(schema, swagger);\n\n  if (!resolvedSchema || typeof resolvedSchema !== \"object\") {\n    return [];\n  }\n\n  if (Array.isArray(resolvedSchema.allOf)) {\n    return resolvedSchema.allOf.flatMap((item: any) => extractLeafProperties(item, swagger, currentPath));\n  }\n\n  if (resolvedSchema.type === \"array\" || resolvedSchema.items) {\n    const arrayPath = currentPath ? `${currentPath}[]` : \"[]\";\n    return extractLeafProperties(resolvedSchema.items, swagger, arrayPath);\n  }\n\n  const properties = resolvedSchema.properties || {};\n  if (!Object.keys(properties).length) {\n    return currentPath\n      ? [\n          {\n            path: currentPath,\n            description: resolvedSchema.description,\n            deprecated: resolvedSchema.deprecated\n          }\n        ]\n      : [];\n  }\n\n  return Object.entries(properties).flatMap(([propertyName, propertySchema]: [string, any]) => {\n    const nextPath = currentPath ? `${currentPath}.${propertyName}` : propertyName;\n    return extractLeafProperties(propertySchema, swagger, nextPath);\n  });\n}\n\nfunction mapInputType(inType?: string): ExtractedApiProperty[\"type\"] | null {\n  if (inType === \"query\") {\n    return \"QUERY\";\n  }\n  if (inType === \"path\") {\n    return \"PATH\";\n  }\n  if (inType === \"header\") {\n    return \"HEADER\";\n  }\n  return null;\n}\n\nexport function extractOpenApiInputProperties(operation: any, swagger: OpenApiDocument): ExtractedApiProperty[] {\n  const map = new Map<string, ExtractedApiProperty>();\n  const parameters = Array.isArray(operation.parameters) ? operation.parameters : [];\n\n  for (const rawParameter of parameters) {\n    const parameter = resolveOpenApiReference(rawParameter, swagger);\n    const inputType = mapInputType(parameter?.in);\n    if (!parameter || !inputType || !parameter.name) {\n      continue;\n    }\n\n    const properties = extractLeafProperties(parameter.schema, swagger, parameter.name);\n    const resolvedProperties = properties.length\n      ? properties\n      : [\n          {\n            path: parameter.name,\n            description: parameter.description,\n            deprecated: parameter.deprecated\n          }\n        ];\n\n    for (const property of resolvedProperties) {\n      map.set(`${inputType}:${property.path}`, {\n        path: property.path,\n        description: property.description || parameter.description,\n        deprecated: property.deprecated ?? parameter.deprecated ?? false,\n        type: inputType\n      });\n    }\n  }\n\n  const requestBody = resolveOpenApiReference(operation.requestBody, swagger);\n  if (requestBody?.content) {\n    const schema = selectPreferredSchema(requestBody.content, swagger);\n    for (const property of extractLeafProperties(schema, swagger)) {\n      map.set(`BODY:${property.path}`, {\n        path: property.path,\n        description: property.description || requestBody.description,\n        deprecated: property.deprecated ?? false,\n        type: \"BODY\"\n      });\n    }\n  }\n\n  return [...map.values()];\n}\n\nexport function extractOpenApiOutputProperties(operation: any, swagger: OpenApiDocument): ExtractedApiProperty[] {\n  const map = new Map<string, ExtractedApiProperty>();\n  const responses = operation?.responses || {};\n\n  for (const [statusCode, rawResponse] of Object.entries(responses)) {\n    if (!isSuccessStatusCode(statusCode)) {\n      continue;\n    }\n\n    const response = resolveOpenApiReference(rawResponse, swagger);\n    const schema = selectPreferredSchema(response?.content, swagger);\n    for (const property of extractLeafProperties(schema, swagger)) {\n      map.set(property.path, {\n        path: property.path,\n        description: property.description || response?.description,\n        deprecated: property.deprecated ?? false,\n        type: \"RESPONSE_BODY\"\n      });\n    }\n  }\n\n  return [...map.values()];\n}\n\nexport function extractOpenApiBackendProperties(swagger: OpenApiDocument): BackendProperty[] {\n  const properties = new Map<string, BackendProperty>();\n  for (const [route, pathItem] of Object.entries(swagger.paths || {})) {\n    for (const [rawMethod, operation] of Object.entries(pathItem || {})) {\n      if (!/^(get|post|put|patch|delete|head|options)$/i.test(rawMethod)) {\n        continue;\n      }\n      const method = rawMethod.toUpperCase();\n      for (const property of [\n        ...extractOpenApiInputProperties(operation, swagger),\n        ...extractOpenApiOutputProperties(operation, swagger)\n      ]) {\n        const key = `${method}:${route}:${property.path}`;\n        if (!properties.has(key)) {\n          properties.set(key, {\n            route,\n            method,\n            field: property.path,\n            description: property.description\n          });\n        }\n      }\n    }\n  }\n  return [...properties.values()];\n}\n","import type { BackendProperty } from \"../../models/types\";\nimport { loadOpenApiDocument } from \"./loadOpenApiDocument\";\nimport { extractOpenApiBackendProperties } from \"./propertyExtractionService\";\n\nexport async function openapiSource(params: { url: string; timeoutMs?: number }): Promise<BackendProperty[]> {\n  const document = await loadOpenApiDocument(params.url, params.timeoutMs);\n  return extractOpenApiBackendProperties(document);\n}\n"],"mappings":"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"}

package/dist/{routeBackendTopologyService-D_aIIBbX.mjs → routeBackendTopologyService-DElirHSh.mjs}

@@ -10,14 +10,37 @@ import { Worker } from "node:worker_threads";
 //#region src/utils/config.ts
 let _config;
 function setUserConfig(config) {
-	_config = config;
+	const backends = normalizeBackendSources(config.analysis.backends);
+	_config = {
+		...config,
+		analysis: {
+			...config.analysis,
+			backends,
+			rules: normalizeExpressionRules([...config.analysis.rules, ...backends.flatMap((backend) => backend.rules || [])])
+		}
+	};
+}
+function normalizeBackendSources(backends) {
+	const sources = backends.map((backend) => typeof backend === "string" ? { name: backend } : backend);
+	const sourcesByName = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		if (!source.name.trim()) throw new Error("Backend source names must not be empty");
+		sourcesByName.set(source.name, source);
+	}
+	return [...sourcesByName.values()];
+}
+function normalizeExpressionRules(rules) {
+	return [...new Set(rules)].map((rule, index) => ({
+		rule,
+		index
+	})).sort((left, right) => (right.rule.priority || 0) - (left.rule.priority || 0) || left.index - right.index).map(({ rule }) => rule);
 }
 function getUserConfig() {
 	if (!_config) throw new Error("Atlas config not loaded. Run Atlas from a directory containing atlas.config.ts or pass --config.");
 	return _config;
 }
-function getTsconfigAliases(repoRoot) {
-	const tsconfigPath = path.join(repoRoot, "tsconfig.json");
+function getTsconfigAliases(workingDirectory = process.cwd()) {
+	const tsconfigPath = path.join(workingDirectory, "tsconfig.json");
 	if (!fs.existsSync(tsconfigPath)) return {};
 	const paths = new Project({
 		tsConfigFilePath: tsconfigPath,
@@ -39,12 +62,17 @@ async function loadAtlasConfig(configPath, projectRoot) {
 		} else mod = await import(pathToFileURL(filePath).href);
 		const config = mod.default ?? mod;
 		const repoRoot = projectRoot || config.repoRoot || process.cwd();
+		const backends = normalizeBackendSources(config.analysis.backends);
 		return {
 			...config,
 			repoRoot,
 			cwd: repoRoot,
+			analysis: {
+				...config.analysis,
+				backends
+			},
 			resolver: { alias: {
-				...getTsconfigAliases(repoRoot),
+				...getTsconfigAliases(),
 				...config.resolver?.alias
 			} }
 		};
@@ -53,7 +81,7 @@ async function loadAtlasConfig(configPath, projectRoot) {
 	}
 }
 //#endregion
-//#region src/services/taskProgressService.ts
+//#region src/services/tasks/taskProgressService.ts
 function formatDuration(durationMs) {
 	if (durationMs < 1e3) return `${durationMs}ms`;
 	return `${(durationMs / 1e3).toFixed(1)}s`;
@@ -138,7 +166,7 @@ function filterAnalysisFiles(filePaths) {
 //#endregion
 //#region src/utils/isKnowBackendType.ts
 function isKnownBackendType(value) {
-	return getUserConfig().analysis.backends.includes(value);
+	return getUserConfig().analysis.backends.some((backend) => backend.name === value);
 }
 //#endregion
 //#region src/services/backendSourceService.ts
@@ -234,14 +262,14 @@ function findLocalCallable(sourceFile, symbol) {
 }
 function resolveSourceFile(project, owner, moduleSpecifier, resolvePath) {
 	const resolvedPath = resolvePath(owner.getFilePath(), moduleSpecifier);
-	if (!resolvedPath) return void 0;
+	if (!resolvedPath) return;
 	const existing = project.getSourceFile(resolvedPath);
 	if (existing) return existing;
 	return isFilePath(resolvedPath) ? project.addSourceFileAtPathIfExists(resolvedPath) : void 0;
 }
 function resolveExportedCallable(project, sourceFile, symbol, resolvePath, seen = /* @__PURE__ */ new Set()) {
 	const key = `${sourceFile.getFilePath()}:${symbol}`;
-	if (seen.has(key)) return void 0;
+	if (seen.has(key)) return;
 	seen.add(key);
 	const local = findLocalCallable(sourceFile, symbol);
 	if (local) return {
@@ -263,7 +291,7 @@ function resolveExportedCallable(project, sourceFile, symbol, resolvePath, seen
 }
 function resolveConstructedMember(project, sourceFile, variableName, memberName, resolvePath) {
 	const initializer = sourceFile.getVariableDeclaration(variableName)?.getInitializer();
-	if (!initializer || !Node.isNewExpression(initializer)) return void 0;
+	if (!initializer || !Node.isNewExpression(initializer)) return;
 	const constructorName = initializer.getExpression().getText();
 	const localMethod = sourceFile.getClass(constructorName)?.getInstanceMethod(memberName);
 	if (localMethod) return {
@@ -324,7 +352,7 @@ function resolveTypedPropertyMethod(project, sourceFile, expression, resolvePath
 	const receiver = expression.getExpression();
 	if (!Node.isPropertyAccessExpression(receiver) || receiver.getExpression().getText() !== "this") return;
 	const propertyType = expression.getFirstAncestorByKind(SyntaxKind.ClassDeclaration)?.getProperty(receiver.getName())?.getTypeNode()?.getText().match(/[A-Za-z_$][A-Za-z0-9_$]*/)?.[0];
-	if (!propertyType) return void 0;
+	if (!propertyType) return;
 	for (const importDeclaration of sourceFile.getImportDeclarations()) {
 		const namedImport = importDeclaration.getNamedImports().find((item) => (item.getAliasNode()?.getText() || item.getName()) === propertyType);
 		if (!namedImport) continue;
@@ -361,10 +389,10 @@ function resolveReference(project, sourceFile, expression, resolvePath) {
 	const imported = resolveImportedReference(project, sourceFile, expressionText, resolvePath);
 	if (imported) return imported;
 	const declaration = expression.getSymbol()?.getAliasedSymbol()?.getDeclarations()[0] || expression.getSymbol()?.getDeclarations()[0];
-	if (!declaration) return void 0;
+	if (!declaration) return;
 	const callable = Node.isFunctionDeclaration(declaration) || Node.isMethodDeclaration(declaration) || Node.isVariableDeclaration(declaration) ? declaration : void 0;
-	if (!callable) return void 0;
-	if (Node.isVariableDeclaration(callable) && !isCallableVariable(callable)) return void 0;
+	if (!callable) return;
+	if (Node.isVariableDeclaration(callable) && !isCallableVariable(callable)) return;
 	const targetFile = callable.getSourceFile();
 	return {
 		declaration: callable,
@@ -404,7 +432,7 @@ function mappingDirection(symbol, layer) {
 function callableFromTopologyNode(cwd, project, node) {
 	const filePath = path.resolve(cwd, node.source);
 	const sourceFile = project.getSourceFile(filePath) || project.addSourceFileAtPathIfExists(filePath);
-	if (!sourceFile) return void 0;
+	if (!sourceFile) return;
 	const declaration = [
 		...sourceFile.getFunctions(),
 		...sourceFile.getDescendantsOfKind(SyntaxKind.MethodDeclaration),
@@ -574,13 +602,13 @@ function traceBackendPaths(params) {
 }
 function stringProperty(object, name) {
 	const property = object.getProperty(name);
-	if (!property || !Node.isPropertyAssignment(property)) return void 0;
+	if (!property || !Node.isPropertyAssignment(property)) return;
 	const initializer = property.getInitializer();
 	return initializer && (Node.isStringLiteral(initializer) || Node.isNoSubstitutionTemplateLiteral(initializer)) ? initializer.getLiteralValue() : void 0;
 }
 function handlerProperty(object) {
 	const property = object.getProperty("handler");
-	if (!property || !Node.isPropertyAssignment(property)) return void 0;
+	if (!property || !Node.isPropertyAssignment(property)) return;
 	const initializer = property.getInitializer();
 	return initializer && (Node.isIdentifier(initializer) || Node.isPropertyAccessExpression(initializer)) ? initializer.getText() : void 0;
 }

package/dist/rules/cleanObjectRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/cleanObjectRule.d.ts
 declare const cleanObjectRule: FieldExtractionRule;
 //#endregion

package/dist/rules/cmsI18nFieldRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/cmsI18nFieldRule.d.ts
 /**
  * `CmsI18n#get`/`getAll` reads a localized field off the translations array passed to the

package/dist/rules/dateConversionRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/dateConversionRule.d.ts
 declare const dateConversionRule: FieldExtractionRule;
 //#endregion

package/dist/rules/lodashGetRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/lodashGetRule.d.ts
 declare const lodashGetRule: FieldExtractionRule;
 //#endregion

package/dist/rules/mappingUtilityRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/mappingUtilityRule.d.ts
 declare const mappingUtilityRule: FieldExtractionRule;
 //#endregion

package/dist/rules/mappingUtilityRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"mappingUtilityRule.mjs","names":[],"sources":["../../src/rules/mappingUtilityRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nconst mapperTypes = new Set([\"string\", \"number\", \"boolean\", \"date\", \"datetime\", \"enum\", \"array\", \"object\"]);\n\nexport const mappingUtilityRule = defineExpressionRule({\n  name: \"mapping-utility-wrapper\",\n  match: (expression, config) => {\n    if (!Node.isCallExpression(expression)) return false;\n\n    const callee = expression.getExpression().getText();\n    return config.analysis.neutralExpressionMatchers.some((matcher) => callee.startsWith(matcher.prefix));\n  },\n  parse: (expression, config) => {\n    if (!Node.isCallExpression(expression)) return undefined;\n\n    const callee = expression.getExpression().getText();\n    const matcher = config.analysis.neutralExpressionMatchers.find((item) => callee.startsWith(item.prefix));\n    const mapperType = callee.split(\".\").find((segment) => mapperTypes.has(segment));\n\n    return {\n      transparent: true,\n      mapperType,\n      apiMapping: matcher?.apiMapping ?? false\n    };\n  }\n});\n"],"mappings":"yFAGA,MAAM,EAAc,IAAI,IAAI,CAAC,SAAU,SAAU,UAAW,OAAQ,WAAY,OAAQ,QAAS,QAAQ,CAAC,EAE7F,EAAqB,EAAqB,CACrD,KAAM,0BACN,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,MAAO,GAE/C,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAClD,OAAO,EAAO,SAAS,0BAA0B,KAAM,GAAY,EAAO,WAAW,EAAQ,MAAM,CAAC,CACtG,EACA,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,OAExC,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAC5C,EAAU,EAAO,SAAS,0BAA0B,KAAM,GAAS,EAAO,WAAW,EAAK,MAAM,CAAC,EAGvG,MAAO,CACL,YAAa,GACb,WAJiB,EAAO,MAAM,GAAG,CAAC,CAAC,KAAM,GAAY,EAAY,IAAI,CAAO,CAInE,EACT,WAAY,GAAS,YAAc,EACrC,CACF,CACF,CAAC"}
+{"version":3,"file":"mappingUtilityRule.mjs","names":[],"sources":["../../src/rules/mappingUtilityRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nconst mapperTypes = new Set([\"string\", \"number\", \"boolean\", \"date\", \"datetime\", \"enum\", \"array\", \"object\"]);\n\nexport const mappingUtilityRule = defineExpressionRule({\n  name: \"mapping-utility-wrapper\",\n  match: (expression, config) => {\n    if (!Node.isCallExpression(expression)) {\n      return false;\n    }\n\n    const callee = expression.getExpression().getText();\n    return config.analysis.neutralExpressionMatchers.some((matcher) => callee.startsWith(matcher.prefix));\n  },\n  parse: (expression, config) => {\n    if (!Node.isCallExpression(expression)) {\n      return undefined;\n    }\n\n    const callee = expression.getExpression().getText();\n    const matcher = config.analysis.neutralExpressionMatchers.find((item) => callee.startsWith(item.prefix));\n    const mapperType = callee.split(\".\").find((segment) => mapperTypes.has(segment));\n\n    return {\n      transparent: true,\n      mapperType,\n      apiMapping: matcher?.apiMapping ?? false\n    };\n  }\n});\n"],"mappings":"yFAGA,MAAM,EAAc,IAAI,IAAI,CAAC,SAAU,SAAU,UAAW,OAAQ,WAAY,OAAQ,QAAS,QAAQ,CAAC,EAE7F,EAAqB,EAAqB,CACrD,KAAM,0BACN,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,MAAO,GAGT,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAClD,OAAO,EAAO,SAAS,0BAA0B,KAAM,GAAY,EAAO,WAAW,EAAQ,MAAM,CAAC,CACtG,EACA,OAAQ,EAAY,IAAW,CAC7B,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,OAGF,IAAM,EAAS,EAAW,cAAc,CAAC,CAAC,QAAQ,EAC5C,EAAU,EAAO,SAAS,0BAA0B,KAAM,GAAS,EAAO,WAAW,EAAK,MAAM,CAAC,EAGvG,MAAO,CACL,YAAa,GACb,WAJiB,EAAO,MAAM,GAAG,CAAC,CAAC,KAAM,GAAY,EAAY,IAAI,CAAO,CAInE,EACT,WAAY,GAAS,YAAc,EACrC,CACF,CACF,CAAC"}

package/dist/rules/memberGetFieldRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/memberGetFieldRule.d.ts
 declare const memberGetFieldRule: FieldExtractionRule;
 //#endregion

package/dist/rules/memberGetFieldRule.mjs

@@ -1,2 +1,2 @@
-import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`member-get-field`,match:e=>{if(!t.isCallExpression(e))return!1;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));return t.isPropertyAccessExpression(n)&&[`get`,`getAll`].includes(n.getName())&&!!r},parse:e=>{if(!t.isCallExpression(e))return;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));if(!(!t.isPropertyAccessExpression(n)||!t.isStringLiteral(r)&&!t.isNoSubstitutionTemplateLiteral(r)))return{backendField:`${n.getExpression().getText()}.${r.getLiteralValue()}`}}});export{n as memberGetFieldRule};
+import{t as e}from"../defineExpressionRule-Dfvzj6n2.mjs";import{Node as t}from"ts-morph";const n=e({name:`member-get-field`,priority:-100,match:e=>{if(!t.isCallExpression(e))return!1;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));return t.isPropertyAccessExpression(n)&&[`get`,`getAll`].includes(n.getName())&&!!r},parse:e=>{if(!t.isCallExpression(e))return;let n=e.getExpression(),r=e.getArguments().find(e=>t.isStringLiteral(e)||t.isNoSubstitutionTemplateLiteral(e));if(!(!t.isPropertyAccessExpression(n)||!t.isStringLiteral(r)&&!t.isNoSubstitutionTemplateLiteral(r)))return{backendField:`${n.getExpression().getText()}.${r.getLiteralValue()}`}}});export{n as memberGetFieldRule};
 //# sourceMappingURL=memberGetFieldRule.mjs.map

package/dist/rules/memberGetFieldRule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"memberGetFieldRule.mjs","names":[],"sources":["../../src/rules/memberGetFieldRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const memberGetFieldRule = defineExpressionRule({\n  name: \"member-get-field\",\n  match: (expression) => {\n    if (!Node.isCallExpression(expression)) return false;\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    return Node.isPropertyAccessExpression(target) && [\"get\", \"getAll\"].includes(target.getName()) && Boolean(field);\n  },\n  parse: (expression) => {\n    if (!Node.isCallExpression(expression)) return undefined;\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    if (!Node.isPropertyAccessExpression(target) || (!Node.isStringLiteral(field) && !Node.isNoSubstitutionTemplateLiteral(field))) {\n      return undefined;\n    }\n\n    return { backendField: `${target.getExpression().getText()}.${field.getLiteralValue()}` };\n  }\n});\n"],"mappings":"yFAGA,MAAa,EAAqB,EAAqB,CACrD,KAAM,mBACN,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,MAAO,GAE/C,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EACtG,OAAO,EAAK,2BAA2B,CAAM,GAAK,CAAC,MAAO,QAAQ,CAAC,CAAC,SAAS,EAAO,QAAQ,CAAC,GAAK,EAAQ,CAC5G,EACA,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EAAG,OAExC,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EAClG,MAAC,EAAK,2BAA2B,CAAM,GAAM,CAAC,EAAK,gBAAgB,CAAK,GAAK,CAAC,EAAK,gCAAgC,CAAK,GAI5H,MAAO,CAAE,aAAc,GAAG,EAAO,cAAc,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAM,gBAAgB,GAAI,CAC1F,CACF,CAAC"}
+{"version":3,"file":"memberGetFieldRule.mjs","names":[],"sources":["../../src/rules/memberGetFieldRule.ts"],"sourcesContent":["import { Node } from \"ts-morph\";\nimport { defineExpressionRule } from \"../utils/defineExpressionRule\";\n\nexport const memberGetFieldRule = defineExpressionRule({\n  name: \"member-get-field\",\n  priority: -100,\n  match: (expression) => {\n    if (!Node.isCallExpression(expression)) {\n      return false;\n    }\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    return Node.isPropertyAccessExpression(target) && [\"get\", \"getAll\"].includes(target.getName()) && Boolean(field);\n  },\n  parse: (expression) => {\n    if (!Node.isCallExpression(expression)) {\n      return undefined;\n    }\n\n    const target = expression.getExpression();\n    const field = expression\n      .getArguments()\n      .find((argument) => Node.isStringLiteral(argument) || Node.isNoSubstitutionTemplateLiteral(argument));\n    if (!Node.isPropertyAccessExpression(target) || (!Node.isStringLiteral(field) && !Node.isNoSubstitutionTemplateLiteral(field))) {\n      return undefined;\n    }\n\n    return { backendField: `${target.getExpression().getText()}.${field.getLiteralValue()}` };\n  }\n});\n"],"mappings":"yFAGA,MAAa,EAAqB,EAAqB,CACrD,KAAM,mBACN,SAAU,KACV,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,MAAO,GAGT,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EACtG,OAAO,EAAK,2BAA2B,CAAM,GAAK,CAAC,MAAO,QAAQ,CAAC,CAAC,SAAS,EAAO,QAAQ,CAAC,GAAK,EAAQ,CAC5G,EACA,MAAQ,GAAe,CACrB,GAAI,CAAC,EAAK,iBAAiB,CAAU,EACnC,OAGF,IAAM,EAAS,EAAW,cAAc,EAClC,EAAQ,EACX,aAAa,CAAC,CACd,KAAM,GAAa,EAAK,gBAAgB,CAAQ,GAAK,EAAK,gCAAgC,CAAQ,CAAC,EAClG,MAAC,EAAK,2BAA2B,CAAM,GAAM,CAAC,EAAK,gBAAgB,CAAK,GAAK,CAAC,EAAK,gCAAgC,CAAK,GAI5H,MAAO,CAAE,aAAc,GAAG,EAAO,cAAc,CAAC,CAAC,QAAQ,EAAE,GAAG,EAAM,gBAAgB,GAAI,CAC1F,CACF,CAAC"}

package/dist/rules/quableI18nFieldRule.d.mts

@@ -1,4 +1,4 @@
-import { n as FieldExtractionRule } from "../types-3y34Gf8R.mjs";
+import { i as FieldExtractionRule } from "../types-cYprdLUO.mjs";
 //#region src/rules/quableI18nFieldRule.d.ts
 declare const quableI18nFieldRule: FieldExtractionRule;
 //#endregion

package/dist/{types-3y34Gf8R.d.mts → types-cYprdLUO.d.mts}

@@ -8,6 +8,8 @@ type FieldExtractionRuleResult = {
 };
 type FieldExtractionRule = {
   name: string;
+  /** Higher-priority rules are evaluated first. Defaults to 0. */
+  priority?: number;
   match: (expression: Expression, config: UserConfig) => boolean;
   parse: (expression: Expression, config: UserConfig) => FieldExtractionRuleResult | undefined;
 };
@@ -18,6 +20,21 @@ interface NeutralExpressionMatcher {
   prefix: string;
   apiMapping?: boolean;
 }
+type BackendProperty = {
+  document: string;
+  field: string;
+  description?: string;
+} | {
+  route: string;
+  method: string;
+  field: string;
+  description?: string;
+};
+interface BackendSource {
+  name: string;
+  resolve?: () => Promise<BackendProperty[]>;
+  rules?: FieldExtractionRule[];
+}
 interface UserConfig {
   /**
    * Absolute path to the root of the repository to analyze (e.g. the digital-api repo).
@@ -59,7 +76,7 @@ interface UserConfig {
    */
   analysis: {
     /** Backend identifiers used by the API project. */
-    backends: string[];
+    backends: Array<string | BackendSource>;
     /**
      * Glob patterns excluded from `analysis_files`.
      * Use this to hide technical plumbing files that add noise to route review documents.
@@ -98,5 +115,5 @@ interface UserConfig {
   };
 }
 //#endregion
-export { FieldExtractionRule as n, defineExpressionRule as r, UserConfig as t };
-//# sourceMappingURL=types-3y34Gf8R.d.mts.map
+export { defineExpressionRule as a, FieldExtractionRule as i, BackendSource as n, UserConfig as r, BackendProperty as t };
+//# sourceMappingURL=types-cYprdLUO.d.mts.map

package/dist/workers/routeBackendTopologyWorker.mjs

@@ -1,4 +1,4 @@
-import { t as generateBackendTopologyArtifacts } from "../routeBackendTopologyService-D_aIIBbX.mjs";
+import { t as generateBackendTopologyArtifacts } from "../routeBackendTopologyService-DElirHSh.mjs";
 import { parentPort, workerData } from "node:worker_threads";
 //#region src/workers/routeBackendTopologyWorker.ts
 const data = workerData;

package/knowledges/cms-and-directus-indirect-routes.md

@@ -97,9 +97,11 @@ Cette limite explique les valeurs `method: null` et `route: unknown` observées
 Avec `@directus/sdk`, le code métier ne manipule généralement pas de route HTTP explicite. Il décrit une opération :
 
 ```ts
-client.request(readItems("offers", {
-  fields: ["id", "label"]
-}));
+client.request(
+  readItems("offers", {
+    fields: ["id", "label"]
+  })
+);
 ```
 
 La méthode et l'URL HTTP sont construites par le SDK. Chercher uniquement un littéral de route dans le code ne peut donc pas produire un résultat fiable.

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@cmflow/atlas",
-  "version": "3.4.0-beta.7",
+  "version": "3.4.0-beta.9",
   "description": "API-to-backend mapping catalogue for Club Med Flow",
   "license": "MIT",
   "author": "romakita",
-  "email": "rom.lenzotti@gmail.com",
   "bin": "./dist/bin/atlas.mjs",
   "type": "module",
   "main": "./dist/index.mjs",
@@ -46,6 +45,7 @@
     "typescript": "^7.0.2",
     "vitest": "^3.0.8"
   },
+  "email": "rom.lenzotti@gmail.com",
   "peerDependencies": {},
   "publishConfig": {
     "tag": "beta"