@resolveio/server-lib 20.9.10 → 20.9.12

package/util/subscription-dependency-context.js

@@ -62,6 +62,15 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.recordAggregateDependencies = exports.recordDependencyResult = exports.withDependencyTracking = void 0;
 var async_hooks_1 = require("async_hooks");
@@ -119,6 +128,7 @@ function recordDependencyResult(collection, result, options) {
             context.filters.set(collection, filterList);
         }
         filterList.push((0, common_1.deepCopy)(options.filter));
+        context.watchAllCollections.delete(collection);
     }
     if (options === null || options === void 0 ? void 0 : options.meta) {
         var metaList = context.queryMetadata.get(collection);
@@ -134,6 +144,7 @@ function recordDependencyResult(collection, result, options) {
         collectIdsFromFilter(options.filter, ids);
     }
     if (ids.size) {
+        context.watchAllCollections.delete(collection);
         var existing = context.dependencies.get(collection);
         if (!existing) {
             existing = new Set();
@@ -159,7 +170,7 @@ function recordDependencyResult(collection, result, options) {
 }
 exports.recordDependencyResult = recordDependencyResult;
 function recordAggregateDependencies(collection, pipeline, result) {
-    var e_2, _a;
+    var e_2, _a, e_3, _b, e_4, _c;
     var context = dependencyStorage.getStore();
     if (!context) {
         return;
@@ -179,12 +190,61 @@ function recordAggregateDependencies(collection, pipeline, result) {
             var target = lookupTargets_1_1.value;
             var nestedValues = [];
             collectLookupValues(result, target.as, nestedValues);
+            var rootDocs = Array.isArray(result) ? result : [result];
+            var pipelineFilters = [];
+            var pipelineUnresolved = false;
+            try {
+                for (var rootDocs_1 = (e_3 = void 0, __values(rootDocs)), rootDocs_1_1 = rootDocs_1.next(); !rootDocs_1_1.done; rootDocs_1_1 = rootDocs_1.next()) {
+                    var rootDoc = rootDocs_1_1.value;
+                    var _d = buildLookupPipelineFilters(rootDoc, target), filtersFromPipeline = _d.filters, unresolved = _d.unresolved;
+                    if (unresolved) {
+                        pipelineUnresolved = true;
+                    }
+                    if (filtersFromPipeline === null || filtersFromPipeline === void 0 ? void 0 : filtersFromPipeline.length) {
+                        pipelineFilters.push.apply(pipelineFilters, __spreadArray([], __read(filtersFromPipeline), false));
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (rootDocs_1_1 && !rootDocs_1_1.done && (_b = rootDocs_1.return)) _b.call(rootDocs_1);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
             var filter = buildLookupFilter(result, target.localField, target.foreignField);
-            if (nestedValues.length || filter) {
+            var uniquePipelineFilters = dedupeFilters(pipelineFilters);
+            if (nestedValues.length) {
                 recordDependencyResult(target.from, nestedValues, filter ? { filter: filter } : undefined);
             }
-            else {
-                context.watchAllCollections.add(target.from);
+            if (uniquePipelineFilters.length) {
+                var pipelineMeta = extractAggregationMetaFromPipeline(target.pipeline);
+                try {
+                    for (var uniquePipelineFilters_1 = (e_4 = void 0, __values(uniquePipelineFilters)), uniquePipelineFilters_1_1 = uniquePipelineFilters_1.next(); !uniquePipelineFilters_1_1.done; uniquePipelineFilters_1_1 = uniquePipelineFilters_1.next()) {
+                        var pipelineFilter = uniquePipelineFilters_1_1.value;
+                        recordDependencyResult(target.from, [], { filter: pipelineFilter, meta: pipelineMeta });
+                    }
+                }
+                catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                finally {
+                    try {
+                        if (uniquePipelineFilters_1_1 && !uniquePipelineFilters_1_1.done && (_c = uniquePipelineFilters_1.return)) _c.call(uniquePipelineFilters_1);
+                    }
+                    finally { if (e_4) throw e_4.error; }
+                }
+                continue;
+            }
+            if (!nestedValues.length && filter) {
+                recordDependencyResult(target.from, [], { filter: filter });
+                continue;
+            }
+            if (!nestedValues.length) {
+                if (pipelineUnresolved) {
+                    context.watchAllCollections.add(target.from);
+                }
+                else if (!target.pipeline || !target.pipeline.length) {
+                    context.watchAllCollections.add(target.from);
+                }
             }
         }
     }
@@ -198,7 +258,7 @@ function recordAggregateDependencies(collection, pipeline, result) {
 }
 exports.recordAggregateDependencies = recordAggregateDependencies;
 function extractLookupTargets(pipeline) {
-    var e_3, _a;
+    var e_5, _a;
     var lookups = [];
     if (!Array.isArray(pipeline)) {
         return lookups;
@@ -213,23 +273,25 @@ function extractLookupTargets(pipeline) {
                         from: lookup.from,
                         as: lookup.as,
                         localField: typeof lookup.localField === 'string' ? lookup.localField : undefined,
-                        foreignField: typeof lookup.foreignField === 'string' ? lookup.foreignField : undefined
+                        foreignField: typeof lookup.foreignField === 'string' ? lookup.foreignField : undefined,
+                        let: lookup.let && typeof lookup.let === 'object' ? lookup.let : undefined,
+                        pipeline: Array.isArray(lookup.pipeline) ? lookup.pipeline : undefined
                     });
                 }
             }
         }
     }
-    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
     finally {
         try {
             if (pipeline_1_1 && !pipeline_1_1.done && (_a = pipeline_1.return)) _a.call(pipeline_1);
         }
-        finally { if (e_3) throw e_3.error; }
+        finally { if (e_5) throw e_5.error; }
     }
     return lookups;
 }
 function extractMatchFilter(pipeline) {
-    var e_4, _a;
+    var e_6, _a;
     if (!Array.isArray(pipeline)) {
         return null;
     }
@@ -242,12 +304,12 @@ function extractMatchFilter(pipeline) {
             }
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
     finally {
         try {
             if (pipeline_2_1 && !pipeline_2_1.done && (_a = pipeline_2.return)) _a.call(pipeline_2);
         }
-        finally { if (e_4) throw e_4.error; }
+        finally { if (e_6) throw e_6.error; }
     }
     if (!filters.length) {
         return null;
@@ -258,7 +320,7 @@ function extractMatchFilter(pipeline) {
     return { $and: filters };
 }
 function extractAggregateMeta(pipeline) {
-    var e_5, _a;
+    var e_7, _a;
     if (!Array.isArray(pipeline)) {
         return null;
     }
@@ -279,12 +341,53 @@ function extractAggregateMeta(pipeline) {
             }
         }
     }
-    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    catch (e_7_1) { e_7 = { error: e_7_1 }; }
     finally {
         try {
             if (pipeline_3_1 && !pipeline_3_1.done && (_a = pipeline_3.return)) _a.call(pipeline_3);
         }
-        finally { if (e_5) throw e_5.error; }
+        finally { if (e_7) throw e_7.error; }
+    }
+    var meta = {};
+    if (limit !== undefined) {
+        meta.limit = limit;
+    }
+    if (skip !== undefined) {
+        meta.skip = skip;
+    }
+    if (sort) {
+        meta.sort = sort;
+    }
+    return Object.keys(meta).length ? meta : null;
+}
+function extractAggregationMetaFromPipeline(pipeline) {
+    var e_8, _a;
+    if (!Array.isArray(pipeline)) {
+        return null;
+    }
+    var limit = undefined;
+    var skip = undefined;
+    var sort = null;
+    try {
+        for (var pipeline_4 = __values(pipeline), pipeline_4_1 = pipeline_4.next(); !pipeline_4_1.done; pipeline_4_1 = pipeline_4.next()) {
+            var stage = pipeline_4_1.value;
+            if ((stage === null || stage === void 0 ? void 0 : stage.$limit) !== undefined && typeof stage.$limit === 'number') {
+                limit = stage.$limit;
+            }
+            else if ((stage === null || stage === void 0 ? void 0 : stage.$skip) !== undefined && typeof stage.$skip === 'number') {
+                skip = stage.$skip;
+            }
+            else if ((stage === null || stage === void 0 ? void 0 : stage.$sort) && typeof stage.$sort === 'object') {
+                sort = (0, common_1.deepCopy)(stage.$sort);
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (pipeline_4_1 && !pipeline_4_1.done && (_a = pipeline_4.return)) _a.call(pipeline_4);
+        }
+        finally { if (e_8) throw e_8.error; }
     }
     var meta = {};
     if (limit !== undefined) {
@@ -299,7 +402,7 @@ function extractAggregateMeta(pipeline) {
     return Object.keys(meta).length ? meta : null;
 }
 function collectLookupValues(source, path, output) {
-    var e_6, _a;
+    var e_9, _a;
     if (!source) {
         return;
     }
@@ -310,12 +413,12 @@ function collectLookupValues(source, path, output) {
                 collectLookupValues(item, path, output);
             }
         }
-        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
         finally {
             try {
                 if (source_1_1 && !source_1_1.done && (_a = source_1.return)) _a.call(source_1);
             }
-            finally { if (e_6) throw e_6.error; }
+            finally { if (e_9) throw e_9.error; }
         }
         return;
     }
@@ -326,7 +429,7 @@ function collectLookupValues(source, path, output) {
     collectLookupPathValues(source, pathSegments, 0, output);
 }
 function collectLookupPathValues(value, path, index, output) {
-    var e_7, _a;
+    var e_10, _a;
     if (!value) {
         return;
     }
@@ -347,12 +450,12 @@ function collectLookupPathValues(value, path, index, output) {
                 }
             }
         }
-        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
         finally {
             try {
                 if (current_1_1 && !current_1_1.done && (_a = current_1.return)) _a.call(current_1);
             }
-            finally { if (e_7) throw e_7.error; }
+            finally { if (e_10) throw e_10.error; }
         }
     }
     else if (current && typeof current === 'object') {
@@ -378,7 +481,7 @@ function buildLookupFilter(result, localField, foreignField) {
         _a;
 }
 function collectFieldValues(source, path, index, output) {
-    var e_8, _a, e_9, _b;
+    var e_11, _a, e_12, _b;
     if (!source) {
         return;
     }
@@ -389,12 +492,12 @@ function collectFieldValues(source, path, index, output) {
                 collectFieldValues(item, path, index, output);
             }
         }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
         finally {
             try {
                 if (source_2_1 && !source_2_1.done && (_a = source_2.return)) _a.call(source_2);
             }
-            finally { if (e_8) throw e_8.error; }
+            finally { if (e_11) throw e_11.error; }
         }
         return;
     }
@@ -418,12 +521,12 @@ function collectFieldValues(source, path, index, output) {
                 collectFieldValues(item, path, index + 1, output);
             }
         }
-        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
         finally {
             try {
                 if (current_2_1 && !current_2_1.done && (_b = current_2.return)) _b.call(current_2);
             }
-            finally { if (e_9) throw e_9.error; }
+            finally { if (e_12) throw e_12.error; }
         }
     }
     else {
@@ -431,7 +534,7 @@ function collectFieldValues(source, path, index, output) {
     }
 }
 function appendFilterValue(output, value) {
-    var e_10, _a;
+    var e_13, _a;
     if (value === undefined || value === null) {
         return;
     }
@@ -442,19 +545,19 @@ function appendFilterValue(output, value) {
                 appendFilterValue(output, item);
             }
         }
-        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
         finally {
             try {
                 if (value_1_1 && !value_1_1.done && (_a = value_1.return)) _a.call(value_1);
             }
-            finally { if (e_10) throw e_10.error; }
+            finally { if (e_13) throw e_13.error; }
         }
         return;
     }
     output.push(value);
 }
 function dedupeFilterValues(values) {
-    var e_11, _a;
+    var e_14, _a;
     var unique = new Map();
     try {
         for (var values_1 = __values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
@@ -465,12 +568,12 @@ function dedupeFilterValues(values) {
             }
         }
     }
-    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    catch (e_14_1) { e_14 = { error: e_14_1 }; }
     finally {
         try {
             if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
         }
-        finally { if (e_11) throw e_11.error; }
+        finally { if (e_14) throw e_14.error; }
     }
     return Array.from(unique.values());
 }
@@ -498,7 +601,7 @@ function serializeFilterValue(value) {
     return String(value);
 }
 function collectIdsFromResult(source, ids, visited) {
-    var e_12, _a, e_13, _b;
+    var e_15, _a, e_16, _b;
     if (visited === void 0) { visited = new WeakSet(); }
     if (!source) {
         return;
@@ -510,12 +613,12 @@ function collectIdsFromResult(source, ids, visited) {
                 collectIdsFromResult(item, ids, visited);
             }
         }
-        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        catch (e_15_1) { e_15 = { error: e_15_1 }; }
         finally {
             try {
                 if (source_3_1 && !source_3_1.done && (_a = source_3.return)) _a.call(source_3);
             }
-            finally { if (e_12) throw e_12.error; }
+            finally { if (e_15) throw e_15.error; }
         }
         return;
     }
@@ -539,16 +642,16 @@ function collectIdsFromResult(source, ids, visited) {
             }
         }
     }
-    catch (e_13_1) { e_13 = { error: e_13_1 }; }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
     finally {
         try {
             if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
         }
-        finally { if (e_13) throw e_13.error; }
+        finally { if (e_16) throw e_16.error; }
     }
 }
 function collectIdsFromFilter(filter, ids) {
-    var e_14, _a, e_15, _b, e_16, _c;
+    var e_17, _a, e_18, _b, e_19, _c;
     if (!filter) {
         return;
     }
@@ -559,12 +662,12 @@ function collectIdsFromFilter(filter, ids) {
                 collectIdsFromFilter(item, ids);
             }
         }
-        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        catch (e_17_1) { e_17 = { error: e_17_1 }; }
         finally {
             try {
                 if (filter_1_1 && !filter_1_1.done && (_a = filter_1.return)) _a.call(filter_1);
             }
-            finally { if (e_14) throw e_14.error; }
+            finally { if (e_17) throw e_17.error; }
         }
         return;
     }
@@ -581,17 +684,17 @@ function collectIdsFromFilter(filter, ids) {
             if (key === '$or' || key === '$and' || key === '$nor') {
                 if (Array.isArray(value)) {
                     try {
-                        for (var value_2 = (e_16 = void 0, __values(value)), value_2_1 = value_2.next(); !value_2_1.done; value_2_1 = value_2.next()) {
+                        for (var value_2 = (e_19 = void 0, __values(value)), value_2_1 = value_2.next(); !value_2_1.done; value_2_1 = value_2.next()) {
                             var item = value_2_1.value;
                             collectIdsFromFilter(item, ids);
                         }
                     }
-                    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+                    catch (e_19_1) { e_19 = { error: e_19_1 }; }
                     finally {
                         try {
                             if (value_2_1 && !value_2_1.done && (_c = value_2.return)) _c.call(value_2);
                         }
-                        finally { if (e_16) throw e_16.error; }
+                        finally { if (e_19) throw e_19.error; }
                     }
                 }
             }
@@ -600,16 +703,16 @@ function collectIdsFromFilter(filter, ids) {
             }
         }
     }
-    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    catch (e_18_1) { e_18 = { error: e_18_1 }; }
     finally {
         try {
             if (_e && !_e.done && (_b = _d.return)) _b.call(_d);
         }
-        finally { if (e_15) throw e_15.error; }
+        finally { if (e_18) throw e_18.error; }
     }
 }
 function collectIdsFromFilterValue(value, ids) {
-    var e_17, _a, e_18, _b;
+    var e_20, _a, e_21, _b;
     if (value === null || value === undefined) {
         return;
     }
@@ -620,12 +723,12 @@ function collectIdsFromFilterValue(value, ids) {
                 collectIdsFromFilterValue(item, ids);
             }
         }
-        catch (e_17_1) { e_17 = { error: e_17_1 }; }
+        catch (e_20_1) { e_20 = { error: e_20_1 }; }
         finally {
             try {
                 if (value_3_1 && !value_3_1.done && (_a = value_3.return)) _a.call(value_3);
             }
-            finally { if (e_17) throw e_17.error; }
+            finally { if (e_20) throw e_20.error; }
         }
         return;
     }
@@ -647,12 +750,12 @@ function collectIdsFromFilterValue(value, ids) {
                 }
             }
         }
-        catch (e_18_1) { e_18 = { error: e_18_1 }; }
+        catch (e_21_1) { e_21 = { error: e_21_1 }; }
         finally {
             try {
                 if (_d && !_d.done && (_b = _c.return)) _b.call(_c);
             }
-            finally { if (e_18) throw e_18.error; }
+            finally { if (e_21) throw e_21.error; }
         }
         return;
     }
@@ -690,7 +793,7 @@ function normalizeId(value) {
     return null;
 }
 function cloneDependencyMap(original) {
-    var e_19, _a;
+    var e_22, _a;
     var cloned = new Map();
     try {
         for (var _b = __values(original.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -698,17 +801,17 @@ function cloneDependencyMap(original) {
             cloned.set(collection, new Set(ids));
         }
     }
-    catch (e_19_1) { e_19 = { error: e_19_1 }; }
+    catch (e_22_1) { e_22 = { error: e_22_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_19) throw e_19.error; }
+        finally { if (e_22) throw e_22.error; }
     }
     return cloned;
 }
 function cloneFilterMap(original) {
-    var e_20, _a;
+    var e_23, _a;
     var cloned = new Map();
     try {
         for (var _b = __values(original.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -716,17 +819,17 @@ function cloneFilterMap(original) {
             cloned.set(collection, filters.map(function (filter) { return (0, common_1.deepCopy)(filter); }));
         }
     }
-    catch (e_20_1) { e_20 = { error: e_20_1 }; }
+    catch (e_23_1) { e_23 = { error: e_23_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_20) throw e_20.error; }
+        finally { if (e_23) throw e_23.error; }
     }
     return cloned;
 }
 function cloneQueryMetaMap(original) {
-    var e_21, _a;
+    var e_24, _a;
     var cloned = new Map();
     try {
         for (var _b = __values(original.entries()), _c = _b.next(); !_c.done; _c = _b.next()) {
@@ -734,14 +837,281 @@ function cloneQueryMetaMap(original) {
             cloned.set(collection, metaList.map(function (meta) { return (0, common_1.deepCopy)(meta); }));
         }
     }
-    catch (e_21_1) { e_21 = { error: e_21_1 }; }
+    catch (e_24_1) { e_24 = { error: e_24_1 }; }
     finally {
         try {
             if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
         }
-        finally { if (e_21) throw e_21.error; }
+        finally { if (e_24) throw e_24.error; }
     }
     return cloned;
 }
+function buildLookupPipelineFilters(rootDoc, target) {
+    var e_25, _a;
+    if (!target.pipeline || !target.pipeline.length) {
+        return { filters: [], unresolved: false };
+    }
+    var matchStages = target.pipeline.map(function (stage) { return ({ stage: stage, base: stage.$match }); }).filter(function (entry) { return entry.base; });
+    if (!matchStages.length) {
+        return buildLookupPipelineFromStack(target.pipeline, [], rootDoc, target.let);
+    }
+    var letValuesResult = resolveLetVariables(rootDoc, target.let);
+    if (!letValuesResult.resolved) {
+        return { filters: [], unresolved: true };
+    }
+    var combinedMatches = [];
+    try {
+        for (var matchStages_1 = __values(matchStages), matchStages_1_1 = matchStages_1.next(); !matchStages_1_1.done; matchStages_1_1 = matchStages_1.next()) {
+            var base = matchStages_1_1.value.base;
+            var substitutionState = { unresolved: false };
+            var substituted = substituteLetVariables(base, letValuesResult.values, rootDoc, substitutionState);
+            if (substitutionState.unresolved || containsUnresolvedLetReference(substituted)) {
+                return { filters: [], unresolved: true };
+            }
+            combinedMatches.push(substituted);
+        }
+    }
+    catch (e_25_1) { e_25 = { error: e_25_1 }; }
+    finally {
+        try {
+            if (matchStages_1_1 && !matchStages_1_1.done && (_a = matchStages_1.return)) _a.call(matchStages_1);
+        }
+        finally { if (e_25) throw e_25.error; }
+    }
+    if (!combinedMatches.length) {
+        return buildLookupPipelineFromStack(target.pipeline, [], rootDoc, target.let);
+    }
+    if (combinedMatches.length === 1) {
+        return { filters: [combinedMatches[0]], unresolved: false };
+    }
+    return { filters: [{ $and: combinedMatches }], unresolved: false };
+}
+function buildLookupPipelineFromStack(pipeline, initialFilters, rootDoc, letMap) {
+    var currentFilters = initialFilters.slice();
+    var unresolved = false;
+    var entries = pipeline.map(function (stage) { return stage ? Object.keys(stage)[0] : null; });
+    for (var i = 0; i < pipeline.length; i++) {
+        var stage = pipeline[i];
+        var stageType = entries[i];
+        if (stageType === '$match' && stage.$match) {
+            var letValuesResult = resolveLetVariables(rootDoc, letMap);
+            if (!letValuesResult.resolved) {
+                unresolved = true;
+                break;
+            }
+            var substitutionState = { unresolved: false };
+            var substituted = substituteLetVariables(stage.$match, letValuesResult.values, rootDoc, substitutionState);
+            if (substitutionState.unresolved || containsUnresolvedLetReference(substituted)) {
+                unresolved = true;
+                break;
+            }
+            currentFilters.push(substituted);
+        }
+        else if (stageType === '$match') {
+            unresolved = true;
+            break;
+        }
+        else if (stageType === '$facet') {
+            unresolved = true;
+            break;
+        }
+    }
+    if (!currentFilters.length) {
+        return { filters: [], unresolved: unresolved };
+    }
+    if (currentFilters.length === 1) {
+        return { filters: currentFilters, unresolved: unresolved };
+    }
+    return { filters: [{ $and: currentFilters }], unresolved: unresolved };
+}
+function resolveLetVariables(rootDoc, letMap) {
+    var e_26, _a;
+    if (!letMap || typeof letMap !== 'object') {
+        return { resolved: true, values: {} };
+    }
+    var values = {};
+    try {
+        for (var _b = __values(Object.entries(letMap)), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var _d = __read(_c.value, 2), key = _d[0], expression = _d[1];
+            var evaluation = evaluateLetExpression(rootDoc, expression);
+            if (!evaluation.resolved) {
+                return { resolved: false, values: null };
+            }
+            values[key] = evaluation.value;
+        }
+    }
+    catch (e_26_1) { e_26 = { error: e_26_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_26) throw e_26.error; }
+    }
+    return { resolved: true, values: values };
+}
+function evaluateLetExpression(rootDoc, expression) {
+    if (typeof expression === 'string') {
+        if (expression.startsWith('$$ROOT.')) {
+            var path = expression.slice('$$ROOT.'.length);
+            return { resolved: true, value: getValueByPath(rootDoc, path) };
+        }
+        else if (expression === '$$ROOT') {
+            return { resolved: true, value: rootDoc };
+        }
+        else if (expression.startsWith('$$')) {
+            return { resolved: false, value: null };
+        }
+        else if (expression.startsWith('$')) {
+            var path = expression.slice(1);
+            return { resolved: true, value: getValueByPath(rootDoc, path) };
+        }
+        else {
+            return { resolved: true, value: expression };
+        }
+    }
+    else if (Array.isArray(expression)) {
+        return { resolved: false, value: null };
+    }
+    else if (expression && typeof expression === 'object') {
+        return { resolved: false, value: null };
+    }
+    return { resolved: true, value: expression };
+}
+function substituteLetVariables(node, letValues, rootDoc, state) {
+    var e_27, _a;
+    if (Array.isArray(node)) {
+        return node.map(function (item) { return substituteLetVariables(item, letValues, rootDoc, state); });
+    }
+    if (node && typeof node === 'object') {
+        var output = {};
+        try {
+            for (var _b = __values(Object.entries(node)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), key = _d[0], value = _d[1];
+                output[key] = substituteLetVariables(value, letValues, rootDoc, state);
+            }
+        }
+        catch (e_27_1) { e_27 = { error: e_27_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_27) throw e_27.error; }
+        }
+        return output;
+    }
+    if (typeof node === 'string') {
+        if (node.startsWith('$$ROOT.')) {
+            var path = node.slice('$$ROOT.'.length);
+            return getValueByPath(rootDoc, path);
+        }
+        if (node === '$$ROOT') {
+            return rootDoc;
+        }
+        if (node.startsWith('$$')) {
+            var varName = node.slice(2);
+            if (Object.prototype.hasOwnProperty.call(letValues, varName)) {
+                return letValues[varName];
+            }
+            state.unresolved = true;
+            return node;
+        }
+    }
+    return node;
+}
+function containsUnresolvedLetReference(node) {
+    if (typeof node === 'string') {
+        return node.includes('$$');
+    }
+    if (Array.isArray(node)) {
+        return node.some(function (item) { return containsUnresolvedLetReference(item); });
+    }
+    if (node && typeof node === 'object') {
+        return Object.values(node).some(function (value) { return containsUnresolvedLetReference(value); });
+    }
+    return false;
+}
+function getValueByPath(source, path) {
+    var e_28, _a;
+    if (!source || !path) {
+        return undefined;
+    }
+    var segments = path.split('.');
+    var current = source;
+    try {
+        for (var segments_1 = __values(segments), segments_1_1 = segments_1.next(); !segments_1_1.done; segments_1_1 = segments_1.next()) {
+            var segment = segments_1_1.value;
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (Array.isArray(current)) {
+                var index = parseInt(segment, 10);
+                if (isNaN(index) || index < 0 || index >= current.length) {
+                    return undefined;
+                }
+                current = current[index];
+            }
+            else {
+                current = current[segment];
+            }
+        }
+    }
+    catch (e_28_1) { e_28 = { error: e_28_1 }; }
+    finally {
+        try {
+            if (segments_1_1 && !segments_1_1.done && (_a = segments_1.return)) _a.call(segments_1);
+        }
+        finally { if (e_28) throw e_28.error; }
+    }
+    return current;
+}
+function canonicalizeFilter(filter) {
+    return JSON.stringify(sortKeys(filter));
+}
+function sortKeys(value) {
+    var e_29, _a;
+    if (Array.isArray(value)) {
+        return value.map(function (item) { return sortKeys(item); });
+    }
+    if (value && typeof value === 'object') {
+        var sorted = {};
+        var keys = Object.keys(value).sort();
+        try {
+            for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+                var key = keys_1_1.value;
+                sorted[key] = sortKeys(value[key]);
+            }
+        }
+        catch (e_29_1) { e_29 = { error: e_29_1 }; }
+        finally {
+            try {
+                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+            }
+            finally { if (e_29) throw e_29.error; }
+        }
+        return sorted;
+    }
+    return value;
+}
+function dedupeFilters(filters) {
+    var e_30, _a;
+    var map = new Map();
+    try {
+        for (var filters_1 = __values(filters), filters_1_1 = filters_1.next(); !filters_1_1.done; filters_1_1 = filters_1.next()) {
+            var filter = filters_1_1.value;
+            var key = canonicalizeFilter(filter);
+            if (!map.has(key)) {
+                map.set(key, filter);
+            }
+        }
+    }
+    catch (e_30_1) { e_30 = { error: e_30_1 }; }
+    finally {
+        try {
+            if (filters_1_1 && !filters_1_1.done && (_a = filters_1.return)) _a.call(filters_1);
+        }
+        finally { if (e_30) throw e_30.error; }
+    }
+    return Array.from(map.values());
+}
 
 //# sourceMappingURL=subscription-dependency-context.js.map