@cmflow/atlas 3.5.0 → 3.6.1

package/dist/bin/atlas.mjs

@@ -3087,7 +3087,7 @@ async function ensureOutputLink(client, outputPropertyId, backendPropertyId) {
 //#endregion
 //#region src/services/directus/queries/loadDirectusReferenceData.ts
 async function loadDirectusReferenceData(client) {
-	const values = await client.request(n$1("predefined_values", {
+	const [values, documentValues] = await Promise.all([client.request(n$1("predefined_values", {
 		filter: { type: { _in: [
 			"backend",
 			"in_type",
@@ -3099,19 +3099,33 @@ async function loadDirectusReferenceData(client) {
 			"type"
 		],
 		limit: -1
-	}));
+	})), client.request(n$1("predefined_values", {
+		filter: { type: { _starts_with: "document_" } },
+		fields: [
+			"id",
+			"label",
+			"type"
+		],
+		limit: -1
+	}))]);
 	const backendIds = /* @__PURE__ */ new Map();
 	const inTypeIds = /* @__PURE__ */ new Map();
 	const outTypeIds = /* @__PURE__ */ new Map();
+	const documentIds = /* @__PURE__ */ new Map();
 	for (const value of values) {
 		const normalizedKeys = [normalizeLookupKey(value.id), normalizeLookupKey(value.label)];
 		const target = value.type === "backend" ? backendIds : value.type === "in_type" ? inTypeIds : outTypeIds;
 		for (const key of normalizedKeys) target.set(key, value.id);
 	}
+	for (const value of documentValues) {
+		const normalizedKeys = [normalizeLookupKey(value.id), normalizeLookupKey(value.label)];
+		for (const key of normalizedKeys) documentIds.set(key, value.id);
+	}
 	return {
 		backendIds,
 		inTypeIds,
-		outTypeIds
+		outTypeIds,
+		documentIds
 	};
 }
 
@@ -4449,6 +4463,7 @@ function ensureBackendRouteRecord(backendRoutesByKey, document, candidate) {
 		key,
 		backend: candidate.backend,
 		route_key: document.key,
+		resource_type: "http",
 		route: `${candidate.method || "CALL"} ${candidate.route}`,
 		source_file: candidate.sourceFile,
 		provenance: "code_analysis"
@@ -4711,7 +4726,7 @@ async function upsertBackendProperty(client, property, backendRouteId, typeId) {
 	const path = normalizeDirectusPath(property.field);
 	const [existing] = await client.request(n$1("backend_properties", {
 		filter: {
-			route: { _eq: backendRouteId },
+			backend: { _eq: backendRouteId },
 			path: { _eq: path },
 			type: { _eq: typeId }
 		},
@@ -4720,39 +4735,93 @@ async function upsertBackendProperty(client, property, backendRouteId, typeId) {
 	}));
 	if (existing) return existing.id;
 	const created = await client.request(n$2("backend_properties", {
-		route: backendRouteId,
+		backend: backendRouteId,
 		path: path || null,
 		type: typeId,
 		source_file: property.source_file || null,
+		provenance: property.provenance,
 		comments: property.provenance === "ai" ? "Inferred with AI" : null,
 		content_name: null
 	}));
 	return typeof created === "string" ? created : created.id;
 }
 
-//#endregion
-//#region src/services/directus/utils/toBackendRouteIdentifier.ts
-function toBackendRouteIdentifier(route) {
-	return `${route.method} ${route.path}`;
-}
-
 //#endregion
 //#region src/services/directus/queries/upsertBackendRoute.ts
-async function upsertBackendRoute(client, apiRoute, backendValueId) {
-	const route = toBackendRouteIdentifier(apiRoute);
-	const [existing] = await client.request(n$1("backend_routes", {
-		filter: { route: { _eq: route } },
+async function upsertBackendSource(client, backendRoute, backendValueId, refs) {
+	const isDocument = backendRoute.resource_type === "document";
+	let documentId = isDocument ? refs.documentIds.get(normalizeLookupKey(backendRoute.document || "")) : void 0;
+	if (isDocument && !documentId && backendRoute.document) {
+		const type = `document_${backendRoute.backend.toLowerCase()}`;
+		const created = await client.request(n$2("predefined_values", {
+			label: backendRoute.document,
+			type
+		}));
+		documentId = typeof created === "string" ? created : created.id;
+		refs.documentIds.set(normalizeLookupKey(backendRoute.document), documentId);
+	}
+	const filter = isDocument ? {
+		backend: { _eq: backendValueId },
+		resource_type: { _eq: "document" },
+		document: { _eq: documentId ?? null }
+	} : {
+		backend: { _eq: backendValueId },
+		resource_type: { _eq: "http" },
+		method: { _eq: backendRoute.method ?? null },
+		route: { _eq: backendRoute.route ?? null }
+	};
+	const [existing] = await client.request(n$1("backend_sources", {
+		filter,
 		fields: ["id"],
 		limit: 1
 	}));
 	if (existing) return existing.id;
-	const created = await client.request(n$2("backend_routes", {
-		route,
-		backend: backendValueId
-	}));
+	const payload = isDocument ? {
+		backend: backendValueId,
+		resource_type: "document",
+		document: documentId ?? null,
+		source_file: backendRoute.source_file || null,
+		provenance: backendRoute.provenance
+	} : {
+		backend: backendValueId,
+		resource_type: "http",
+		method: backendRoute.method ?? null,
+		route: backendRoute.route ?? null,
+		source_file: backendRoute.source_file || null,
+		provenance: backendRoute.provenance
+	};
+	const created = await client.request(n$2("backend_sources", payload));
 	return typeof created === "string" ? created : created.id;
 }
 
+//#endregion
+//#region src/services/directus/queries/upsertMappingEvidence.ts
+async function upsertMappingEvidence(client, evidence, params) {
+	const [existing] = await client.request(n$1("mapping_evidence", {
+		filter: { atlas_key: { _eq: evidence.key } },
+		fields: ["id"],
+		limit: 1
+	}));
+	const payload = {
+		atlas_key: evidence.key,
+		input_property_id: params.inputPropertyId ?? null,
+		output_property_id: params.outputPropertyId ?? null,
+		backend_property_id: params.backendPropertyId,
+		evidence_type: evidence.evidence_type,
+		status: evidence.status,
+		confidence_score: evidence.confidence_score,
+		comment: evidence.comment || null,
+		source_file: evidence.source_file || null,
+		last_seen_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	if (existing) {
+		await client.request(i("mapping_evidence", existing.id, payload));
+		return false;
+	}
+	await client.request(n$2("mapping_evidence", payload));
+	return true;
+}
+
 //#endregion
 //#region src/services/directus/queries/upsertInputProperty.ts
 async function upsertInputProperty(client, property, routeId, inType) {
@@ -4812,6 +4881,12 @@ async function upsertOutputProperty(client, property, routeId, outType) {
 	return existing.id;
 }
 
+//#endregion
+//#region src/services/directus/utils/toBackendRouteIdentifier.ts
+function toBackendRouteIdentifier(route) {
+	return `${route.method} ${route.path}`;
+}
+
 //#endregion
 //#region src/services/directus/utils/buildTranslationSummary.ts
 function buildTranslationSummary(route) {
@@ -4851,11 +4926,10 @@ async function upsertRoute(client, route) {
 
 //#endregion
 //#region src/services/directus/utils/groupBackendRoutesForDirectusSync.ts
-function groupBackendRoutesForDirectusSync(backendRoutes, apiRoutesByKey) {
+function groupBackendRoutesForDirectusSync(backendRoutes) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const backendRoute of backendRoutes) {
-		const apiRoute = apiRoutesByKey.get(backendRoute.route_key);
-		const key = apiRoute ? `${backendRoute.backend}\0${apiRoute.method}\0${apiRoute.path}` : `${backendRoute.backend}\0missing-api-route\0${backendRoute.key}`;
+		const key = backendRoute.resource_type === "document" ? `${backendRoute.backend}\0document\0${backendRoute.document || ""}` : `${backendRoute.backend}\0http\0${backendRoute.method || ""}\0${backendRoute.route || ""}`;
 		const group = groups.get(key);
 		if (group) group.keys.push(backendRoute.key);
 		else groups.set(key, {
@@ -4910,12 +4984,13 @@ async function pushCatalogueToDirectus(catalogue, options) {
 		"routes",
 		"route_input_properties",
 		"route_output_properties",
-		"backend_routes",
+		"backend_sources",
 		"backend_properties",
+		"mapping_evidence",
 		"route_input_properties_backend_properties",
 		"route_output_properties_backend_properties"
 	];
-	const skippedCollections = ["mapping_evidence"];
+	const skippedCollections = [];
 	const catalogueToPush = selectCatalogueForDirectusPush(catalogue, options.routeSelector);
 	if (options.dryRun) {
 		taskProgressService.report("Validating reconstructed catalogue (dry-run)");
@@ -4934,7 +5009,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 	const warnings = /* @__PURE__ */ new Set();
 	let pushedItems = 0;
 	const apiRoutesByKey = new Map(catalogueToPush.routes.map((route) => [route.key, route]));
-	const backendRouteGroups = groupBackendRoutesForDirectusSync(catalogueToPush.backend_routes, apiRoutesByKey);
+	const backendRouteGroups = groupBackendRoutesForDirectusSync(catalogueToPush.backend_routes);
 	const backendRouteGroupsByApiRouteKey = /* @__PURE__ */ new Map();
 	const backendRouteApiRouteKeys = /* @__PURE__ */ new Map();
 	for (const group of backendRouteGroups) {
@@ -4962,7 +5037,7 @@ async function pushCatalogueToDirectus(catalogue, options) {
 				continue;
 			}
 			if (backendReference.created) pushedItems += 1;
-			const backendRouteId = await upsertBackendRoute(client, route, backendReference.id);
+			const backendRouteId = await upsertBackendSource(client, backendRoute, backendReference.id, refs);
 			for (const key of keys) backendRouteIds.set(key, backendRouteId);
 			pushedItems += 1;
 		}
@@ -4995,7 +5070,14 @@ async function pushCatalogueToDirectus(catalogue, options) {
 			pushedItems += 1;
 			for (const evidence of catalogueToPush.mapping_evidence.filter((item) => item.input_property_key === property.key)) {
 				const backendPropertyId = backendPropertyIds.get(evidence.backend_property_key);
-				if (backendPropertyId && await ensureInputLink(client, inputPropertyId, backendPropertyId)) pushedItems += 1;
+				if (backendPropertyId) {
+					if (await ensureInputLink(client, inputPropertyId, backendPropertyId)) pushedItems += 1;
+					await upsertMappingEvidence(client, evidence, {
+						inputPropertyId,
+						backendPropertyId
+					});
+					pushedItems += 1;
+				}
 			}
 		}
 		const routeOutputProperties = catalogueToPush.route_output_properties.filter((property) => property.route_key === route.key);
@@ -5010,7 +5092,14 @@ async function pushCatalogueToDirectus(catalogue, options) {
 			pushedItems += 1;
 			for (const evidence of catalogueToPush.mapping_evidence.filter((item) => item.output_property_key === property.key)) {
 				const backendPropertyId = backendPropertyIds.get(evidence.backend_property_key);
-				if (backendPropertyId && await ensureOutputLink(client, outputPropertyId, backendPropertyId)) pushedItems += 1;
+				if (backendPropertyId) {
+					if (await ensureOutputLink(client, outputPropertyId, backendPropertyId)) pushedItems += 1;
+					await upsertMappingEvidence(client, evidence, {
+						outputPropertyId,
+						backendPropertyId
+					});
+					pushedItems += 1;
+				}
 			}
 		}
 	}
@@ -5121,7 +5210,7 @@ function buildRouteReviewDocument(catalogue, routeKey) {
 	const datasources = backendRoutes.map((backendRoute) => ({
 		type: backendRoute.backend,
 		source: backendRoute.source_file,
-		...parseBackendRoute(backendRoute.route) ? { operation: parseBackendRoute(backendRoute.route) } : {},
+		...parseBackendRoute(backendRoute.route ?? "") ? { operation: parseBackendRoute(backendRoute.route ?? "") } : {},
 		...backendRoute.provenance === "ai" ? { provenance: backendRoute.provenance } : {}
 	}));
 	for (const backend of route.backends) if (!datasources.some((datasource) => datasource.type === backend) && !mappedBackendTypes.has(backend)) datasources.push({
@@ -5243,6 +5332,7 @@ function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backend
 		key: backendRouteKey,
 		backend: mapping.backend,
 		route_key: routeKey,
+		resource_type: "http",
 		route: `${mapping.method || "CALL"} ${backendRoute}`,
 		source_file: mapping.source_file,
 		provenance: "code_analysis"
@@ -5291,6 +5381,7 @@ function addDatasourceRoute(routeKey, datasource, backendRoutesByKey) {
 		key: backendRouteKey,
 		backend: datasource.type,
 		route_key: routeKey,
+		resource_type: "http",
 		route: `${datasource.operation?.method || "CALL"} ${backendRoute}`,
 		source_file: datasource.source,
 		provenance: datasource.provenance || "code_analysis"
@@ -23082,6 +23173,7 @@ function ensureBackendRoute(catalogue, document, suggestion) {
 		key,
 		backend: suggestion.candidate.backend,
 		route_key: document.key,
+		resource_type: "http",
 		route: `${candidate?.method || "CALL"} ${backendRoutePath}`,
 		source_file: candidate?.sourceFile || suggestion.candidate.sourceFile,
 		provenance: "ai"
@@ -23841,7 +23933,7 @@ async function reportChangedHandler(cwd, options) {
 				backends: catalogueRoute?.backends || [],
 				backendRoutes: catalogue.backend_routes.filter((br) => br.route_key === catalogueRoute?.key).map((br) => ({
 					backend: br.backend,
-					route: br.route
+					route: br.route ?? ""
 				})),
 				properties: [...catalogue.route_input_properties.map((p) => ({
 					direction: "input",