flowquery 1.0.85 → 1.0.87

package/dist/graph/source_access.js

@@ -0,0 +1,726 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncDelegator = (this && this.__asyncDelegator) || function (o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryRelationshipAccess = exports.MemoryNodeAccess = exports.RelationshipSourceAccess = exports.NodeSourceAccess = void 0;
+exports.isStaticExpression = isStaticExpression;
+exports.buildTerms = buildTerms;
+exports.predicateFor = predicateFor;
+const list_comprehension_1 = __importDefault(require("../parsing/data_structures/list_comprehension"));
+const binding_reference_1 = __importDefault(require("../parsing/expressions/binding_reference"));
+const reference_1 = __importDefault(require("../parsing/expressions/reference"));
+const function_1 = __importDefault(require("../parsing/functions/function"));
+const source_context_1 = require("./source_context");
+const source_provider_1 = require("./source_provider");
+/**
+ * True when the expression only depends on literals and query
+ * parameters, i.e. its value is fixed for the whole query.
+ */
+function isStaticExpression(node) {
+    if (node instanceof reference_1.default ||
+        node instanceof binding_reference_1.default ||
+        node instanceof function_1.default ||
+        node instanceof list_comprehension_1.default ||
+        // Pattern and sub-query expressions are evaluated per row.
+        typeof node.evaluate === "function") {
+        return false;
+    }
+    for (const child of node.getChildren()) {
+        if (!isStaticExpression(child))
+            return false;
+    }
+    return true;
+}
+/** Evaluate static element properties and pushed WHERE predicates into push terms. */
+function buildTerms(properties, pushed) {
+    const terms = [];
+    let args = null;
+    for (const [key, expression] of properties) {
+        if (!isStaticExpression(expression))
+            continue;
+        const value = expression.value();
+        args !== null && args !== void 0 ? args : (args = {});
+        args[key] = value;
+        terms.push({ op: "eq", property: key, value });
+    }
+    for (const p of pushed) {
+        const value = p.expression.value();
+        if (p.op === "in") {
+            if (Array.isArray(value))
+                terms.push({ op: "in", property: p.property, values: value });
+        }
+        else {
+            terms.push({ op: p.op, property: p.property, value });
+        }
+    }
+    return { terms, args };
+}
+function isPushablePrimitive(value) {
+    return typeof value === "string" || (typeof value === "number" && Number.isFinite(value));
+}
+/** Convert a term into a contract predicate the source can evaluate, or null. */
+function toPredicate(caps, term) {
+    var _a;
+    if (caps === undefined || !caps.operators.includes(term.op))
+        return null;
+    if (caps.properties !== undefined && !caps.properties.includes(term.property))
+        return null;
+    switch (term.op) {
+        case "eq":
+            return isPushablePrimitive(term.value)
+                ? { op: "eq", property: term.property, value: term.value }
+                : null;
+        case "in": {
+            const values = (_a = term.values) !== null && _a !== void 0 ? _a : [];
+            if (!values.every(isPushablePrimitive))
+                return null;
+            const seen = new Set();
+            const distinct = [];
+            for (const v of values) {
+                const key = (0, source_context_1.canonicalKey)(v);
+                if (!seen.has(key)) {
+                    seen.add(key);
+                    distinct.push(v);
+                }
+            }
+            return { op: "in", property: term.property, values: distinct };
+        }
+        default:
+            if (typeof term.value === "number" && Number.isFinite(term.value)) {
+                return { op: term.op, property: term.property, value: term.value };
+            }
+            if (typeof term.value === "string" && caps.stringOrdering === "binary") {
+                return { op: term.op, property: term.property, value: term.value };
+            }
+            return null;
+    }
+}
+function combine(predicates) {
+    if (predicates.length === 0)
+        return null;
+    if (predicates.length === 1)
+        return predicates[0];
+    return { op: "and", terms: predicates };
+}
+function predicateFor(caps, terms) {
+    const out = [];
+    for (const term of terms) {
+        const p = toPredicate(caps, term);
+        if (p !== null)
+            out.push(p);
+    }
+    return combine(out);
+}
+function supportsKeyIn(caps, field) {
+    return (caps !== undefined &&
+        caps.operators.includes("in") &&
+        (caps.properties === undefined || caps.properties.includes(field)));
+}
+const providerIds = new WeakMap();
+let nextProviderId = 0;
+function providerKey(provider) {
+    let id = providerIds.get(provider);
+    if (id === undefined) {
+        id = ++nextProviderId;
+        providerIds.set(provider, id);
+    }
+    return id;
+}
+function chunk(items, size) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(items.slice(i, i + size));
+    return out;
+}
+function distinct(ids) {
+    const seen = new Set();
+    const out = [];
+    for (const id of ids) {
+        if (id === null || id === undefined)
+            continue;
+        const key = (0, source_context_1.canonicalKey)(id);
+        if (!seen.has(key)) {
+            seen.add(key);
+            out.push(id);
+        }
+    }
+    return out;
+}
+const indexCache = new WeakMap();
+function indexRows(rows, field) {
+    let byField = indexCache.get(rows);
+    if (byField === undefined) {
+        byField = new Map();
+        indexCache.set(rows, byField);
+    }
+    let index = byField.get(field);
+    if (index === undefined) {
+        index = new Map();
+        for (const row of rows) {
+            if (!(field in row))
+                continue;
+            const key = (0, source_context_1.canonicalKey)(row[field]);
+            let bucket = index.get(key);
+            if (bucket === undefined) {
+                bucket = [];
+                index.set(key, bucket);
+            }
+            bucket.push(row);
+        }
+        byField.set(field, index);
+    }
+    return index;
+}
+/** Common machinery for one provider bound to one label or relationship type. */
+class SourceEntry {
+    constructor(ctx, provider, name, kind) {
+        this.ctx = ctx;
+        this.provider = provider;
+        this.name = name;
+        this.kind = kind;
+        this._unsupported = new Set();
+    }
+    get caps() {
+        return this.provider.capabilities;
+    }
+    get batchSize() {
+        var _a;
+        return Math.min(this.ctx.options.maxBatchSize, (_a = this.caps.maxBatchSize) !== null && _a !== void 0 ? _a : Infinity);
+    }
+    get cacheable() {
+        return this.caps.cacheable === true;
+    }
+    cacheKey(op, predicate, args, extra) {
+        return `${this.kind}|${providerKey(this.provider)}|${this.name}|${op}|${(0, source_context_1.canonicalKey)(predicate)}|${(0, source_context_1.canonicalKey)(args)}|${(0, source_context_1.canonicalKey)(extra)}`;
+    }
+    /** Stream scan pages, optionally constrained by an extra key predicate. */
+    scan(terms, args) {
+        return __asyncGenerator(this, arguments, function* scan_1() {
+            const predicate = predicateFor(this.caps.predicates, terms);
+            yield __await(yield* __asyncDelegator(__asyncValues(this.scanWith(predicate, args))));
+        });
+    }
+    scanWith(predicate, args) {
+        return __asyncGenerator(this, arguments, function* scanWith_1() {
+            var _a, e_1, _b, _c;
+            const key = this.cacheable ? this.cacheKey("scan", predicate, args, null) : null;
+            if (key !== null) {
+                const cached = this.ctx.cacheGet(key);
+                if (cached !== undefined) {
+                    yield yield __await(cached);
+                    return yield __await(void 0);
+                }
+            }
+            const collected = key !== null ? [] : null;
+            let overflow = false;
+            try {
+                for (var _d = true, _e = __asyncValues(this.ctx.call(this.provider, "scan", this.name, this.kind, Object.assign(Object.assign({ operation: "scan" }, this.base()), { predicate,
+                    args, pageSize: this.ctx.options.pageSize }))), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const page = _c;
+                    const enriched = page.map((row) => this.enrich(row));
+                    if (collected !== null && !overflow) {
+                        if (collected.length + enriched.length > this.ctx.options.cacheCapacity) {
+                            overflow = true;
+                        }
+                        else {
+                            collected.push(...enriched);
+                        }
+                    }
+                    yield yield __await(enriched);
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            if (key !== null && collected !== null && !overflow) {
+                this.ctx.cacheSet(key, collected);
+            }
+        });
+    }
+    /** Fully materialize a scan (shared per query) as the last-resort fallback. */
+    materializeAll(args) {
+        const key = this.cacheKey("materialize", null, args, null);
+        return this.ctx.materialize(key, () => __awaiter(this, void 0, void 0, function* () {
+            var _a, e_2, _b, _c;
+            const rows = [];
+            try {
+                for (var _d = true, _e = __asyncValues(this.scanWith(null, args)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const page = _c;
+                    rows.push(...page);
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return rows;
+        }));
+    }
+    /**
+     * Fetch rows for a set of key values using the native keyed operation
+     * (`lookup`/`expand`) in batches, falling back to filtered scans or a
+     * materialized scan.  Returns `null` when `maxRows` would be exceeded.
+     */
+    fetchKeyed(operation_1, native_1, field_1, ids_1, terms_1, args_1, extra_1) {
+        return __awaiter(this, arguments, void 0, function* (operation, native, field, ids, terms, args, extra, maxRows = Infinity) {
+            var _a, e_3, _b, _c, _d, e_4, _e, _f;
+            var _g;
+            const predicate = predicateFor(this.caps.predicates, terms);
+            const result = new Map();
+            const pending = [];
+            for (const id of ids) {
+                const key = this.cacheable
+                    ? this.cacheKey(operation, predicate, args, Object.assign(Object.assign({}, extra), { id }))
+                    : null;
+                const cached = key !== null ? this.ctx.cacheGet(key) : undefined;
+                if (cached !== undefined) {
+                    result.set((0, source_context_1.canonicalKey)(id), cached);
+                }
+                else {
+                    result.set((0, source_context_1.canonicalKey)(id), []);
+                    pending.push(id);
+                }
+            }
+            const wanted = new Set(pending.map(source_context_1.canonicalKey));
+            if (pending.length === 0)
+                return result;
+            let total = 0;
+            const add = (row) => {
+                const k = (0, source_context_1.canonicalKey)(row[field]);
+                if (!wanted.has(k))
+                    return true;
+                result.get(k).push(this.enrich(row));
+                total++;
+                return total <= maxRows;
+            };
+            const useNative = native && !this._unsupported.has(operation);
+            if (useNative) {
+                try {
+                    for (const batch of chunk(pending, this.batchSize)) {
+                        this.ctx.stats.batches++;
+                        try {
+                            for (var _h = true, _j = (e_3 = void 0, __asyncValues(this.ctx.call(this.provider, operation, this.name, this.kind, Object.assign(Object.assign(Object.assign({ operation }, this.base()), extra), { ids: batch, predicate,
+                                args, pageSize: this.ctx.options.pageSize })))), _k; _k = yield _j.next(), _a = _k.done, !_a; _h = true) {
+                                _c = _k.value;
+                                _h = false;
+                                const page = _c;
+                                for (const row of page) {
+                                    if (!add(row))
+                                        return null;
+                                }
+                                this.ctx.notePeakBuffered(total);
+                            }
+                        }
+                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                        finally {
+                            try {
+                                if (!_h && !_a && (_b = _j.return)) yield _b.call(_j);
+                            }
+                            finally { if (e_3) throw e_3.error; }
+                        }
+                    }
+                }
+                catch (e) {
+                    if (!(e instanceof source_provider_1.SourceUnsupportedError) || total > 0)
+                        throw e;
+                    this._unsupported.add(operation);
+                    return this.fetchKeyed(operation, false, field, ids, terms, args, extra, maxRows);
+                }
+            }
+            else {
+                this.ctx.stats.fallbacks++;
+                if (supportsKeyIn(this.caps.predicates, field)) {
+                    for (const batch of chunk(pending, this.batchSize)) {
+                        this.ctx.stats.batches++;
+                        const keyed = combine([
+                            ...(predicate === null ? [] : [predicate]),
+                            { op: "in", property: field, values: batch },
+                        ]);
+                        try {
+                            for (var _l = true, _m = (e_4 = void 0, __asyncValues(this.scanWith(keyed, args))), _o; _o = yield _m.next(), _d = _o.done, !_d; _l = true) {
+                                _f = _o.value;
+                                _l = false;
+                                const page = _f;
+                                for (const row of page) {
+                                    if (!wanted.has((0, source_context_1.canonicalKey)(row[field])))
+                                        continue;
+                                    result.get((0, source_context_1.canonicalKey)(row[field])).push(row);
+                                    if (++total > maxRows)
+                                        return null;
+                                }
+                            }
+                        }
+                        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                        finally {
+                            try {
+                                if (!_l && !_d && (_e = _m.return)) yield _e.call(_m);
+                            }
+                            finally { if (e_4) throw e_4.error; }
+                        }
+                    }
+                }
+                else {
+                    const index = indexRows(yield this.materializeAll(args), field);
+                    for (const id of pending) {
+                        const rows = (_g = index.get((0, source_context_1.canonicalKey)(id))) !== null && _g !== void 0 ? _g : [];
+                        result.set((0, source_context_1.canonicalKey)(id), rows);
+                        total += rows.length;
+                    }
+                    if (total > maxRows)
+                        return null;
+                }
+            }
+            if (this.cacheable) {
+                for (const id of pending) {
+                    this.ctx.cacheSet(this.cacheKey(operation, predicate, args, Object.assign(Object.assign({}, extra), { id })), result.get((0, source_context_1.canonicalKey)(id)));
+                }
+            }
+            return result;
+        });
+    }
+}
+class NodeEntry extends SourceEntry {
+    constructor(ctx, provider, label) {
+        super(ctx, provider, label, "node");
+        this.label = label;
+    }
+    base() {
+        return { label: this.label };
+    }
+    enrich(row) {
+        return Object.assign(Object.assign({}, row), { _label: this.label });
+    }
+    get nativeLookup() {
+        return this.provider.capabilities.lookup === true;
+    }
+    lookup(ids, terms, args) {
+        return this.fetchKeyed("lookup", this.nativeLookup, "id", ids, terms, args, {});
+    }
+    estimate(terms, args) {
+        const provider = this.provider;
+        if (typeof provider.estimate !== "function")
+            return undefined;
+        return provider.estimate({
+            version: 1,
+            operation: "scan",
+            label: this.label,
+            predicate: predicateFor(this.caps.predicates, terms),
+            args,
+            pageSize: this.ctx.options.pageSize,
+        });
+    }
+    pushes(terms) {
+        return predicateFor(this.caps.predicates, terms) !== null;
+    }
+}
+class RelationshipEntry extends SourceEntry {
+    constructor(ctx, provider, type, sourceLabel, targetLabel) {
+        super(ctx, provider, `(:${sourceLabel !== null && sourceLabel !== void 0 ? sourceLabel : ""})-[:${type}]->(:${targetLabel !== null && targetLabel !== void 0 ? targetLabel : ""})`, "relationship");
+        this.type = type;
+        this.sourceLabel = sourceLabel;
+        this.targetLabel = targetLabel;
+    }
+    base() {
+        return { type: this.type, sourceLabel: this.sourceLabel, targetLabel: this.targetLabel };
+    }
+    enrich(row) {
+        return Object.assign(Object.assign({}, row), { _type: this.type });
+    }
+    nativeExpand(side) {
+        var _a;
+        return ((_a = this.provider.capabilities.expand) === null || _a === void 0 ? void 0 : _a[side]) === true;
+    }
+    expandBatch(side, ids, terms, args, maxRows) {
+        return this.fetchKeyed("expand", this.nativeExpand(side), `${side}_id`, ids, terms, args, { side }, maxRows);
+    }
+    /** Stream the relationships of one anchor without buffering. */
+    expandOne(side, id, terms, args) {
+        return __asyncGenerator(this, arguments, function* expandOne_1() {
+            var _a, e_5, _b, _c;
+            var _d;
+            const field = `${side}_id`;
+            const predicate = predicateFor(this.caps.predicates, terms);
+            const extra = { side, id };
+            const key = this.cacheable ? this.cacheKey("expand", predicate, args, extra) : null;
+            if (key !== null) {
+                const cached = this.ctx.cacheGet(key);
+                if (cached !== undefined) {
+                    yield yield __await(cached);
+                    return yield __await(void 0);
+                }
+            }
+            if (!this.nativeExpand(side) || this._unsupported.has("expand")) {
+                const rows = yield __await(this.fetchKeyed("expand", false, field, [id], terms, args, { side }));
+                yield yield __await((_d = rows.get((0, source_context_1.canonicalKey)(id))) !== null && _d !== void 0 ? _d : []);
+                return yield __await(void 0);
+            }
+            const want = (0, source_context_1.canonicalKey)(id);
+            const collected = key !== null ? [] : null;
+            let overflow = false;
+            let yielded = false;
+            try {
+                try {
+                    for (var _e = true, _f = __asyncValues(this.ctx.call(this.provider, "expand", this.name, this.kind, Object.assign(Object.assign({ operation: "expand" }, this.base()), { side, ids: [id], predicate,
+                        args, pageSize: this.ctx.options.pageSize }))), _g; _g = yield __await(_f.next()), _a = _g.done, !_a; _e = true) {
+                        _c = _g.value;
+                        _e = false;
+                        const page = _c;
+                        const rows = page
+                            .filter((r) => (0, source_context_1.canonicalKey)(r[field]) === want)
+                            .map((r) => this.enrich(r));
+                        if (collected !== null && !overflow) {
+                            if (collected.length + rows.length > this.ctx.options.cacheCapacity)
+                                overflow = true;
+                            else
+                                collected.push(...rows);
+                        }
+                        yielded = true;
+                        yield yield __await(rows);
+                    }
+                }
+                catch (e_5_1) { e_5 = { error: e_5_1 }; }
+                finally {
+                    try {
+                        if (!_e && !_a && (_b = _f.return)) yield __await(_b.call(_f));
+                    }
+                    finally { if (e_5) throw e_5.error; }
+                }
+            }
+            catch (e) {
+                if (!(e instanceof source_provider_1.SourceUnsupportedError) || yielded)
+                    throw e;
+                this._unsupported.add("expand");
+                yield __await(yield* __asyncDelegator(__asyncValues(this.expandOne(side, id, terms, args))));
+                return yield __await(void 0);
+            }
+            if (key !== null && collected !== null && !overflow)
+                this.ctx.cacheSet(key, collected);
+        });
+    }
+}
+/** Provider-backed node access across one or more labels. */
+class NodeSourceAccess {
+    constructor(ctx, entries) {
+        this.ctx = ctx;
+        this.deferred = true;
+        this._buffer = null;
+        this._entries = entries.map((e) => new NodeEntry(ctx, e.provider, e.label));
+    }
+    scan(terms, args) {
+        return __asyncGenerator(this, arguments, function* scan_2() {
+            for (const entry of this._entries)
+                yield __await(yield* __asyncDelegator(__asyncValues(entry.scan(terms, args))));
+        });
+    }
+    prefetch(ids, terms, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unique = distinct(ids);
+            const previous = this._buffer;
+            const buffer = new Map();
+            const missing = [];
+            for (const id of unique) {
+                const key = (0, source_context_1.canonicalKey)(id);
+                const kept = previous === null || previous === void 0 ? void 0 : previous.get(key);
+                if (kept !== undefined) {
+                    buffer.set(key, kept);
+                }
+                else {
+                    buffer.set(key, []);
+                    missing.push(id);
+                }
+            }
+            if (missing.length > 0) {
+                for (const entry of this._entries) {
+                    const rows = yield entry.lookup(missing, terms, args);
+                    for (const [key, list] of rows)
+                        buffer.get(key).push(...list);
+                }
+            }
+            this._buffer = buffer;
+        });
+    }
+    lookup(id, terms, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            if (id === null || id === undefined)
+                return [];
+            const key = (0, source_context_1.canonicalKey)(id);
+            const buffered = (_a = this._buffer) === null || _a === void 0 ? void 0 : _a.get(key);
+            if (buffered !== undefined)
+                return buffered;
+            const out = [];
+            for (const entry of this._entries) {
+                const rows = yield entry.lookup([id], terms, args);
+                out.push(...((_b = rows.get(key)) !== null && _b !== void 0 ? _b : []));
+            }
+            return out;
+        });
+    }
+    canLookup() {
+        return this._entries.every((e) => e.nativeLookup);
+    }
+    pushes(terms) {
+        return this._entries.every((e) => e.pushes(terms));
+    }
+    estimate(terms, args) {
+        let total = 0;
+        for (const entry of this._entries) {
+            const e = entry.estimate(terms, args);
+            if (e === undefined)
+                return undefined;
+            total += e;
+        }
+        return total;
+    }
+}
+exports.NodeSourceAccess = NodeSourceAccess;
+/** Provider-backed relationship access across one or more types/endpoints. */
+class RelationshipSourceAccess {
+    constructor(ctx, entries) {
+        this.ctx = ctx;
+        this.deferred = true;
+        this._buffer = null;
+        this._bufferSide = null;
+        this._entries = entries.map((e) => new RelationshipEntry(ctx, e.provider, e.type, e.sourceLabel, e.targetLabel));
+    }
+    expand(anchor, side, terms, args) {
+        return __asyncGenerator(this, arguments, function* expand_1() {
+            var _a;
+            if (anchor === null || anchor === undefined)
+                return yield __await(void 0);
+            const buffered = this._bufferSide === side ? (_a = this._buffer) === null || _a === void 0 ? void 0 : _a.get((0, source_context_1.canonicalKey)(anchor)) : undefined;
+            if (buffered !== undefined) {
+                yield yield __await(buffered);
+                return yield __await(void 0);
+            }
+            for (const entry of this._entries)
+                yield __await(yield* __asyncDelegator(__asyncValues(entry.expandOne(side, anchor, terms, args))));
+        });
+    }
+    prefetch(anchors, side, terms, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._buffer = null;
+            this._bufferSide = null;
+            const unique = distinct(anchors);
+            if (unique.length < 2 || !this._entries.every((e) => e.nativeExpand(side)))
+                return null;
+            const buffer = new Map();
+            for (const id of unique)
+                buffer.set((0, source_context_1.canonicalKey)(id), []);
+            let remaining = this.ctx.options.maxPrefetchRows;
+            const all = [];
+            for (const entry of this._entries) {
+                const rows = yield entry.expandBatch(side, unique, terms, args, remaining);
+                if (rows === null)
+                    return null;
+                for (const [key, list] of rows) {
+                    buffer.get(key).push(...list);
+                    all.push(...list);
+                    remaining -= list.length;
+                }
+            }
+            this.ctx.notePeakBuffered(all.length);
+            this._buffer = buffer;
+            this._bufferSide = side;
+            return all;
+        });
+    }
+}
+exports.RelationshipSourceAccess = RelationshipSourceAccess;
+/** In-memory node access over materialized legacy records (used by reversed plans). */
+class MemoryNodeAccess {
+    constructor(_records) {
+        this._records = _records;
+        this.deferred = false;
+    }
+    scan() {
+        return __asyncGenerator(this, arguments, function* scan_3() {
+            yield yield __await(this._records);
+        });
+    }
+    lookup(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return (_a = indexRows(this._records, "id").get((0, source_context_1.canonicalKey)(id))) !== null && _a !== void 0 ? _a : [];
+        });
+    }
+    prefetch() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    canLookup() {
+        return true;
+    }
+    pushes() {
+        return false;
+    }
+    estimate() {
+        return this._records.length;
+    }
+}
+exports.MemoryNodeAccess = MemoryNodeAccess;
+/** In-memory relationship access over materialized legacy records (used by reversed plans). */
+class MemoryRelationshipAccess {
+    constructor(_records) {
+        this._records = _records;
+        this.deferred = false;
+    }
+    expand(anchor, side) {
+        return __asyncGenerator(this, arguments, function* expand_2() {
+            var _a;
+            yield yield __await((_a = indexRows(this._records, `${side}_id`).get((0, source_context_1.canonicalKey)(anchor))) !== null && _a !== void 0 ? _a : []);
+        });
+    }
+    prefetch() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return null;
+        });
+    }
+}
+exports.MemoryRelationshipAccess = MemoryRelationshipAccess;
+//# sourceMappingURL=source_access.js.map