@cmflow/atlas 3.7.0 → 3.8.0

package/dist/bin/atlas.mjs

@@ -4,13 +4,13 @@ const __filename = __atlasFileURLToPath(import.meta.url);
 import { n as __require, r as __toESM, t as __commonJSMin } from "../rolldown-runtime-CGR6nZuH.mjs";
 import { a as isCancel, c as userConfig$1, i as select, n as atlasLogger, o as getUserConfig, r as progress, s as setUserConfig, t as taskProgressService } from "../taskProgressService-DAEpEqsT.mjs";
 import { a as resolveModulePath, c as filterAnalysisFiles, d as globby, i as matchesRouteSelector, l as shouldKeepAnalysisFile, n as generateBackendTopologyArtifactsInWorkers, o as inferBackendNameFromFile, s as isKnownBackendType, u as normalizeFilePath } from "../routeBackendTopologyService-_-yZSfG8.mjs";
-import { a as loadOpenApiDocument, i as extractOpenApiOutputProperties, r as extractOpenApiInputProperties, t as require_dist$1 } from "../dist-D8VumL0r.mjs";
+import { c as loadOpenApiDocument, i as extractOpenApiOutputProperties, o as transformTypeFrom, r as extractOpenApiInputProperties, s as pickPropertyMetadata, t as require_dist$1 } from "../dist-DIU2ATkt.mjs";
 import { n as require_auth_errors, r as require_token_error, t as require_token_util } from "../token-util-Dnzm6rU4.mjs";
 import { readFileSync } from "node:fs";
 import path, { resolve } from "node:path";
 import { Node, Project, SyntaxKind } from "ts-morph";
 import fsPromises from "node:fs/promises";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 
 //#region node_modules/commander/lib/error.js
 var require_error = /* @__PURE__ */ __commonJSMin(((exports) => {
@@ -2948,18 +2948,12 @@ async function createClient() {
 //#region src/services/directus/queries/deleteOrphanedPropertyLinks.ts
 const DIRECTUS_DELETE_WORKERS = 2;
 async function deleteOrphanedPropertyLinks(client, orphanedLinks) {
-	const links = [...orphanedLinks.input.map((link) => ({
-		collection: "route_input_properties_backend_properties",
-		id: link.id
-	})), ...orphanedLinks.output.map((link) => ({
-		collection: "route_output_properties_backend_properties",
-		id: link.id
-	}))];
+	const links = orphanedLinks.links;
 	let nextIndex = 0;
 	await Promise.all(Array.from({ length: Math.min(DIRECTUS_DELETE_WORKERS, links.length) }, async () => {
 		while (nextIndex < links.length) {
 			const link = links[nextIndex++];
-			await client.request(r$1(link.collection, link.id));
+			await client.request(r$1("route_properties_backend_properties", link.id));
 		}
 	}));
 	return links.length;
@@ -2968,12 +2962,8 @@ async function deleteOrphanedPropertyLinks(client, orphanedLinks) {
 //#endregion
 //#region src/services/directus/queries/findOrphanedPropertyLinks.ts
 async function findOrphanedPropertyLinks(client) {
-	const [inputProperties, outputProperties, backendProperties, inputLinks, outputLinks] = await Promise.all([
-		client.request(n$1("route_input_properties", {
-			fields: ["id"],
-			limit: -1
-		})),
-		client.request(n$1("route_output_properties", {
+	const [routeProperties, backendProperties, links] = await Promise.all([
+		client.request(n$1("route_properties", {
 			fields: ["id"],
 			limit: -1
 		})),
@@ -2981,31 +2971,19 @@ async function findOrphanedPropertyLinks(client) {
 			fields: ["id"],
 			limit: -1
 		})),
-		client.request(n$1("route_input_properties_backend_properties", {
-			fields: [
-				"id",
-				"route_input_properties_id",
-				"backend_properties_id"
-			],
-			limit: -1
-		})),
-		client.request(n$1("route_output_properties_backend_properties", {
+		client.request(n$1("route_properties_backend_properties", {
 			fields: [
 				"id",
-				"route_output_properties_id",
+				"route_properties_id",
 				"backend_properties_id"
 			],
 			limit: -1
 		}))
 	]);
 	const ids = (items) => new Set(items.map((item) => String(item.id)));
-	const inputIds = ids(inputProperties);
-	const outputIds = ids(outputProperties);
+	const routePropertyIds = ids(routeProperties);
 	const backendIds = ids(backendProperties);
-	return {
-		input: inputLinks.filter((link) => !inputIds.has(String(link.route_input_properties_id)) || !backendIds.has(String(link.backend_properties_id))),
-		output: outputLinks.filter((link) => !outputIds.has(String(link.route_output_properties_id)) || !backendIds.has(String(link.backend_properties_id)))
-	};
+	return { links: links.filter((link) => !routePropertyIds.has(String(link.route_properties_id)) || !backendIds.has(String(link.backend_properties_id))) };
 }
 
 //#endregion
@@ -3015,7 +2993,7 @@ async function cleanDirectusOrphanedPropertyLinks(options) {
 	const client = await createClient();
 	taskProgressService.report("Finding orphaned property links");
 	const orphanedLinks = await findOrphanedPropertyLinks(client);
-	const orphanedCount = orphanedLinks.input.length + orphanedLinks.output.length;
+	const orphanedCount = orphanedLinks.links.length;
 	if (options.dryRun) {
 		taskProgressService.report(`${orphanedCount} orphaned property links found (dry-run)`);
 		return {
@@ -3050,17 +3028,17 @@ async function cleanupOrphanedPropertyLinks(client) {
 //#endregion
 //#region src/services/directus/queries/ensureInputLink.ts
 async function ensureInputLink(client, inputPropertyId, backendPropertyId) {
-	const [existing] = await client.request(n$1("route_input_properties_backend_properties", {
+	const [existing] = await client.request(n$1("route_properties_backend_properties", {
 		filter: {
-			route_input_properties_id: { _eq: inputPropertyId },
+			route_properties_id: { _eq: inputPropertyId },
 			backend_properties_id: { _eq: backendPropertyId }
 		},
 		fields: ["id"],
 		limit: 1
 	}));
 	if (existing) return false;
-	await client.request(n$2("route_input_properties_backend_properties", {
-		route_input_properties_id: inputPropertyId,
+	await client.request(n$2("route_properties_backend_properties", {
+		route_properties_id: inputPropertyId,
 		backend_properties_id: backendPropertyId
 	}));
 	return true;
@@ -3069,17 +3047,17 @@ async function ensureInputLink(client, inputPropertyId, backendPropertyId) {
 //#endregion
 //#region src/services/directus/queries/ensureOutputLink.ts
 async function ensureOutputLink(client, outputPropertyId, backendPropertyId) {
-	const [existing] = await client.request(n$1("route_output_properties_backend_properties", {
+	const [existing] = await client.request(n$1("route_properties_backend_properties", {
 		filter: {
-			route_output_properties_id: { _eq: outputPropertyId },
+			route_properties_id: { _eq: outputPropertyId },
 			backend_properties_id: { _eq: backendPropertyId }
 		},
 		fields: ["id"],
 		limit: 1
 	}));
 	if (existing) return false;
-	await client.request(n$2("route_output_properties_backend_properties", {
-		route_output_properties_id: outputPropertyId,
+	await client.request(n$2("route_properties_backend_properties", {
+		route_properties_id: outputPropertyId,
 		backend_properties_id: backendPropertyId
 	}));
 	return true;
@@ -3092,7 +3070,8 @@ async function loadDirectusReferenceData(client) {
 		filter: { type: { _in: [
 			"backend",
 			"in_type",
-			"out_type"
+			"out_type",
+			"data_type"
 		] } },
 		fields: [
 			"id",
@@ -3113,9 +3092,10 @@ async function loadDirectusReferenceData(client) {
 	const inTypeIds = /* @__PURE__ */ new Map();
 	const outTypeIds = /* @__PURE__ */ new Map();
 	const documentIds = /* @__PURE__ */ new Map();
+	const dataTypeIds = /* @__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;
+		const target = value.type === "backend" ? backendIds : value.type === "in_type" ? inTypeIds : value.type === "out_type" ? outTypeIds : dataTypeIds;
 		for (const key of normalizedKeys) target.set(key, value.id);
 	}
 	for (const value of documentValues) {
@@ -3126,7 +3106,8 @@ async function loadDirectusReferenceData(client) {
 		backendIds,
 		inTypeIds,
 		outTypeIds,
-		documentIds
+		documentIds,
+		dataTypeIds
 	};
 }
 
@@ -3354,6 +3335,13 @@ function dedupeByKey(items, keyFn) {
 	return [...map.values()];
 }
 
+//#endregion
+//#region src/utils/path/isArrayPath.ts
+/** Whether a property path denotes an array element (e.g. `offers[].id`). */
+function isArrayPath(path) {
+	return path.includes("[]");
+}
+
 //#endregion
 //#region src/services/codeAnalysisService.ts
 const userConfig = new Proxy({}, { get: (_target, property) => Reflect.get(getUserConfig(), property) });
@@ -4457,15 +4445,26 @@ function resolveApiPropertySource(document, property, direction, matches = []) {
 	return match ? `${match.sourceFile}:${match.line}` : matches[0] ? backendFieldSource(matches[0]) : document.routeFile || null;
 }
 function ensureBackendRouteRecord(backendRoutesByKey, document, candidate) {
-	const key = stableKey(document.key, candidate.backend, candidate.route);
+	const isDocument = "document" in candidate;
+	const sourceId = isDocument ? candidate.document : candidate.route;
+	const key = stableKey(document.key, candidate.backend, sourceId);
 	const existing = backendRoutesByKey.get(key);
 	if (existing) return existing;
-	const created = {
+	const created = isDocument ? {
+		key,
+		backend: candidate.backend,
+		route_key: document.key,
+		resource_type: "document",
+		document: candidate.document,
+		source_file: candidate.sourceFile,
+		provenance: "code_analysis"
+	} : {
 		key,
 		backend: candidate.backend,
 		route_key: document.key,
 		resource_type: "http",
-		route: `${candidate.method || "CALL"} ${candidate.route}`,
+		method: candidate.method || void 0,
+		route: candidate.route,
 		source_file: candidate.sourceFile,
 		provenance: "code_analysis"
 	};
@@ -4483,6 +4482,7 @@ function toBackendMapping(document, match) {
 		document: resolved.document,
 		field: resolved.field,
 		description: resolved.description,
+		...pickPropertyMetadata(resolved),
 		source_file: backendFieldSource(match),
 		confidence: match.confidence,
 		mapper_type: match.mapperType,
@@ -4492,15 +4492,20 @@ function toBackendMapping(document, match) {
 	return {
 		backend: match.backend,
 		method: backendRouteCandidate?.method || null,
-		route: backendRouteCandidate?.route || "unknown",
+		route: backendRouteCandidate?.route || "",
 		field: resolved?.field || match.backendField,
 		description: resolved?.description,
+		...pickPropertyMetadata(resolved),
 		source_file: backendFieldSource(match),
 		confidence: match.confidence,
 		mapper_type: match.mapperType,
 		reason: match.reviewReason
 	};
 }
+function toApiPropertyDataType(property) {
+	if (!property.data_type || property.data_type === "unknow" || property.data_type.endsWith("[]")) return property.data_type;
+	return isArrayPath(property.path) ? `${property.data_type}[]` : property.data_type;
+}
 async function buildCatalogue(documents) {
 	const routes = documents.map((document) => ({
 		key: document.key,
@@ -4550,6 +4555,8 @@ async function buildCatalogue(documents) {
 				field: property.path,
 				domain_field: apiSource?.domainField,
 				transversal: isTransversalInput(property) || void 0,
+				...pickPropertyMetadata(property),
+				data_type: toApiPropertyDataType(property),
 				backend_names: backendNames,
 				backend_mappings: backendMappings,
 				description: normalizeDescription(property.description),
@@ -4568,9 +4575,14 @@ async function buildCatalogue(documents) {
 				source_file: document.routeFile || null
 			});
 			for (const match of matches) {
-				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolveBackendRouteCandidate(document, match) || {
+				const resolvedDocument = match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0;
+				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolvedDocument ? {
 					backend: match.backend,
-					route: "unknown",
+					document: resolvedDocument,
+					sourceFile: match.sourceFile
+				} : resolveBackendRouteCandidate(document, match) || {
+					backend: match.backend,
+					route: "",
 					sourceFile: match.sourceFile
 				}).key;
 				const backendPropertyKey = stableKey(backendRouteKey, "input", match.resolvedProperty?.field || match.backendField);
@@ -4581,6 +4593,7 @@ async function buildCatalogue(documents) {
 					field: match.resolvedProperty?.field || match.backendField,
 					document: match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0,
 					description: match.resolvedProperty?.description,
+					...pickPropertyMetadata(match.resolvedProperty),
 					direction: "input",
 					source_file: backendFieldSource(match),
 					provenance: "code_analysis"
@@ -4611,6 +4624,8 @@ async function buildCatalogue(documents) {
 				direction: "output",
 				field: property.path,
 				domain_field: apiSource?.domainField,
+				...pickPropertyMetadata(property),
+				data_type: toApiPropertyDataType(property),
 				backend_names: backendNames,
 				backend_mappings: backendMappings,
 				description: normalizeDescription(property.description),
@@ -4630,9 +4645,14 @@ async function buildCatalogue(documents) {
 				source_file: document.routeFile || null
 			});
 			for (const match of matches) {
-				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolveBackendRouteCandidate(document, match) || {
+				const resolvedDocument = match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0;
+				const backendRouteKey = ensureBackendRouteRecord(backendRoutesByKey, document, resolvedDocument ? {
+					backend: match.backend,
+					document: resolvedDocument,
+					sourceFile: match.sourceFile
+				} : resolveBackendRouteCandidate(document, match) || {
 					backend: match.backend,
-					route: "unknown",
+					route: "",
 					sourceFile: match.sourceFile
 				}).key;
 				const backendPropertyKey = stableKey(backendRouteKey, "output", match.resolvedProperty?.field || match.backendField);
@@ -4643,6 +4663,7 @@ async function buildCatalogue(documents) {
 					field: match.resolvedProperty?.field || match.backendField,
 					document: match.resolvedProperty && "document" in match.resolvedProperty ? match.resolvedProperty.document : void 0,
 					description: match.resolvedProperty?.description,
+					...pickPropertyMetadata(match.resolvedProperty),
 					direction: "output",
 					source_file: backendFieldSource(match),
 					provenance: "code_analysis"
@@ -4692,6 +4713,20 @@ function toPascalCase(value) {
 	return value.toLowerCase().replace(/(^|[^a-z0-9]+)([a-z0-9])/g, (_match, _separator, character) => character.toUpperCase());
 }
 
+//#endregion
+//#region src/services/directus/queries/createPredefinedValue.ts
+/**
+* Creates a Directus predefined value while retaining the attempted identity in
+* any error reported by the push command.
+*/
+async function createPredefinedValue(client, payload) {
+	try {
+		return await client.request(n$2("predefined_values", payload));
+	} catch (error) {
+		throw new Error(`Unable to create predefined_values entry (type=${JSON.stringify(payload.type)}, id=${JSON.stringify(payload.id)}, label=${JSON.stringify(payload.label)})`, { cause: error });
+	}
+}
+
 //#endregion
 //#region src/services/directus/queries/resolveBackendReference.ts
 async function resolveBackendReference(client, references, backend) {
@@ -4702,11 +4737,11 @@ async function resolveBackendReference(client, references, backend) {
 		created: false
 	};
 	if (!isKnownBackendType(backend)) return { created: false };
-	const created = await client.request(n$2("predefined_values", {
+	const created = await createPredefinedValue(client, {
 		id: backend,
 		label: toPascalCase(backend),
 		type: "backend"
-	}));
+	});
 	const id = typeof created === "string" ? created : created.id;
 	references.backendIds.set(lookupKey, id);
 	return {
@@ -4715,15 +4750,56 @@ async function resolveBackendReference(client, references, backend) {
 	};
 }
 
+//#endregion
+//#region src/services/directus/queries/resolveDataTypeReference.ts
+async function resolveDataTypeReference(client, references, dataType) {
+	const { id, label } = transformTypeFrom(dataType);
+	const lookupKey = normalizeLookupKey(id);
+	const existingId = references.dataTypeIds.get(lookupKey);
+	if (existingId) return {
+		id: existingId,
+		created: false
+	};
+	const created = await createPredefinedValue(client, {
+		id,
+		label,
+		type: "data_type"
+	});
+	const createdId = typeof created === "string" ? created : created.id;
+	references.dataTypeIds.set(lookupKey, createdId);
+	return {
+		id: createdId,
+		created: true
+	};
+}
+
 //#endregion
 //#region src/services/directus/utils/normalizeDirectusPath.ts
 function normalizeDirectusPath(value) {
 	return value.replace(/\?\.\[/g, "[").replace(/\?\./g, ".");
 }
 
+//#endregion
+//#region src/services/directus/utils/toDirectusPropertyMetadata.ts
+/**
+* Converts Atlas' property metadata to the nullable shape expected by Directus.
+* The data type relation is deliberately excluded: it is resolved separately as
+* a predefined-value id before a property is upserted.
+*/
+function toDirectusPropertyMetadata(property) {
+	return {
+		original_type: property.original_type ?? null,
+		format: property.format ?? null,
+		pattern: property.pattern ?? null,
+		is_nullable: property.is_nullable ?? null,
+		enum_values: property.enum_values?.length ? property.enum_values : null,
+		description: property.description ?? null
+	};
+}
+
 //#endregion
 //#region src/services/directus/queries/upsertBackendProperty.ts
-async function upsertBackendProperty(client, property, backendRouteId, typeId) {
+async function upsertBackendProperty(client, property, backendRouteId, typeId, dataTypeId) {
 	const path = normalizeDirectusPath(property.field);
 	const [existing] = await client.request(n$1("backend_properties", {
 		filter: {
@@ -4734,16 +4810,21 @@ async function upsertBackendProperty(client, property, backendRouteId, typeId) {
 		fields: ["id"],
 		limit: 1
 	}));
-	if (existing) return existing.id;
-	const created = await client.request(n$2("backend_properties", {
+	const payload = {
 		backend: backendRouteId,
 		path: path || null,
 		type: typeId,
+		data_type: dataTypeId ?? null,
+		...toDirectusPropertyMetadata(property),
 		source_file: property.source_file || null,
 		provenance: property.provenance,
-		comments: property.provenance === "ai" ? "Inferred with AI" : null,
-		content_name: null
-	}));
+		comments: property.provenance === "ai" ? "Inferred with AI" : null
+	};
+	if (existing) {
+		await client.request(i("backend_properties", existing.id, payload));
+		return existing.id;
+	}
+	const created = await client.request(n$2("backend_properties", payload));
 	return typeof created === "string" ? created : created.id;
 }
 
@@ -4754,10 +4835,12 @@ async function upsertBackendSource(client, backendRoute, backendValueId, refs) {
 	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", {
+		const id = `${type}_${backendRoute.document}`.toUpperCase().replace(/[^A-Z0-9]+/g, "_");
+		const created = await createPredefinedValue(client, {
+			id,
 			label: backendRoute.document,
 			type
-		}));
+		});
 		documentId = typeof created === "string" ? created : created.id;
 		refs.documentIds.set(normalizeLookupKey(backendRoute.document), documentId);
 	}
@@ -4780,6 +4863,8 @@ async function upsertBackendSource(client, backendRoute, backendValueId, refs) {
 	const payload = isDocument ? {
 		backend: backendValueId,
 		resource_type: "document",
+		method: null,
+		route: null,
 		document: documentId ?? null,
 		source_file: backendRoute.source_file || null,
 		provenance: backendRoute.provenance
@@ -4788,26 +4873,29 @@ async function upsertBackendSource(client, backendRoute, backendValueId, refs) {
 		resource_type: "http",
 		method: backendRoute.method ?? null,
 		route: backendRoute.route ?? null,
+		document: null,
 		source_file: backendRoute.source_file || null,
 		provenance: backendRoute.provenance
 	};
-	const created = await client.request(n$2("backend_sources", payload));
+	const created = await client.request(n$2("backend_sources", {
+		id: randomUUID(),
+		...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", {
+	const [existing] = await client.request(n$1("mapping_evidences", {
 		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,
+		route_property_id: params.routePropertyId ?? null,
+		backend_property_id: params.backendPropertyId ?? null,
 		evidence_type: evidence.evidence_type,
 		status: evidence.status,
 		confidence_score: evidence.confidence_score,
@@ -4816,70 +4904,57 @@ async function upsertMappingEvidence(client, evidence, params) {
 		last_seen_at: (/* @__PURE__ */ new Date()).toISOString()
 	};
 	if (existing) {
-		await client.request(i("mapping_evidence", existing.id, payload));
+		await client.request(i("mapping_evidences", existing.id, payload));
 		return false;
 	}
-	await client.request(n$2("mapping_evidence", payload));
+	await client.request(n$2("mapping_evidences", {
+		id: randomUUID(),
+		...payload
+	}));
 	return true;
 }
 
 //#endregion
-//#region src/services/directus/queries/upsertInputProperty.ts
-async function upsertInputProperty(client, property, routeId, inType) {
-	const field = normalizeDirectusPath(property.field);
-	const [existing] = await client.request(n$1("route_input_properties", {
+//#region src/services/directus/queries/upsertRouteProperty.ts
+async function upsertRouteProperty(client, property, routeId, type, dataTypeId) {
+	const path = normalizeDirectusPath(property.field);
+	const [existing] = await client.request(n$1("route_properties", {
 		filter: {
 			route_id: { _eq: routeId },
-			path: { _eq: field },
-			in_type: { _eq: inType }
+			path: { _eq: path },
+			type: { _eq: type }
 		},
 		fields: ["id"],
 		limit: 1
 	}));
 	const payload = {
 		route_id: routeId,
-		path: field,
-		in_type: inType,
-		description: property.description || null,
+		path,
+		type,
+		data_type: dataTypeId ?? null,
+		...toDirectusPropertyMetadata(property),
 		source_file: property.source_file || null,
-		deprecated: false
+		deprecated: false,
+		is_dynamic: isArrayPath(path) || path.includes("{")
 	};
 	if (!existing) {
-		const created = await client.request(n$2("route_input_properties", payload));
+		const created = await client.request(n$2("route_properties", payload));
 		return typeof created === "string" ? created : created.id;
 	}
-	await client.request(i("route_input_properties", existing.id, payload));
+	await client.request(i("route_properties", existing.id, payload));
 	return existing.id;
 }
 
+//#endregion
+//#region src/services/directus/queries/upsertInputProperty.ts
+async function upsertInputProperty(client, property, routeId, inType, dataTypeId) {
+	return upsertRouteProperty(client, property, routeId, inType, dataTypeId);
+}
+
 //#endregion
 //#region src/services/directus/queries/upsertOutputProperty.ts
-async function upsertOutputProperty(client, property, routeId, outType) {
-	const field = normalizeDirectusPath(property.field);
-	const [existing] = await client.request(n$1("route_output_properties", {
-		filter: {
-			route_id: { _eq: routeId },
-			path: { _eq: field },
-			out_type: { _eq: outType }
-		},
-		fields: ["id"],
-		limit: 1
-	}));
-	const payload = {
-		route_id: routeId,
-		path: field,
-		out_type: outType,
-		description: property.description || null,
-		source_file: property.source_file || null,
-		deprecated: false,
-		is_dynamic: field.includes("[]") || field.includes("{")
-	};
-	if (!existing) {
-		const created = await client.request(n$2("route_output_properties", payload));
-		return typeof created === "string" ? created : created.id;
-	}
-	await client.request(i("route_output_properties", existing.id, payload));
-	return existing.id;
+async function upsertOutputProperty(client, property, routeId, outType, dataTypeId) {
+	return upsertRouteProperty(client, property, routeId, outType, dataTypeId);
 }
 
 //#endregion
@@ -4930,7 +5005,7 @@ async function upsertRoute(client, route) {
 function groupBackendRoutesForDirectusSync(backendRoutes) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const backendRoute of backendRoutes) {
-		const key = backendRoute.resource_type === "document" ? `${backendRoute.backend}\0document\0${backendRoute.document || ""}` : `${backendRoute.backend}\0http\0${backendRoute.method || ""}\0${backendRoute.route || ""}`;
+		const key = backendRoute.resource_type === "document" ? `${backendRoute.route_key}\0${backendRoute.backend}\0document\0${backendRoute.document || ""}` : `${backendRoute.route_key}\0${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, {
@@ -4963,7 +5038,6 @@ function selectCatalogueForDirectusPush(catalogue, routeSelector) {
 	const backendRouteKeys = new Set(backendRoutes.map((route) => route.key));
 	const backendProperties = catalogue.backend_properties.filter((property) => backendRouteKeys.has(property.backend_route_key));
 	const apiPropertyKeys = new Set([...routeInputProperties, ...routeOutputProperties].map((property) => property.key));
-	const backendPropertyKeys = new Set(backendProperties.map((property) => property.key));
 	return {
 		...catalogue,
 		routes,
@@ -4971,7 +5045,7 @@ function selectCatalogueForDirectusPush(catalogue, routeSelector) {
 		route_output_properties: routeOutputProperties,
 		backend_routes: backendRoutes,
 		backend_properties: backendProperties,
-		mapping_evidence: catalogue.mapping_evidence.filter((evidence) => backendPropertyKeys.has(evidence.backend_property_key) && (apiPropertyKeys.has(evidence.input_property_key || "") || apiPropertyKeys.has(evidence.output_property_key || ""))),
+		mapping_evidence: catalogue.mapping_evidence.filter((evidence) => apiPropertyKeys.has(evidence.input_property_key || "") || apiPropertyKeys.has(evidence.output_property_key || "")),
 		rules: catalogue.rules.filter((rule) => routeKeys.has(rule.route_key)),
 		aggregations: catalogue.aggregations.filter((aggregation) => routeKeys.has(aggregation.route_key))
 	};
@@ -4983,13 +5057,11 @@ async function pushCatalogueToDirectus(catalogue, options) {
 	const pushedCollections = [
 		"predefined_values",
 		"routes",
-		"route_input_properties",
-		"route_output_properties",
+		"route_properties",
 		"backend_sources",
 		"backend_properties",
-		"mapping_evidence",
-		"route_input_properties_backend_properties",
-		"route_output_properties_backend_properties"
+		"mapping_evidences",
+		"route_properties_backend_properties"
 	];
 	const skippedCollections = [];
 	const catalogueToPush = selectCatalogueForDirectusPush(catalogue, options.routeSelector);
@@ -5055,7 +5127,13 @@ async function pushCatalogueToDirectus(catalogue, options) {
 				warnings.add(`UNKNOWN_BACKEND_PROPERTY_TYPE: ${backendProperty.direction} ${backendProperty.field}`);
 				continue;
 			}
-			const backendPropertyId = await upsertBackendProperty(client, backendProperty, backendRouteId, typeId);
+			let dataTypeId;
+			if (backendProperty.data_type) {
+				const dataTypeReference = await resolveDataTypeReference(client, refs, backendProperty.data_type);
+				dataTypeId = dataTypeReference.id;
+				if (dataTypeReference.created) pushedItems += 1;
+			}
+			const backendPropertyId = await upsertBackendProperty(client, backendProperty, backendRouteId, typeId, dataTypeId);
 			backendPropertyIds.set(backendProperty.key, backendPropertyId);
 			pushedItems += 1;
 		}
@@ -5067,18 +5145,18 @@ async function pushCatalogueToDirectus(catalogue, options) {
 				warnings.add(`UNKNOWN_IN_TYPE: ${property.field}`);
 				continue;
 			}
-			const inputPropertyId = await upsertInputProperty(client, property, routeId, inType);
+			const dataTypeReference = property.data_type ? await resolveDataTypeReference(client, refs, property.data_type) : void 0;
+			if (dataTypeReference?.created) pushedItems += 1;
+			const inputPropertyId = await upsertInputProperty(client, property, routeId, inType, dataTypeReference?.id);
 			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) {
-					if (await ensureInputLink(client, inputPropertyId, backendPropertyId)) pushedItems += 1;
-					await upsertMappingEvidence(client, evidence, {
-						inputPropertyId,
-						backendPropertyId
-					});
-					pushedItems += 1;
-				}
+				if (backendPropertyId && await ensureInputLink(client, inputPropertyId, backendPropertyId)) pushedItems += 1;
+				await upsertMappingEvidence(client, evidence, {
+					routePropertyId: inputPropertyId,
+					backendPropertyId
+				});
+				pushedItems += 1;
 			}
 		}
 		const routeOutputProperties = catalogueToPush.route_output_properties.filter((property) => property.route_key === route.key);
@@ -5089,18 +5167,18 @@ async function pushCatalogueToDirectus(catalogue, options) {
 				warnings.add("UNKNOWN_OUT_TYPE: RESPONSE_BODY");
 				continue;
 			}
-			const outputPropertyId = await upsertOutputProperty(client, property, routeId, outType);
+			const dataTypeReference = property.data_type ? await resolveDataTypeReference(client, refs, property.data_type) : void 0;
+			if (dataTypeReference?.created) pushedItems += 1;
+			const outputPropertyId = await upsertOutputProperty(client, property, routeId, outType, dataTypeReference?.id);
 			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) {
-					if (await ensureOutputLink(client, outputPropertyId, backendPropertyId)) pushedItems += 1;
-					await upsertMappingEvidence(client, evidence, {
-						outputPropertyId,
-						backendPropertyId
-					});
-					pushedItems += 1;
-				}
+				if (backendPropertyId && await ensureOutputLink(client, outputPropertyId, backendPropertyId)) pushedItems += 1;
+				await upsertMappingEvidence(client, evidence, {
+					routePropertyId: outputPropertyId,
+					backendPropertyId
+				});
+				pushedItems += 1;
 			}
 		}
 	}
@@ -5141,12 +5219,11 @@ function buildRouteReviewRelativePath(method, routePath) {
 	];
 	return path.join(resourceDir, versionDir, `${fileNameParts.join("_")}.yaml`);
 }
-function parseBackendRoute(route) {
-	const match = route.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|CALL)\s+(.+)$/);
-	if (!match || match[1] === "CALL" && match[2] === "unknown") return;
+function toHttpOperation(backendRoute) {
+	if (!backendRoute.route) return;
 	return {
-		method: match[1] === "CALL" ? null : match[1],
-		route: match[2]
+		method: backendRoute.method || null,
+		route: backendRoute.route
 	};
 }
 function buildReviewProperty(property) {
@@ -5155,6 +5232,7 @@ function buildReviewProperty(property) {
 		field: mapping.field,
 		document: mapping.document,
 		description: mapping.description,
+		...pickPropertyMetadata(mapping),
 		source: mapping.source_file,
 		...mapping.route && (mapping.route !== "unknown" || mapping.method) ? { operation: {
 			method: mapping.method || null,
@@ -5195,6 +5273,7 @@ function buildReviewProperty(property) {
 		source: property.source_file,
 		evidence_status: property.evidence_status,
 		transversal: property.transversal,
+		...pickPropertyMetadata(property),
 		...hasMapping ? { mapping } : {},
 		...suggestions?.length || unresolvedBackendCandidates?.length ? { review: {
 			...suggestions?.length ? { suggestions } : {},
@@ -5211,7 +5290,7 @@ function buildRouteReviewDocument(catalogue, routeKey) {
 	const datasources = backendRoutes.map((backendRoute) => ({
 		type: backendRoute.backend,
 		source: backendRoute.source_file,
-		...parseBackendRoute(backendRoute.route ?? "") ? { operation: parseBackendRoute(backendRoute.route ?? "") } : {},
+		...backendRoute.resource_type === "document" ? { document: backendRoute.document } : toHttpOperation(backendRoute) ? { operation: toHttpOperation(backendRoute) } : {},
 		...backendRoute.provenance === "ai" ? { provenance: backendRoute.provenance } : {}
 	}));
 	for (const backend of route.backends) if (!datasources.some((datasource) => datasource.type === backend) && !mappedBackendTypes.has(backend)) datasources.push({
@@ -5327,14 +5406,16 @@ async function writeCatalogueArtifacts(catalogue, outputDir, repoRoot = process.
 	};
 }
 function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backendRoutesByKey, backendPropertiesByKey, mappingEvidence) {
-	const backendRoute = mapping.route || (mapping.document ? `DOCUMENT ${mapping.document}` : "unknown");
-	const backendRouteKey = stableKey(routeKey, mapping.backend, backendRoute);
+	const backendSourceId = mapping.document || mapping.route || "";
+	const backendRouteKey = stableKey(routeKey, mapping.backend, backendSourceId);
 	const backendRouteRecord = backendRoutesByKey.get(backendRouteKey) || {
 		key: backendRouteKey,
 		backend: mapping.backend,
 		route_key: routeKey,
-		resource_type: "http",
-		route: `${mapping.method || "CALL"} ${backendRoute}`,
+		resource_type: mapping.document ? "document" : "http",
+		method: mapping.document ? void 0 : mapping.method || void 0,
+		route: mapping.document ? void 0 : mapping.route || void 0,
+		document: mapping.document || void 0,
 		source_file: mapping.source_file,
 		provenance: "code_analysis"
 	};
@@ -5345,6 +5426,8 @@ function addBackendMapping(routeKey, direction, apiPropertyKey, mapping, backend
 		backend_route_key: backendRouteKey,
 		backend: mapping.backend,
 		field: mapping.field,
+		description: mapping.description,
+		...pickPropertyMetadata(mapping),
 		direction,
 		source_file: mapping.source_file,
 		provenance: mapping.provenance || "code_analysis"
@@ -5368,6 +5451,7 @@ function toCatalogueBackendMapping(mapping) {
 		field: mapping.field,
 		document: mapping.document,
 		description: mapping.description,
+		...pickPropertyMetadata(mapping),
 		source_file: mapping.source,
 		confidence: mapping.confidence,
 		mapper_type: mapping.mapper_type,
@@ -5376,14 +5460,25 @@ function toCatalogueBackendMapping(mapping) {
 	};
 }
 function addDatasourceRoute(routeKey, datasource, backendRoutesByKey) {
-	const backendRoute = datasource.operation?.route || "unknown";
-	const backendRouteKey = stableKey(routeKey, datasource.type, backendRoute);
-	backendRoutesByKey.set(backendRouteKey, {
+	const isDocument = datasource.document !== void 0;
+	if (!isDocument && !datasource.operation) return;
+	const sourceId = isDocument ? datasource.document : datasource.operation?.route || "";
+	const backendRouteKey = stableKey(routeKey, datasource.type, sourceId);
+	backendRoutesByKey.set(backendRouteKey, isDocument ? {
+		key: backendRouteKey,
+		backend: datasource.type,
+		route_key: routeKey,
+		resource_type: "document",
+		document: datasource.document,
+		source_file: datasource.source,
+		provenance: datasource.provenance || "code_analysis"
+	} : {
 		key: backendRouteKey,
 		backend: datasource.type,
 		route_key: routeKey,
 		resource_type: "http",
-		route: `${datasource.operation?.method || "CALL"} ${backendRoute}`,
+		method: datasource.operation?.method || void 0,
+		route: datasource.operation?.route || void 0,
 		source_file: datasource.source,
 		provenance: datasource.provenance || "code_analysis"
 	});
@@ -5422,12 +5517,13 @@ function mergeRouteReviewDocuments(documents) {
 					field: property.field,
 					domain_field: property.mapping?.domain?.field,
 					transversal: property.transversal,
+					...pickPropertyMetadata(property),
 					backend_names: [...new Set(backendMappings.map((mapping) => mapping.backend))],
 					backend_mappings: backendMappings,
 					inference_suggestions: property.review?.suggestions?.map((suggestion) => ({
 						backend: suggestion.type,
 						method: suggestion.operation?.method || null,
-						route: suggestion.operation?.route || "unknown",
+						route: suggestion.operation?.route || "",
 						field: suggestion.field,
 						source_file: suggestion.source,
 						confidence: suggestion.confidence,
@@ -5550,7 +5646,10 @@ function parseRouteSelector(value) {
 //#endregion
 //#region src/commands/push.ts
 function formatPushError(error) {
-	if (error instanceof Error) return error.message;
+	if (error instanceof Error) {
+		const cause = isRecord$1(error) ? error.cause : void 0;
+		return cause === void 0 ? error.message : `${error.message}; ${formatPushError(cause)}`;
+	}
 	if (!isRecord$1(error)) return String(error);
 	const details = (Array.isArray(error.errors) ? error.errors : []).flatMap((item) => {
 		if (!isRecord$1(item) || typeof item.message !== "string") return [];
@@ -23166,16 +23265,20 @@ function findBackendRoute(document, suggestion) {
 }
 function ensureBackendRoute(catalogue, document, suggestion) {
 	const candidate = findBackendRoute(document, suggestion);
-	const backendRoutePath = candidate?.route || "unknown";
-	const key = stableKey(document.key, suggestion.candidate.backend, backendRoutePath);
+	const resolvedProp = suggestion.candidate.resolvedProperty;
+	const isDocument = resolvedProp !== void 0 && "document" in resolvedProp;
+	const sourceId = isDocument ? resolvedProp.document : candidate?.route || "";
+	const key = stableKey(document.key, suggestion.candidate.backend, sourceId);
 	const existing = catalogue.backend_routes.find((route) => route.key === key);
 	if (existing) return existing;
 	const created = {
 		key,
 		backend: suggestion.candidate.backend,
 		route_key: document.key,
-		resource_type: "http",
-		route: `${candidate?.method || "CALL"} ${backendRoutePath}`,
+		resource_type: isDocument ? "document" : "http",
+		method: isDocument ? void 0 : candidate?.method || void 0,
+		route: isDocument ? void 0 : candidate?.route || void 0,
+		document: isDocument ? resolvedProp.document : void 0,
 		source_file: candidate?.sourceFile || suggestion.candidate.sourceFile,
 		provenance: "ai"
 	};
@@ -23207,20 +23310,28 @@ function applySuggestion(catalogue, document, property, suggestion) {
 	const backendRouteCandidate = findBackendRoute(document, suggestion);
 	const backendRoute = ensureBackendRoute(catalogue, document, suggestion);
 	const backendPropertyKey = stableKey(backendRoute.key, property.direction, suggestion.candidate.backendField);
+	const resolvedProp = suggestion.candidate.resolvedProperty;
+	const resolvedDocument = resolvedProp && "document" in resolvedProp ? resolvedProp.document : void 0;
 	if (!catalogue.backend_properties.some((item) => item.key === backendPropertyKey)) catalogue.backend_properties.push({
 		key: backendPropertyKey,
 		backend_route_key: backendRoute.key,
 		backend: suggestion.candidate.backend,
 		field: suggestion.candidate.backendField,
+		description: resolvedProp?.description,
+		...pickPropertyMetadata(resolvedProp),
 		direction: property.direction,
 		source_file: candidateSource(suggestion.candidate),
 		provenance: "ai"
 	});
 	if (!property.backend_mappings.some((mapping) => mapping.backend === suggestion.candidate.backend && mapping.field === suggestion.candidate.backendField)) property.backend_mappings.push({
 		backend: suggestion.candidate.backend,
-		method: backendRouteCandidate?.method || null,
-		route: backendRouteCandidate?.route || "unknown",
+		...resolvedDocument ? { document: resolvedDocument } : {
+			method: backendRouteCandidate?.method || null,
+			route: backendRouteCandidate?.route || ""
+		},
 		field: suggestion.candidate.backendField,
+		description: resolvedProp?.description,
+		...pickPropertyMetadata(resolvedProp),
 		source_file: candidateSource(suggestion.candidate),
 		confidence: suggestion.confidence,
 		mapper_type: suggestion.candidate.mapperType,
@@ -23247,7 +23358,7 @@ function recordReviewSuggestion(document, property, suggestion) {
 	property.inference_suggestions.push({
 		backend: suggestion.candidate.backend,
 		method: backendRouteCandidate?.method || null,
-		route: backendRouteCandidate?.route || "unknown",
+		route: backendRouteCandidate?.route || "",
 		field: suggestion.candidate.backendField,
 		source_file: candidateSource(suggestion.candidate),
 		confidence: suggestion.confidence,
@@ -23379,11 +23490,13 @@ async function inferCatalogueDirectory(params) {
 			input: catalogue.route_input_properties.filter((property) => property.route_key === routeKey).map((property) => ({
 				path: property.field,
 				description: property.description,
+				type: property.data_type,
 				location: "body"
 			})),
 			output: catalogue.route_output_properties.filter((property) => property.route_key === routeKey).map((property) => ({
 				path: property.field,
 				description: property.description,
+				type: property.data_type,
 				location: "body"
 			}))
 		}]]);