@terra-graph/core 1.0.0-rc.4

package/dist/cjs/Graph/Adapters/GraphologyAdapter.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphologyAdapter = exports.GraphAttributeKey = void 0;
+const graphology_1 = require("graphology");
+const JsonRenderer_js_1 = require("../Renderers/JsonRenderer.js");
+const TgGraph_js_1 = require("../TgGraph.js");
+var GraphAttributeKey;
+(function (GraphAttributeKey) {
+    GraphAttributeKey["Description"] = "tg:description";
+    GraphAttributeKey["SchemaVersion"] = "tg:schemaVersion";
+})(GraphAttributeKey || (exports.GraphAttributeKey = GraphAttributeKey = {}));
+class GraphologyAdapter {
+    graph;
+    constructor(graph = new graphology_1.DirectedGraph()) {
+        this.graph = graph;
+    }
+    withTgGraph(tg) {
+        return this.mutateGraph((graph) => {
+            for (const node of Object.values(tg.nodes)) {
+                graph.addNode(node.id, node);
+            }
+            for (const edge of tg.edges) {
+                graph.addEdgeWithKey(edge.id, edge.from, edge.to, edge.attributes ?? {});
+            }
+            graph.setAttribute(GraphAttributeKey.Description, tg.description);
+            graph.setAttribute(GraphAttributeKey.SchemaVersion, tg.schemaVersion ?? TgGraph_js_1.TG_SCHEMA_VERSION);
+        });
+    }
+    toTgGraph() {
+        const nodes = {};
+        const edges = [];
+        this.graph.forEachNode((nodeId, attributes) => {
+            const id = (0, TgGraph_js_1.asNodeId)(nodeId);
+            const parsed = (0, TgGraph_js_1.parseTgNodeId)(id);
+            const attrRecord = attributes;
+            const { label: _ignoredLabel, terraform: rawTerraform, ...rest } = attrRecord;
+            const node = {
+                id,
+                ...rest,
+            };
+            const terraform = this.resolveTerraform(rawTerraform, parsed?.kind, parsed?.address);
+            if (terraform) {
+                node.terraform = terraform;
+            }
+            nodes[nodeId] = node;
+        });
+        this.graph.forEachEdge((edgeId, attributes, source, target) => {
+            edges.push({
+                id: edgeId,
+                from: source,
+                to: target,
+                attributes,
+            });
+        });
+        const description = this.readGraphAttribute(GraphAttributeKey.Description, {});
+        const schemaVersion = this.readGraphAttribute(GraphAttributeKey.SchemaVersion, TgGraph_js_1.TG_SCHEMA_VERSION);
+        return {
+            schemaVersion,
+            nodes,
+            edges,
+            description,
+        };
+    }
+    getRenderer(_options) {
+        return new JsonRenderer_js_1.JsonRenderer();
+    }
+    getGraph() {
+        return this.graph.copy();
+    }
+    getNodeAttributes(nodeId) {
+        if (!this.graph.hasNode(nodeId)) {
+            return undefined;
+        }
+        return this.graph.getNodeAttributes(nodeId);
+    }
+    getEdgeAttributes(edgeId) {
+        return this.graph.getEdgeAttributes(edgeId);
+    }
+    edgeSource(edgeId) {
+        return this.graph.source(edgeId);
+    }
+    edgeTarget(edgeId) {
+        return this.graph.target(edgeId);
+    }
+    nodeIds() {
+        return this.graph.nodes();
+    }
+    neighbors(nodeId) {
+        return this.graph.neighbors(nodeId);
+    }
+    predecessors(nodeId) {
+        return this.graph.inNeighbors(nodeId);
+    }
+    successors(nodeId) {
+        return this.graph.outNeighbors(nodeId);
+    }
+    inEdges(nodeId) {
+        return this.graph.inEdges(nodeId);
+    }
+    outEdges(nodeId) {
+        return this.graph.outEdges(nodeId);
+    }
+    edgesBetween(source, target) {
+        return this.graph.edges(source, target);
+    }
+    setNodeAttributes(nodeId, attributes) {
+        return this.mutateGraph((graph) => {
+            graph.mergeNode(nodeId, attributes);
+        });
+    }
+    setEdge(edgeId, source, target, attributes) {
+        return this.mutateGraph((graph) => {
+            graph.mergeEdgeWithKey(edgeId, source, target, attributes);
+        });
+    }
+    removeNode(nodeId) {
+        return this.mutateGraph((graph) => {
+            graph.dropNode(nodeId);
+        });
+    }
+    removeEdge(edgeId) {
+        return this.mutateGraph((graph) => {
+            graph.dropEdge(edgeId);
+        });
+    }
+    readGraphAttribute(key, fallback) {
+        const value = this.graph.getAttribute(key);
+        if (value !== undefined && value !== null) {
+            return value;
+        }
+        const attrs = this.graph.getAttributes();
+        return attrs[key] ?? fallback;
+    }
+    mutateGraph(mutate) {
+        const nextGraph = this.getGraph();
+        mutate(nextGraph);
+        const Ctor = this.constructor;
+        return new Ctor(nextGraph);
+    }
+    describeNode(address, kind) {
+        const segments = address.split('.');
+        let index = 0;
+        while (segments[index] === 'module' && segments[index + 1]) {
+            index += 2;
+        }
+        const moduleAddress = index > 0 ? segments.slice(0, index).join('.') : undefined;
+        const tail = segments.slice(index);
+        if (kind === 'resource') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: tail[0],
+                name: tail[1],
+            };
+        }
+        if (kind === 'data') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: tail[1],
+                name: tail[2],
+            };
+        }
+        if (kind === 'local' || kind === 'var' || kind === 'output') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: kind,
+                name: tail[1] ?? tail[0],
+            };
+        }
+        if (kind === 'module') {
+            const moduleSegments = segments.slice(0, index);
+            const parentModuleAddress = moduleSegments.length > 2
+                ? moduleSegments.slice(0, moduleSegments.length - 2).join('.')
+                : undefined;
+            return {
+                moduleAddress: parentModuleAddress,
+                ...this.parentModuleHelpers(parentModuleAddress),
+                resource: 'module',
+                name: moduleSegments[moduleSegments.length - 1] ?? address,
+            };
+        }
+        if (kind === 'provider') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: 'provider',
+                name: tail.join('.') || address,
+            };
+        }
+        if (kind === 'root') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: 'root',
+                name: 'root',
+            };
+        }
+        if (kind === 'meta') {
+            return {
+                moduleAddress,
+                ...this.parentModuleHelpers(moduleAddress),
+                resource: 'meta',
+                name: tail.join('.') || address,
+            };
+        }
+        return {
+            moduleAddress,
+            ...this.parentModuleHelpers(moduleAddress),
+            resource: 'terraform',
+            name: address,
+        };
+    }
+    resolveTerraform(rawTerraform, parsedKind, parsedAddress) {
+        const terraform = rawTerraform && typeof rawTerraform === 'object'
+            ? rawTerraform
+            : undefined;
+        const kindRaw = typeof terraform?.kind === 'string'
+            ? terraform.kind
+            : typeof parsedKind === 'string'
+                ? parsedKind
+                : undefined;
+        const addressRaw = typeof terraform?.address === 'string'
+            ? terraform.address
+            : typeof parsedAddress === 'string'
+                ? parsedAddress
+                : undefined;
+        if (!kindRaw || !addressRaw) {
+            return undefined;
+        }
+        const kind = kindRaw;
+        const details = this.describeNode(addressRaw, kind);
+        const moduleAddress = typeof terraform?.moduleAddress === 'string'
+            ? terraform.moduleAddress
+            : details.moduleAddress;
+        const parentModuleName = typeof terraform?.parentModuleName === 'string'
+            ? terraform.parentModuleName
+            : details.parentModuleName;
+        const parentModuleNodeId = typeof terraform?.parentModuleNodeId === 'string'
+            ? (0, TgGraph_js_1.asNodeId)(terraform.parentModuleNodeId)
+            : details.parentModuleNodeId;
+        const resolved = {
+            kind,
+            address: addressRaw,
+            resource: typeof terraform?.resource === 'string'
+                ? terraform.resource
+                : details.resource,
+            name: typeof terraform?.name === 'string' ? terraform.name : details.name,
+        };
+        if (moduleAddress !== undefined) {
+            resolved.moduleAddress = moduleAddress;
+        }
+        if (parentModuleName !== undefined) {
+            resolved.parentModuleName = parentModuleName;
+        }
+        if (parentModuleNodeId !== undefined) {
+            resolved.parentModuleNodeId = parentModuleNodeId;
+        }
+        return resolved;
+    }
+    parentModuleHelpers(moduleAddress) {
+        if (!moduleAddress) {
+            return {};
+        }
+        const parts = moduleAddress.split('.');
+        return {
+            parentModuleName: parts[parts.length - 1] ?? moduleAddress,
+            parentModuleNodeId: (0, TgGraph_js_1.tgNodeIdFrom)('module', moduleAddress),
+        };
+    }
+}
+exports.GraphologyAdapter = GraphologyAdapter;

package/dist/cjs/Graph/Adapters/GraphologyAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};