@dbt-tools/core 0.3.2

package/dist/analysis/manifest-graph.js

@@ -0,0 +1,651 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestGraph = void 0;
+const graphology_1 = require("graphology");
+const graphology_dag_1 = require("graphology-dag");
+const version_1 = require("../version");
+function getManifestMetrics(manifest) {
+    return manifest.metrics;
+}
+function getManifestSemanticModels(manifest) {
+    return manifest.semantic_models;
+}
+function getManifestUnitTests(manifest) {
+    return manifest.unit_tests;
+}
+/**
+ * ManifestGraph builds and manages a directed graph from a dbt manifest.
+ *
+ * This class transforms dbt artifacts into a graphology graph, enabling
+ * efficient graph operations like cycle detection, path finding, and traversal.
+ */
+class ManifestGraph {
+    constructor(manifest) {
+        this.relationMap = new Map(); // relation_name -> unique_id
+        if (!(0, version_1.isSupportedVersion)(manifest)) {
+            const versionInfo = (0, version_1.getVersionInfo)(manifest);
+            throw new Error(`Unsupported dbt version. ` +
+                `Schema version: ${versionInfo.schema_version || "unknown"}, ` +
+                `dbt version: ${versionInfo.dbt_version || "unknown"}. ` +
+                `Requires dbt 1.10+ (manifest schema v${version_1.MIN_SUPPORTED_SCHEMA_VERSION}+)`);
+        }
+        this.graph = new graphology_1.DirectedGraph();
+        this.buildGraph(manifest);
+    }
+    /**
+     * Build the graph from manifest data
+     */
+    buildGraph(manifest) {
+        // Add all nodes from manifest
+        this.addNodes(manifest);
+        // Add edges based on dependencies
+        this.addEdges(manifest);
+    }
+    /**
+     * Add nodes from manifest to the graph
+     */
+    /** Map relation_name (lowercase) to unique_id when present on manifest entries. */
+    registerRelationName(uniqueId, relationName) {
+        if (!relationName)
+            return;
+        this.relationMap.set(relationName.toLowerCase(), uniqueId);
+    }
+    addNodes(manifest) {
+        this.addNodeEntries(manifest.nodes);
+        this.addSourceEntries(manifest.sources);
+        this.addMacroEntries(manifest.macros);
+        this.addExposureEntries(manifest.exposures);
+        this.addMetricEntries(getManifestMetrics(manifest));
+        this.addSemanticModelEntries(getManifestSemanticModels(manifest));
+        this.addUnitTestEntries(getManifestUnitTests(manifest));
+    }
+    addNodeEntries(nodes) {
+        if (!nodes)
+            return;
+        for (const [uniqueId, node] of Object.entries(nodes)) {
+            const nodeAny = node;
+            const resourceType = this.extractResourceType(nodeAny.resource_type || "model");
+            const config = nodeAny.config;
+            const materializedRaw = config === null || config === void 0 ? void 0 : config.materialized;
+            const materialized = typeof materializedRaw === "string" && materializedRaw.trim() !== ""
+                ? materializedRaw
+                : undefined;
+            this.graph.addNode(uniqueId, Object.assign({ unique_id: uniqueId, resource_type: resourceType, name: nodeAny.name || uniqueId, package_name: nodeAny.package_name || "", path: nodeAny.path || undefined, original_file_path: nodeAny.original_file_path || undefined, patch_path: nodeAny.patch_path || undefined, database: nodeAny.database || undefined, schema: nodeAny.schema || undefined, tags: nodeAny.tags || undefined, description: nodeAny.description || undefined, compiled_code: nodeAny.compiled_code || undefined, raw_code: nodeAny.raw_code ||
+                    nodeAny.raw_sql ||
+                    undefined }, (materialized != null ? { materialized } : {})));
+            this.registerRelationName(uniqueId, nodeAny.relation_name);
+        }
+    }
+    addSourceEntries(sources) {
+        if (!sources)
+            return;
+        for (const [uniqueId, source] of Object.entries(sources)) {
+            const sourceAny = source;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "source",
+                name: sourceAny.name || uniqueId,
+                package_name: sourceAny.package_name || "",
+                path: sourceAny.path || undefined,
+                original_file_path: sourceAny.original_file_path || undefined,
+                tags: sourceAny.tags || undefined,
+                description: sourceAny.description || undefined,
+            });
+            this.registerRelationName(uniqueId, sourceAny.relation_name);
+        }
+    }
+    addMacroEntries(macros) {
+        if (!macros)
+            return;
+        for (const [uniqueId, macro] of Object.entries(macros)) {
+            const macroAny = macro;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "macro",
+                name: macroAny.name || uniqueId,
+                package_name: macroAny.package_name || "",
+                path: macroAny.path || undefined,
+                original_file_path: macroAny.original_file_path || undefined,
+                description: macroAny.description || undefined,
+                raw_code: macroAny.macro_sql || undefined,
+            });
+        }
+    }
+    addExposureEntries(exposures) {
+        if (!exposures)
+            return;
+        for (const [uniqueId, exposure] of Object.entries(exposures)) {
+            const exposureAny = exposure;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "exposure",
+                name: exposureAny.name || uniqueId,
+                package_name: exposureAny.package_name || "",
+                tags: exposureAny.tags || undefined,
+                description: exposureAny.description || undefined,
+            });
+        }
+    }
+    addMetricEntries(metrics) {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        if (!metrics)
+            return;
+        for (const [uniqueId, metric] of Object.entries(metrics)) {
+            const metricAny = metric;
+            const tagsValue = metricAny.tags;
+            const tags = Array.isArray(tagsValue)
+                ? tagsValue
+                : typeof tagsValue === "string"
+                    ? [tagsValue]
+                    : undefined;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "metric",
+                name: metricAny.name || uniqueId,
+                package_name: metricAny.package_name || "",
+                path: metricAny.path || undefined,
+                original_file_path: metricAny.original_file_path || undefined,
+                description: metricAny.description || undefined,
+                label: metricAny.label || undefined,
+                metric_type: metricAny.type || undefined,
+                metric_expression: ((_a = metricAny.type_params) === null || _a === void 0 ? void 0 : _a.expr) || undefined,
+                metric_measure: ((_c = (_b = metricAny.type_params) === null || _b === void 0 ? void 0 : _b.measure) === null || _c === void 0 ? void 0 : _c.name) || undefined,
+                metric_input_measures: Array.isArray((_d = metricAny.type_params) === null || _d === void 0 ? void 0 : _d.input_measures)
+                    ? metricAny.type_params
+                        .input_measures
+                        .map((entry) => entry.name)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+                metric_input_metrics: Array.isArray((_e = metricAny.type_params) === null || _e === void 0 ? void 0 : _e.metrics)
+                    ? metricAny.type_params
+                        .metrics
+                        .map((entry) => entry.name)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+                metric_time_granularity: metricAny.time_granularity || undefined,
+                metric_filters: Array.isArray((_f = metricAny.filter) === null || _f === void 0 ? void 0 : _f.where_filters)
+                    ? metricAny.filter
+                        .where_filters
+                        .map((entry) => entry.where_sql_template)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+                metric_source_reference: ((_h = (_g = metricAny.depends_on) === null || _g === void 0 ? void 0 : _g.nodes) === null || _h === void 0 ? void 0 : _h[0]) || undefined,
+                tags,
+            });
+        }
+    }
+    addSemanticModelEntries(semanticModels) {
+        var _a;
+        if (!semanticModels)
+            return;
+        for (const [uniqueId, semanticModel] of Object.entries(semanticModels)) {
+            const sm = semanticModel;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "semantic_model",
+                name: sm.name || uniqueId,
+                package_name: sm.package_name || "",
+                path: sm.path || undefined,
+                original_file_path: sm.original_file_path || undefined,
+                description: sm.description || undefined,
+                label: sm.label || undefined,
+                semantic_model_reference: sm.model || undefined,
+                semantic_model_default_time_dimension: ((_a = sm.defaults) === null || _a === void 0 ? void 0 : _a.agg_time_dimension) || undefined,
+                semantic_model_entities: Array.isArray(sm.entities)
+                    ? sm.entities
+                        .map((entry) => entry.name)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+                semantic_model_measures: Array.isArray(sm.measures)
+                    ? sm.measures
+                        .map((entry) => entry.name)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+                semantic_model_dimensions: Array.isArray(sm.dimensions)
+                    ? sm.dimensions
+                        .map((entry) => entry.name)
+                        .filter((entry) => typeof entry === "string")
+                    : undefined,
+            });
+        }
+    }
+    addUnitTestEntries(unitTests) {
+        if (!unitTests)
+            return;
+        for (const [uniqueId, unitTest] of Object.entries(unitTests)) {
+            const ut = unitTest;
+            this.graph.addNode(uniqueId, {
+                unique_id: uniqueId,
+                resource_type: "unit_test",
+                name: ut.name || uniqueId,
+                package_name: ut.package_name || "",
+            });
+        }
+    }
+    /**
+     * Add edges based on dependencies
+     */
+    addEdges(manifest) {
+        if (manifest.parent_map) {
+            this.addEdgesFromParentMap(manifest.parent_map);
+        }
+        this.addEdgesFromNodeDependsOn(manifest.nodes);
+        this.addEdgesFromExposureDependsOn(manifest.exposures);
+        this.addEdgesFromMetricDependsOn(getManifestMetrics(manifest));
+    }
+    addEdgesFromParentMap(parentMap) {
+        for (const [childId, parentIds] of Object.entries(parentMap)) {
+            if (!this.graph.hasNode(childId))
+                continue;
+            for (const parentId of parentIds) {
+                if (this.graph.hasNode(parentId) &&
+                    !this.graph.hasEdge(parentId, childId)) {
+                    this.graph.addEdge(parentId, childId, {
+                        dependency_type: this.inferDependencyType(parentId),
+                    });
+                }
+            }
+        }
+    }
+    addEdgesFromDependsOn(childId, dependsOn) {
+        if (dependsOn.nodes) {
+            for (const depId of dependsOn.nodes) {
+                if (this.graph.hasNode(depId) && !this.graph.hasEdge(depId, childId)) {
+                    this.graph.addEdge(depId, childId, { dependency_type: "node" });
+                }
+            }
+        }
+        if (dependsOn.macros) {
+            for (const macroId of dependsOn.macros) {
+                if (this.graph.hasNode(macroId) &&
+                    !this.graph.hasEdge(macroId, childId)) {
+                    this.graph.addEdge(macroId, childId, { dependency_type: "macro" });
+                }
+            }
+        }
+    }
+    addEdgesFromNodeDependsOn(nodes) {
+        if (!nodes)
+            return;
+        for (const [uniqueId, node] of Object.entries(nodes)) {
+            const dep = node.depends_on;
+            if (dep)
+                this.addEdgesFromDependsOn(uniqueId, dep);
+        }
+    }
+    addEdgesFromExposureDependsOn(exposures) {
+        if (!exposures)
+            return;
+        for (const [uniqueId, exposure] of Object.entries(exposures)) {
+            const dep = exposure.depends_on;
+            if (dep === null || dep === void 0 ? void 0 : dep.nodes)
+                this.addEdgesFromDependsOn(uniqueId, dep);
+        }
+    }
+    addEdgesFromMetricDependsOn(metrics) {
+        if (!metrics)
+            return;
+        for (const [uniqueId, metric] of Object.entries(metrics)) {
+            const dep = metric.depends_on;
+            if (dep === null || dep === void 0 ? void 0 : dep.nodes)
+                this.addEdgesFromDependsOn(uniqueId, dep);
+        }
+    }
+    /**
+     * Extract resource type from manifest node
+     */
+    extractResourceType(resourceType) {
+        const normalized = resourceType.toLowerCase();
+        if ([
+            "model",
+            "source",
+            "seed",
+            "snapshot",
+            "test",
+            "analysis",
+            "macro",
+            "exposure",
+            "metric",
+            "semantic_model",
+            "unit_test",
+            "function",
+        ].includes(normalized)) {
+            return normalized;
+        }
+        return "model"; // Default fallback
+    }
+    /**
+     * Infer dependency type from node ID
+     */
+    inferDependencyType(nodeId) {
+        if (nodeId.startsWith("macro.")) {
+            return "macro";
+        }
+        if (nodeId.startsWith("source.")) {
+            return "source";
+        }
+        return "node";
+    }
+    /**
+     * Get the underlying graphology graph
+     */
+    getGraph() {
+        return this.graph;
+    }
+    /**
+     * Get summary statistics about the graph
+     */
+    getSummary() {
+        const nodesByType = {};
+        let totalNodes = 0;
+        // Count nodes by type
+        this.graph.forEachNode((nodeId, attributes) => {
+            totalNodes++;
+            const type = attributes.resource_type || "unknown";
+            nodesByType[type] = (nodesByType[type] || 0) + 1;
+        });
+        // Detect cycles using graphology-dag
+        const hasCycles = (0, graphology_dag_1.hasCycle)(this.graph);
+        return {
+            total_nodes: totalNodes,
+            nodes_by_type: nodesByType,
+            total_edges: this.graph.size,
+            has_cycles: hasCycles,
+        };
+    }
+    /**
+     * Get all upstream dependencies of a node using BFS.
+     * @param nodeId - The node to find upstream dependencies for
+     * @param maxDepth - Optional limit; 1 = immediate neighbors only, undefined = all levels
+     * @returns Array of { nodeId, depth } where depth is the shortest distance from the node
+     */
+    getUpstream(nodeId, maxDepth) {
+        if (!this.graph.hasNode(nodeId)) {
+            return [];
+        }
+        const result = [];
+        const visited = new Set();
+        const queue = [];
+        let head = 0;
+        for (const neighborId of this.graph.inboundNeighbors(nodeId)) {
+            if (!visited.has(neighborId)) {
+                visited.add(neighborId);
+                result.push({ nodeId: neighborId, depth: 1 });
+                if (maxDepth === undefined || 1 < maxDepth) {
+                    queue.push({ id: neighborId, depth: 1 });
+                }
+            }
+        }
+        while (head < queue.length) {
+            const { id, depth } = queue[head++];
+            const nextDepth = depth + 1;
+            for (const neighborId of this.graph.inboundNeighbors(id)) {
+                if (!visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    result.push({ nodeId: neighborId, depth: nextDepth });
+                    if (maxDepth === undefined || nextDepth < maxDepth) {
+                        queue.push({ id: neighborId, depth: nextDepth });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get all downstream dependents of a node using BFS.
+     * @param nodeId - The node to find downstream dependents for
+     * @param maxDepth - Optional limit; 1 = immediate neighbors only, undefined = all levels
+     * @returns Array of { nodeId, depth } where depth is the shortest distance from the node
+     */
+    getDownstream(nodeId, maxDepth) {
+        if (!this.graph.hasNode(nodeId)) {
+            return [];
+        }
+        const result = [];
+        const visited = new Set();
+        const queue = [];
+        let head = 0;
+        for (const neighborId of this.graph.outboundNeighbors(nodeId)) {
+            if (!visited.has(neighborId)) {
+                visited.add(neighborId);
+                result.push({ nodeId: neighborId, depth: 1 });
+                if (maxDepth === undefined || 1 < maxDepth) {
+                    queue.push({ id: neighborId, depth: 1 });
+                }
+            }
+        }
+        while (head < queue.length) {
+            const { id, depth } = queue[head++];
+            const nextDepth = depth + 1;
+            for (const neighborId of this.graph.outboundNeighbors(id)) {
+                if (!visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    result.push({ nodeId: neighborId, depth: nextDepth });
+                    if (maxDepth === undefined || nextDepth < maxDepth) {
+                        queue.push({ id: neighborId, depth: nextDepth });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get upstream dependencies with parent info for tree construction.
+     * @returns Array of { nodeId, depth, parentId } where parentId is the BFS predecessor
+     */
+    getUpstreamWithParents(nodeId, maxDepth) {
+        if (!this.graph.hasNode(nodeId)) {
+            return [];
+        }
+        const result = [];
+        const visited = new Set();
+        const queue = [];
+        for (const neighborId of this.graph.inboundNeighbors(nodeId)) {
+            if (!visited.has(neighborId)) {
+                visited.add(neighborId);
+                result.push({ nodeId: neighborId, depth: 1, parentId: nodeId });
+                if (maxDepth === undefined || 1 < maxDepth) {
+                    queue.push({ id: neighborId, depth: 1, parentId: nodeId });
+                }
+            }
+        }
+        while (queue.length > 0) {
+            const { id, depth } = queue.shift();
+            const nextDepth = depth + 1;
+            for (const neighborId of this.graph.inboundNeighbors(id)) {
+                if (!visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    result.push({ nodeId: neighborId, depth: nextDepth, parentId: id });
+                    if (maxDepth === undefined || nextDepth < maxDepth) {
+                        queue.push({ id: neighborId, depth: nextDepth, parentId: id });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get upstream dependencies in build order (topological sort).
+     * Sources and root models first, then models that depend on them.
+     * @param nodeId - The node to find upstream dependencies for
+     * @param maxDepth - Optional limit; 1 = immediate neighbors only, undefined = all levels
+     * @returns Array of { nodeId, depth } in build order
+     */
+    getUpstreamBuildOrder(nodeId, maxDepth) {
+        const entries = this.getUpstream(nodeId, maxDepth);
+        if (entries.length === 0) {
+            return [];
+        }
+        const nodeIds = new Set(entries.map((e) => e.nodeId));
+        const depthByNode = new Map(entries.map((e) => [e.nodeId, e.depth]));
+        const subgraph = new graphology_1.DirectedGraph();
+        for (const nid of nodeIds) {
+            subgraph.addNode(nid, this.graph.getNodeAttributes(nid));
+        }
+        this.graph.forEachEdge((_edge, attr, source, target) => {
+            if (nodeIds.has(source) && nodeIds.has(target)) {
+                if (!subgraph.hasEdge(source, target)) {
+                    subgraph.addEdge(source, target, attr);
+                }
+            }
+        });
+        const orderedIds = (0, graphology_dag_1.topologicalSort)(subgraph);
+        return orderedIds.map((nid) => {
+            var _a;
+            return ({
+                nodeId: nid,
+                depth: (_a = depthByNode.get(nid)) !== null && _a !== void 0 ? _a : 0,
+            });
+        });
+    }
+    /**
+     * Get downstream dependents with parent info for tree construction.
+     * @returns Array of { nodeId, depth, parentId } where parentId is the BFS predecessor
+     */
+    getDownstreamWithParents(nodeId, maxDepth) {
+        if (!this.graph.hasNode(nodeId)) {
+            return [];
+        }
+        const result = [];
+        const visited = new Set();
+        const queue = [];
+        for (const neighborId of this.graph.outboundNeighbors(nodeId)) {
+            if (!visited.has(neighborId)) {
+                visited.add(neighborId);
+                result.push({ nodeId: neighborId, depth: 1, parentId: nodeId });
+                if (maxDepth === undefined || 1 < maxDepth) {
+                    queue.push({ id: neighborId, depth: 1, parentId: nodeId });
+                }
+            }
+        }
+        while (queue.length > 0) {
+            const { id, depth } = queue.shift();
+            const nextDepth = depth + 1;
+            for (const neighborId of this.graph.outboundNeighbors(id)) {
+                if (!visited.has(neighborId)) {
+                    visited.add(neighborId);
+                    result.push({ nodeId: neighborId, depth: nextDepth, parentId: id });
+                    if (maxDepth === undefined || nextDepth < maxDepth) {
+                        queue.push({ id: neighborId, depth: nextDepth, parentId: id });
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Add field nodes from catalog metadata
+     */
+    addFieldNodes(catalog) {
+        if (catalog.nodes) {
+            for (const [uniqueId, node] of Object.entries(catalog.nodes)) {
+                if (this.graph.hasNode(uniqueId)) {
+                    const columns = node
+                        .columns;
+                    this.processCatalogColumns(uniqueId, columns);
+                }
+            }
+        }
+        if (catalog.sources) {
+            for (const [uniqueId, source] of Object.entries(catalog.sources)) {
+                if (this.graph.hasNode(uniqueId)) {
+                    const columns = source
+                        .columns;
+                    this.processCatalogColumns(uniqueId, columns);
+                }
+            }
+        }
+    }
+    processCatalogColumns(parentUniqueId, columns) {
+        var _a;
+        if (!columns)
+            return;
+        const parentNode = this.graph.getNodeAttributes(parentUniqueId);
+        for (const [colName, colAttr] of Object.entries(columns)) {
+            const fieldUniqueId = `${parentUniqueId}#${colName}`;
+            const attr = colAttr;
+            const description = (_a = attr === null || attr === void 0 ? void 0 : attr.comment) !== null && _a !== void 0 ? _a : attr === null || attr === void 0 ? void 0 : attr.description;
+            // Add field node if it doesn't exist
+            if (!this.graph.hasNode(fieldUniqueId)) {
+                this.graph.addNode(fieldUniqueId, {
+                    unique_id: fieldUniqueId,
+                    resource_type: "field",
+                    name: colName,
+                    package_name: parentNode.package_name,
+                    parent_id: parentUniqueId,
+                    description,
+                });
+                // Add internal edge from parent to field
+                this.graph.addEdge(parentUniqueId, fieldUniqueId, {
+                    dependency_type: "internal",
+                });
+            }
+        }
+    }
+    /**
+     * Add field-to-field edges based on SQL analysis
+     */
+    addFieldEdges(childNodeId, dependencies) {
+        if (!this.graph.hasNode(childNodeId))
+            return;
+        for (const [targetCol, sourceCols] of Object.entries(dependencies)) {
+            const targetFieldId = `${childNodeId}#${targetCol}`;
+            // Ensure target field node exists
+            this.ensureFieldNode(childNodeId, targetCol);
+            for (const source of sourceCols) {
+                // Resolve source table name/relation name to unique ID
+                const sourceNodeId = this.resolveRelationToUniqueId(source.sourceTable);
+                if (!sourceNodeId)
+                    continue;
+                const sourceFieldId = `${sourceNodeId}#${source.sourceColumn}`;
+                this.ensureFieldNode(sourceNodeId, source.sourceColumn);
+                // Add field edge from source field to target field
+                if (!this.graph.hasEdge(sourceFieldId, targetFieldId)) {
+                    this.graph.addEdge(sourceFieldId, targetFieldId, {
+                        dependency_type: "field",
+                    });
+                }
+            }
+        }
+    }
+    ensureFieldNode(parentNodeId, colName) {
+        const fieldId = `${parentNodeId}#${colName}`;
+        if (!this.graph.hasNode(fieldId)) {
+            const parentAttr = this.graph.getNodeAttributes(parentNodeId);
+            this.graph.addNode(fieldId, {
+                unique_id: fieldId,
+                resource_type: "field",
+                name: colName,
+                package_name: parentAttr.package_name,
+                parent_id: parentNodeId,
+            });
+            // Add internal edge
+            this.graph.addEdge(parentNodeId, fieldId, {
+                dependency_type: "internal",
+            });
+        }
+        return fieldId;
+    }
+    resolveRelationToUniqueId(relationName) {
+        // Try exact match
+        const normalized = relationName.toLowerCase();
+        if (this.relationMap.has(normalized)) {
+            return this.relationMap.get(normalized);
+        }
+        // Try stripping quotes if any
+        const unquoted = normalized.replace(/["`]/g, "");
+        if (this.relationMap.has(unquoted)) {
+            return this.relationMap.get(unquoted);
+        }
+        // Try partial match if it's just the table name (alias)
+        // We also strip quotes from the mapped relations for comparison
+        for (const [rel, uid] of this.relationMap.entries()) {
+            const relUnquoted = rel.replace(/["`]/g, "");
+            if (relUnquoted.endsWith(`.${unquoted}`) || relUnquoted === unquoted) {
+                return uid;
+            }
+        }
+        return undefined;
+    }
+}
+exports.ManifestGraph = ManifestGraph;