flowquery 1.0.66 → 1.0.68

package/dist/parsing/statement_info_crawler.js

@@ -0,0 +1,730 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const database_1 = __importDefault(require("../graph/database"));
+const node_1 = __importDefault(require("../graph/node"));
+const relationship_1 = __importDefault(require("../graph/relationship"));
+const ast_node_1 = __importDefault(require("./ast_node"));
+const lookup_1 = __importDefault(require("./data_structures/lookup"));
+const f_string_1 = __importDefault(require("./expressions/f_string"));
+const identifier_1 = __importDefault(require("./expressions/identifier"));
+const operator_1 = require("./expressions/operator");
+const parameter_reference_1 = __importDefault(require("./expressions/parameter_reference"));
+const reference_1 = __importDefault(require("./expressions/reference"));
+const subquery_expression_1 = __importDefault(require("./expressions/subquery_expression"));
+const aggregated_return_1 = __importDefault(require("./operations/aggregated_return"));
+const aggregated_with_1 = __importDefault(require("./operations/aggregated_with"));
+const create_node_1 = __importDefault(require("./operations/create_node"));
+const create_relationship_1 = __importDefault(require("./operations/create_relationship"));
+const delete_node_1 = __importDefault(require("./operations/delete_node"));
+const delete_relationship_1 = __importDefault(require("./operations/delete_relationship"));
+const load_1 = __importDefault(require("./operations/load"));
+const match_1 = __importDefault(require("./operations/match"));
+const order_by_1 = __importDefault(require("./operations/order_by"));
+const return_1 = __importDefault(require("./operations/return"));
+const with_1 = __importDefault(require("./operations/with"));
+/**
+ * Walks one or more parsed FlowQuery statement ASTs and extracts a
+ * `StatementInfo` describing the labels, relationship types, sources, and
+ * properties they reference.
+ *
+ * The crawler does not execute the statement. It only inspects the AST
+ * structure plus the live `Database` registry (to resolve sources for
+ * virtuals that are referenced but not (re-)declared in the AST).
+ *
+ * @example
+ * ```typescript
+ * const crawler = new StatementInfoCrawler();
+ * const info = crawler.crawl(ast);
+ * console.log(info.node_labels);
+ * ```
+ */
+class StatementInfoCrawler {
+    constructor() {
+        this._nodeLabels = new Set();
+        this._relTypes = new Set();
+        this._nodeProps = new Map();
+        this._relProps = new Map();
+        this._nodeSources = new Map();
+        this._relSources = new Map();
+        this._nodeLiterals = new Map();
+        this._relLiterals = new Map();
+        this._nodeDeclaredProps = new Map();
+        this._relDeclaredProps = new Map();
+        this._nodeDeclaredSources = new Map();
+        this._relDeclaredSources = new Map();
+        this._ownCreatedNodeLabels = new Set();
+        this._ownCreatedRelTypes = new Set();
+        /**
+         * For each inline CREATE VIRTUAL clause, the (label or type) it
+         * declares and its inner statement AST. The label key receives the
+         * sources collected from the statement during {@link resolveRegisteredDefinitions}.
+         */
+        this._ownNodeCreates = [];
+        this._ownRelCreates = [];
+    }
+    /**
+     * Walks one or more statement ASTs and returns the merged structural info.
+     *
+     * @param statements - A single statement root, or an iterable of roots
+     *                     (for multi-statement queries).
+     */
+    crawl(statements) {
+        this.reset();
+        const roots = this.toIterable(statements);
+        for (const root of roots) {
+            this.crawlStatement(root);
+        }
+        this.resolveRegisteredDefinitions();
+        return this.snapshot();
+    }
+    toIterable(statements) {
+        if (statements instanceof ast_node_1.default) {
+            return [statements];
+        }
+        return statements;
+    }
+    reset() {
+        this._nodeLabels = new Set();
+        this._relTypes = new Set();
+        this._nodeProps = new Map();
+        this._relProps = new Map();
+        this._nodeSources = new Map();
+        this._relSources = new Map();
+        this._nodeLiterals = new Map();
+        this._relLiterals = new Map();
+        this._nodeDeclaredProps = new Map();
+        this._relDeclaredProps = new Map();
+        this._nodeDeclaredSources = new Map();
+        this._relDeclaredSources = new Map();
+        this._ownCreatedNodeLabels = new Set();
+        this._ownCreatedRelTypes = new Set();
+        this._ownNodeCreates = [];
+        this._ownRelCreates = [];
+    }
+    crawlStatement(root) {
+        let op = null;
+        try {
+            op = root.firstChild();
+        }
+        catch (_a) {
+            return;
+        }
+        while (op !== null) {
+            this.visitOperation(op);
+            op = op.next;
+        }
+    }
+    visitOperation(op) {
+        var _a, _b, _c, _d, _e;
+        if (op instanceof create_node_1.default) {
+            const node = op.node;
+            if (node === null || node === void 0 ? void 0 : node.label) {
+                this._nodeLabels.add(node.label);
+                this._ownCreatedNodeLabels.add(node.label);
+                if (op.statement) {
+                    this._ownNodeCreates.push({ label: node.label, statement: op.statement });
+                }
+            }
+        }
+        else if (op instanceof create_relationship_1.default) {
+            const rel = op.relationship;
+            if (rel === null || rel === void 0 ? void 0 : rel.type) {
+                this._relTypes.add(rel.type);
+                this._ownCreatedRelTypes.add(rel.type);
+                if (op.statement) {
+                    this._ownRelCreates.push({ type: rel.type, statement: op.statement });
+                }
+            }
+            if ((_a = rel === null || rel === void 0 ? void 0 : rel.source) === null || _a === void 0 ? void 0 : _a.label)
+                this._nodeLabels.add(rel.source.label);
+            if ((_b = rel === null || rel === void 0 ? void 0 : rel.target) === null || _b === void 0 ? void 0 : _b.label)
+                this._nodeLabels.add(rel.target.label);
+        }
+        else if (op instanceof delete_node_1.default) {
+            if ((_c = op.node) === null || _c === void 0 ? void 0 : _c.label)
+                this._nodeLabels.add(op.node.label);
+        }
+        else if (op instanceof delete_relationship_1.default) {
+            const rel = op.relationship;
+            if (rel === null || rel === void 0 ? void 0 : rel.type)
+                this._relTypes.add(rel.type);
+            if ((_d = rel === null || rel === void 0 ? void 0 : rel.source) === null || _d === void 0 ? void 0 : _d.label)
+                this._nodeLabels.add(rel.source.label);
+            if ((_e = rel === null || rel === void 0 ? void 0 : rel.target) === null || _e === void 0 ? void 0 : _e.label)
+                this._nodeLabels.add(rel.target.label);
+        }
+        else if (op instanceof match_1.default) {
+            for (const pattern of op.patterns) {
+                for (const element of pattern.chain) {
+                    if (element instanceof node_1.default) {
+                        for (const lbl of element.labels)
+                            this._nodeLabels.add(lbl);
+                        for (const [propKey, expr] of element.properties) {
+                            this.addNodeProp(element.labels, propKey);
+                            this.tryAddNodeLiteral(element.labels, propKey, expr);
+                        }
+                    }
+                    else if (element instanceof relationship_1.default) {
+                        for (const t of element.types)
+                            this._relTypes.add(t);
+                        for (const [propKey, expr] of element.properties) {
+                            this.addRelProp(element.types, propKey);
+                            this.tryAddRelLiteral(element.types, propKey, expr);
+                        }
+                    }
+                }
+            }
+        }
+        // CREATE/DELETE VIRTUAL operations describe registry mutations rather
+        // than query-side property accesses; their inner ASTs are crawled
+        // separately for sources, but we don't surface their property usage.
+        if (!(op instanceof create_node_1.default) &&
+            !(op instanceof create_relationship_1.default) &&
+            !(op instanceof delete_node_1.default) &&
+            !(op instanceof delete_relationship_1.default)) {
+            this.collectPropertyAccesses(op);
+        }
+    }
+    resolveRegisteredDefinitions() {
+        // Sources and declared properties from inline CREATE VIRTUAL clauses
+        // in the crawled statements.
+        for (const { label, statement } of this._ownNodeCreates) {
+            this.collectSources(statement, this.getOrCreate(this._nodeSources, label));
+            this.collectSources(statement, this.getOrCreate(this._nodeDeclaredSources, label));
+            this.collectDeclaredProps(statement, this.getOrCreate(this._nodeDeclaredProps, label));
+        }
+        for (const { type, statement } of this._ownRelCreates) {
+            this.collectSources(statement, this.getOrCreate(this._relSources, type));
+            this.collectSources(statement, this.getOrCreate(this._relDeclaredSources, type));
+            this.collectDeclaredProps(statement, this.getOrCreate(this._relDeclaredProps, type));
+        }
+        // Sources / declared properties from already-registered virtuals
+        // that the crawled statements reference (e.g. MATCH/DELETE against
+        // a virtual registered earlier).
+        const db = database_1.default.getInstance();
+        for (const label of this._nodeLabels) {
+            if (this._ownCreatedNodeLabels.has(label))
+                continue;
+            const physical = db.nodes.get(label);
+            if (physical === null || physical === void 0 ? void 0 : physical.statement) {
+                this.collectSources(physical.statement, this.getOrCreate(this._nodeSources, label));
+                this.collectSources(physical.statement, this.getOrCreate(this._nodeDeclaredSources, label));
+                this.collectDeclaredProps(physical.statement, this.getOrCreate(this._nodeDeclaredProps, label));
+            }
+        }
+        for (const type of this._relTypes) {
+            if (this._ownCreatedRelTypes.has(type))
+                continue;
+            const typeMap = db.relationships.get(type);
+            if (typeMap === undefined)
+                continue;
+            for (const physical of typeMap.values()) {
+                if (physical.statement) {
+                    this.collectSources(physical.statement, this.getOrCreate(this._relSources, type));
+                    this.collectSources(physical.statement, this.getOrCreate(this._relDeclaredSources, type));
+                    this.collectDeclaredProps(physical.statement, this.getOrCreate(this._relDeclaredProps, type));
+                }
+            }
+        }
+    }
+    getOrCreate(map, key) {
+        let set = map.get(key);
+        if (set === undefined) {
+            set = new Set();
+            map.set(key, set);
+        }
+        return set;
+    }
+    /**
+     * Walks the AST rooted at `root` and records every property access
+     * (via `Lookup`) on a known node/relationship binding, every literal
+     * value supplied via equality / `IN` predicates, and descends into
+     * subqueries plus the privately-held WHERE / ORDER BY ASTs of
+     * RETURN-style operations.
+     */
+    collectPropertyAccesses(root) {
+        const visited = new Set();
+        const stack = [root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (visited.has(node))
+                continue;
+            visited.add(node);
+            if (node instanceof lookup_1.default) {
+                this.handleLookupAccess(node);
+            }
+            if (node instanceof operator_1.Equals) {
+                this.handleEqualityLiteral(node);
+            }
+            else if (node instanceof operator_1.In) {
+                this.handleInLiteral(node);
+            }
+            for (const child of node.getChildren()) {
+                stack.push(child);
+            }
+            // Subquery expressions hold their inner AST in a private field
+            // rather than as a child; descend into it explicitly.
+            if (node instanceof subquery_expression_1.default) {
+                const inner = node._subqueryAST;
+                if (inner !== undefined)
+                    stack.push(inner);
+            }
+            // RETURN / AggregatedReturn hold WHERE and ORDER BY clauses in
+            // private fields; descend into the ones with expression trees.
+            if (node instanceof return_1.default) {
+                const w = node._where;
+                const o = node._orderBy;
+                if (w)
+                    stack.push(w);
+                if (o)
+                    stack.push(o);
+            }
+            // OrderBy stores its sort expressions in a private array of
+            // SortField objects rather than as AST children; descend
+            // explicitly.
+            if (node instanceof order_by_1.default) {
+                for (const field of node.fields) {
+                    stack.push(field.expression);
+                }
+            }
+        }
+    }
+    handleLookupAccess(node) {
+        const target = this.resolveLookupTarget(node);
+        if (target === null)
+            return;
+        if (target.kind === "node") {
+            this.addNodeProp(target.labels, target.prop);
+        }
+        else {
+            this.addRelProp(target.types, target.prop);
+        }
+    }
+    /**
+     * Resolves a `Lookup` of the shape `alias.prop` to the labels/types
+     * of the bound entity and the property name. Returns `null` if the
+     * lookup isn't of that shape or its variable doesn't resolve to a
+     * Node/Relationship.
+     */
+    resolveLookupTarget(lookup) {
+        const variable = lookup.variable;
+        const index = lookup.index;
+        if (!(variable instanceof reference_1.default) || !(index instanceof identifier_1.default))
+            return null;
+        const propName = index.value();
+        if (typeof propName !== "string" || propName.length === 0)
+            return null;
+        const referred = variable.referred;
+        if (referred instanceof node_1.default) {
+            return { kind: "node", labels: referred.labels, prop: propName };
+        }
+        if (referred instanceof relationship_1.default) {
+            return { kind: "rel", types: referred.types, prop: propName };
+        }
+        return null;
+    }
+    handleEqualityLiteral(op) {
+        const lhs = op.lhs;
+        const rhs = op.rhs;
+        // Try both orientations: `alias.prop = literal` and `literal = alias.prop`.
+        this.tryRecordPropEquality(lhs, rhs);
+        this.tryRecordPropEquality(rhs, lhs);
+    }
+    tryRecordPropEquality(side, other) {
+        if (!(side instanceof lookup_1.default))
+            return;
+        if (!this.isLiteralAst(other))
+            return;
+        const target = this.resolveLookupTarget(side);
+        if (target === null)
+            return;
+        const value = this.safeEvaluate(other);
+        if (value === undefined)
+            return;
+        if (target.kind === "node") {
+            this.addNodeLiteralValue(target.labels, target.prop, value);
+        }
+        else {
+            this.addRelLiteralValue(target.types, target.prop, value);
+        }
+    }
+    handleInLiteral(op) {
+        const lhs = op.lhs;
+        const rhs = op.rhs;
+        if (!(lhs instanceof lookup_1.default))
+            return;
+        if (!this.isLiteralAst(rhs))
+            return;
+        const target = this.resolveLookupTarget(lhs);
+        if (target === null)
+            return;
+        const value = this.safeEvaluate(rhs);
+        if (!Array.isArray(value))
+            return;
+        for (const item of value) {
+            if (target.kind === "node") {
+                this.addNodeLiteralValue(target.labels, target.prop, item);
+            }
+            else {
+                this.addRelLiteralValue(target.types, target.prop, item);
+            }
+        }
+    }
+    /**
+     * Returns true iff the AST subtree contains only literal nodes (no
+     * References, ParameterReferences, Lookups, FStrings, or
+     * SubqueryExpressions). Used to guard literal-value extraction
+     * against runtime-dependent expressions.
+     */
+    isLiteralAst(node) {
+        if (node instanceof reference_1.default ||
+            node instanceof parameter_reference_1.default ||
+            node instanceof lookup_1.default ||
+            node instanceof f_string_1.default ||
+            node instanceof subquery_expression_1.default) {
+            return false;
+        }
+        for (const child of node.getChildren()) {
+            if (!this.isLiteralAst(child))
+                return false;
+        }
+        return true;
+    }
+    safeEvaluate(node) {
+        try {
+            return node.value();
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    tryAddNodeLiteral(labels, prop, expr) {
+        if (!this.isLiteralAst(expr))
+            return;
+        const value = this.safeEvaluate(expr);
+        if (value === undefined)
+            return;
+        this.addNodeLiteralValue(labels, prop, value);
+    }
+    tryAddRelLiteral(types, prop, expr) {
+        if (!this.isLiteralAst(expr))
+            return;
+        const value = this.safeEvaluate(expr);
+        if (value === undefined)
+            return;
+        this.addRelLiteralValue(types, prop, value);
+    }
+    /**
+     * Walks a virtual definition's inner statement to find the final
+     * RETURN-style projection and records its aliases as the declared
+     * property set. Falls back to the last WITH if no RETURN exists.
+     */
+    collectDeclaredProps(statement, target) {
+        let op = null;
+        try {
+            op = statement.firstChild();
+        }
+        catch (_a) {
+            return;
+        }
+        let lastReturn = null;
+        let lastWith = null;
+        while (op !== null) {
+            if (op instanceof return_1.default || op instanceof aggregated_return_1.default) {
+                lastReturn = op;
+            }
+            else if (op instanceof with_1.default || op instanceof aggregated_with_1.default) {
+                lastWith = op;
+            }
+            op = op.next;
+        }
+        const projection = lastReturn !== null && lastReturn !== void 0 ? lastReturn : lastWith;
+        if (projection === null)
+            return;
+        for (const alias of this.projectionAliases(projection)) {
+            target.add(alias);
+        }
+    }
+    /**
+     * Yields the alias of every projected expression in a Projection.
+     * Mirrors the alias-resolution logic of `Projection.expressions()`
+     * (which is protected).
+     */
+    *projectionAliases(projection) {
+        var _a;
+        const children = projection.getChildren();
+        for (let i = 0; i < children.length; i++) {
+            const expr = children[i];
+            const alias = (_a = expr.alias) !== null && _a !== void 0 ? _a : `expr${i}`;
+            if (typeof alias === "string" && alias.length > 0) {
+                yield alias;
+            }
+        }
+    }
+    collectSources(statement, target) {
+        var _a;
+        let op = null;
+        try {
+            op = statement.firstChild();
+        }
+        catch (_b) {
+            return;
+        }
+        while (op !== null) {
+            if (op instanceof load_1.default) {
+                if (op.isAsyncFunction) {
+                    const name = (_a = op.asyncFunction) === null || _a === void 0 ? void 0 : _a.name;
+                    if (typeof name === "string" && name.length > 0)
+                        target.add(name);
+                }
+                else {
+                    try {
+                        const from = op.from;
+                        if (typeof from === "string" && from.length > 0)
+                            target.add(from);
+                    }
+                    catch (_c) {
+                        // Dynamic source (e.g. f-string with unresolved refs);
+                        // skip rather than fail metadata extraction.
+                    }
+                }
+            }
+            op = op.next;
+        }
+    }
+    addNodeProp(labels, prop) {
+        for (const label of labels) {
+            if (!label)
+                continue;
+            let set = this._nodeProps.get(label);
+            if (set === undefined) {
+                set = new Set();
+                this._nodeProps.set(label, set);
+            }
+            set.add(prop);
+        }
+    }
+    addRelProp(types, prop) {
+        for (const type of types) {
+            if (!type)
+                continue;
+            let set = this._relProps.get(type);
+            if (set === undefined) {
+                set = new Set();
+                this._relProps.set(type, set);
+            }
+            set.add(prop);
+        }
+    }
+    addNodeLiteralValue(labels, prop, value) {
+        for (const label of labels) {
+            if (!label)
+                continue;
+            let propMap = this._nodeLiterals.get(label);
+            if (propMap === undefined) {
+                propMap = new Map();
+                this._nodeLiterals.set(label, propMap);
+            }
+            this.appendUniqueLiteral(propMap, prop, value);
+        }
+    }
+    addRelLiteralValue(types, prop, value) {
+        for (const type of types) {
+            if (!type)
+                continue;
+            let propMap = this._relLiterals.get(type);
+            if (propMap === undefined) {
+                propMap = new Map();
+                this._relLiterals.set(type, propMap);
+            }
+            this.appendUniqueLiteral(propMap, prop, value);
+        }
+    }
+    appendUniqueLiteral(propMap, prop, value) {
+        let arr = propMap.get(prop);
+        if (arr === undefined) {
+            arr = [];
+            propMap.set(prop, arr);
+        }
+        for (const existing of arr) {
+            if (this.literalsEqual(existing, value))
+                return;
+        }
+        arr.push(value);
+    }
+    literalsEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a === null || b === null || a === undefined || b === undefined)
+            return false;
+        if (typeof a !== typeof b)
+            return false;
+        if (typeof a !== "object")
+            return false;
+        if (Array.isArray(a) !== Array.isArray(b))
+            return false;
+        if (Array.isArray(a)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!this.literalsEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        const ka = Object.keys(a);
+        const kb = Object.keys(b);
+        if (ka.length !== kb.length)
+            return false;
+        for (const k of ka) {
+            if (!Object.prototype.hasOwnProperty.call(b, k))
+                return false;
+            if (!this.literalsEqual(a[k], b[k]))
+                return false;
+        }
+        return true;
+    }
+    literalsSnapshot(map, key) {
+        const propMap = map.get(key);
+        if (propMap === undefined || propMap.size === 0)
+            return {};
+        const out = {};
+        const sortedKeys = Array.from(propMap.keys()).sort();
+        for (const propKey of sortedKeys) {
+            out[propKey] = [...propMap.get(propKey)];
+        }
+        return out;
+    }
+    snapshot() {
+        const allSources = new Set();
+        const nodes = {};
+        for (const label of this._nodeLabels) {
+            const props = this._nodeProps.get(label);
+            const sources = this._nodeSources.get(label);
+            if (sources !== undefined) {
+                for (const s of sources)
+                    allSources.add(s);
+            }
+            nodes[label] = {
+                properties: props ? Array.from(props).sort() : [],
+                sources: sources ? Array.from(sources).sort() : [],
+                literal_values: this.literalsSnapshot(this._nodeLiterals, label),
+            };
+        }
+        const relationships = {};
+        for (const type of this._relTypes) {
+            const props = this._relProps.get(type);
+            const sources = this._relSources.get(type);
+            if (sources !== undefined) {
+                for (const s of sources)
+                    allSources.add(s);
+            }
+            relationships[type] = {
+                properties: props ? Array.from(props).sort() : [],
+                sources: sources ? Array.from(sources).sort() : [],
+                literal_values: this.literalsSnapshot(this._relLiterals, type),
+            };
+        }
+        const declaredNodes = {};
+        for (const label of this._nodeLabels) {
+            const props = this._nodeDeclaredProps.get(label);
+            const sources = this._nodeDeclaredSources.get(label);
+            if ((props && props.size > 0) || (sources && sources.size > 0)) {
+                declaredNodes[label] = {
+                    properties: props ? Array.from(props).sort() : [],
+                    sources: sources ? Array.from(sources).sort() : [],
+                };
+            }
+        }
+        const declaredRelationships = {};
+        for (const type of this._relTypes) {
+            const props = this._relDeclaredProps.get(type);
+            const sources = this._relDeclaredSources.get(type);
+            if ((props && props.size > 0) || (sources && sources.size > 0)) {
+                declaredRelationships[type] = {
+                    properties: props ? Array.from(props).sort() : [],
+                    sources: sources ? Array.from(sources).sort() : [],
+                };
+            }
+        }
+        const info = {
+            node_labels: Array.from(this._nodeLabels).sort(),
+            relationship_types: Array.from(this._relTypes).sort(),
+            sources: Array.from(allSources).sort(),
+            node_properties: {},
+            relationship_properties: {},
+            nodes,
+            relationships,
+            declared: {
+                nodes: declaredNodes,
+                relationships: declaredRelationships,
+            },
+        };
+        for (const [label, props] of this._nodeProps) {
+            info.node_properties[label] = Array.from(props).sort();
+        }
+        for (const [type, props] of this._relProps) {
+            info.relationship_properties[type] = Array.from(props).sort();
+        }
+        return info;
+    }
+    /**
+     * Returns a deep copy of a StatementInfo so callers can mutate it freely.
+     */
+    static clone(info) {
+        var _a, _b, _c, _d;
+        const cloneProps = (props) => {
+            const out = {};
+            for (const [k, v] of Object.entries(props))
+                out[k] = [...v];
+            return out;
+        };
+        const cloneLiterals = (literals) => {
+            const out = {};
+            for (const [k, v] of Object.entries(literals)) {
+                out[k] = v.map((item) => typeof item === "object" && item !== null ? structuredClone(item) : item);
+            }
+            return out;
+        };
+        const cloneEntities = (entities) => {
+            var _a;
+            const out = {};
+            for (const [k, v] of Object.entries(entities)) {
+                out[k] = {
+                    properties: [...v.properties],
+                    sources: [...v.sources],
+                    literal_values: cloneLiterals((_a = v.literal_values) !== null && _a !== void 0 ? _a : {}),
+                };
+            }
+            return out;
+        };
+        const cloneDeclared = (entities) => {
+            const out = {};
+            for (const [k, v] of Object.entries(entities)) {
+                out[k] = {
+                    properties: [...v.properties],
+                    sources: [...v.sources],
+                };
+            }
+            return out;
+        };
+        return {
+            node_labels: [...info.node_labels],
+            relationship_types: [...info.relationship_types],
+            sources: [...info.sources],
+            node_properties: cloneProps(info.node_properties),
+            relationship_properties: cloneProps(info.relationship_properties),
+            nodes: cloneEntities(info.nodes),
+            relationships: cloneEntities(info.relationships),
+            declared: {
+                nodes: cloneDeclared((_b = (_a = info.declared) === null || _a === void 0 ? void 0 : _a.nodes) !== null && _b !== void 0 ? _b : {}),
+                relationships: cloneDeclared((_d = (_c = info.declared) === null || _c === void 0 ? void 0 : _c.relationships) !== null && _d !== void 0 ? _d : {}),
+            },
+        };
+    }
+}
+exports.default = StatementInfoCrawler;
+//# sourceMappingURL=statement_info_crawler.js.map