@omegup/msync 0.1.45 → 0.1.46

package/index.js

@@ -219,7 +219,7 @@ const { root, ctx } = Field;
 const asAccumulator = (x) => x;
 const $sum_ = (expr) => ({ raw: f => asAccumulator({ $sum: expr.raw(f).get() }) });
 const $sum = (expr) => ({
-    group: $sum_(ite(root().of('old').expr(), subtract(val(0), $ifNull(sub(expr, root().of('v')), val(0))), sub(expr, root().of('v')))),
+    group: $sum_(ite(root().of('deleted').expr(), val(0), ite(root().of('old').expr(), subtract(val(0), $ifNull(sub(expr, root().of('v')), val(0))), sub(expr, root().of('v'))))),
     merge: (x, y) => add($ifNull(x, val(0)), y),
 });
 const $accumulator_ = (init, accumulateArgs, accumulate, merge) => {
@@ -242,7 +242,13 @@ const $accumulator = (init, accumulateArgs, accumulate, merge) => ({
 });
 const $countDict = (expr) => $accumulator(function () {
     return {};
-}, [sub(expr, root().of('v')), root().of('old').expr()], function (a, k, old) {
+}, [
+    sub(expr, root().of('v')),
+    root().of('old').expr(),
+    root().of('deleted').expr(),
+], function (a, k, old, deleted) {
+    if (deleted)
+        return a;
     let y = (a[k] || 0) + (old ? -1 : 1);
     return y ? (a[k] = y) : delete a[k], a;
 }, function (a, b) {
@@ -253,7 +259,13 @@ const $countDict = (expr) => $accumulator(function () {
 });
 const $countDictArray = (expr) => $accumulator(function () {
     return {};
-}, [sub(expr, root().of('v')), root().of('old').expr()], function (a, keys, old) {
+}, [
+    sub(expr, root().of('v')),
+    root().of('old').expr(),
+    root().of('deleted').expr(),
+], function (a, keys, old, deleted) {
+    if (deleted)
+        return a;
     keys.forEach(k => {
         const y = (a[k] || 0) + (old ? -1 : 1);
         if (y)
@@ -274,7 +286,10 @@ const $pushDict = (key, value) => $accumulator(function () {
     sub(key, root().of('v')),
     sub(value, root().of('v')),
     root().of('old').expr(),
-], function (ra, k, v, old) {
+    root().of('deleted').expr(),
+], function (ra, k, v, old, deleted) {
+    if (deleted)
+        return ra;
     let a = { ...ra };
     const equal = (a, b) => {
         if (!a || !b)
@@ -402,6 +417,7 @@ const assertEqual = () => ({
     forward1: id,
     backward1: id,
 });
+const literalsEqaul = (_) => assertEqual();
 const omitRORec = () => assertEqual();
 const omitPick = () => assertEqual();
 const translateOmit = () => assertEqual();
@@ -420,7 +436,7 @@ const filter = ({ as, cond, expr, limit, }) => asExpr({
             input: expr.raw(f).get(),
             as,
             cond: cond.raw(f).get(),
-            limit: limit?.raw(f).get() ?? null,
+            ...(limit ? { limit: limit.raw(f).get() } : {}),
         },
     }),
 });
@@ -564,9 +580,23 @@ const subGroup = (id, args, addGrp) => {
     const part = filterDefined(array(ite(eqTyped(root().of('after').expr(), nil), nil, field({
         v: ['v', root().of('after').expr()],
         old: ['old', val(false)],
+        deleted: [
+            'deleted',
+            root()
+                .of('deleted')
+                .of('after')
+                .expr(),
+        ],
     })), ite(eqTyped(root().of('before').expr(), nil), nil, field({
         v: ['v', root().of('before').expr()],
         old: ['old', val(true)],
+        deleted: [
+            'deleted',
+            root()
+                .of('deleted')
+                .of('before')
+                .expr(),
+        ],
     }))));
     const replaceWith = (expr) => $replaceWith_(expr);
     return link()
@@ -1052,9 +1082,10 @@ const $setDelta = (updater) => {
         after1: ['after1', 'after'],
         before1: ['before1', 'before'],
     };
-    const update = (k) => subUpdater(weaken(updater), root().of(k));
+    const side = (k) => root().of(k);
+    const update = (k) => subUpdater(weaken(updater), side(k));
     return link()
-        .with($setEach(k => to(root().of(k).expr()), dict))
+        .with($setEach(k => to(side(k).expr()), dict))
         .with($setEach(update, dict))
         .with($replaceWithEach(field => root().of(`${field}1`).expr()))
         .with($setEach(k => to(nil), dict)).stages;
@@ -1088,147 +1119,229 @@ const dualIn = operator();
 const $in = dualIn('$in');
 const $nin = dualIn('$nin');
 
-const $unwindDelta = (k1, k2, k, middle, includeNull1, includeNull2) => {
-    const outer1 = includeNull1 === null;
-    const outer2 = includeNull2 === null;
-    const newItems = {
-        $filter: {
-            input: { $ifNull: [`$after.${k2}`, []] },
+const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), matchDelta());
+const matchDelta = () => {
+    const part = (side) => root().of(side).expr();
+    return $match_($expr(ne(part('before'))(part('after'))));
+};
+
+const $match = (query) => ({
+    raw: $match1($expr(query)),
+    delta: $matchDelta(query),
+});
+
+const joinIdOf = (k, k1, k1Id, k2Id) => {
+    if (k === k1)
+        return k1Id;
+    if (typeof k === 'string')
+        return k2Id;
+    const idOf = (key) => (key === k1 ? k1Id : k2Id);
+    return concat(idOf(k[0]), val(k[1]), idOf(k[2]));
+};
+const andAlso = (probe, keep) => ite(eqTyped(probe, nil), nil, keep);
+const notObjAndAlso = (probe, keep) => ite(eqTyped(probe, field({})), nil, keep);
+const $unwindDelta = (k1, k2, k, includeNull1, includeNull2) => {
+    const emptyArr = array();
+    const src = root();
+    const k2Arr = (side) => src.of(side).of(k2).expr();
+    const k2OrEmpty = (side) => $ifNull(k2Arr(side), emptyArr);
+    const k2Empty = (side) => eq(k2Arr(side))(emptyArr);
+    const beforeItems = k2OrEmpty('before');
+    const afterItems = k2OrEmpty('after');
+    const beforeIds = $map1(beforeItems, (item) => item.of('_id').expr());
+    const newByK2Id = filter({
+        expr: afterItems,
+        as: 'a',
+        cond: not(inArray(ctx()('a').of('_id').expr(), beforeIds)),
+    });
+    const oldByK2Id = $map0({
+        input: beforeItems,
+        as: 'b',
+        expr: field({
+            before: ['before', ctx()('b').expr()],
+            after: [
+                'after',
+                first$1(filter({
+                    expr: afterItems,
+                    as: 'a',
+                    cond: eq(ctx()('a').of('_id').expr())(ctx()('b').of('_id').expr()),
+                })),
+            ],
+        }),
+    });
+    const k1Slot = (fill) => array(field({
+        before: [
+            'before',
+            $ifNull(first$1(beforeItems), fill),
+        ],
+        after: [
+            'after',
+            $ifNull(first$1(afterItems), fill),
+        ],
+    }));
+    const kept = k === k1 ? k1Slot(nil) : oldByK2Id;
+    const added = k === k1 ? emptyArr : newByK2Id;
+    const k1Delta = field({
+        before: [
+            'before',
+            $ifNull(src.of('before').of(k1).expr(), nil),
+        ],
+        after: [
+            'after',
+            $ifNull(src.of('after').of(k1).expr(), nil),
+        ],
+    });
+    const unwindJoin = ({ kept, added, padToNull, isPad, join, }) => {
+        const newDeltas = $map0({
+            input: added,
             as: 'a',
-            cond: {
-                $not: {
-                    $in: [
-                        '$$a._id',
-                        {
-                            $map: {
-                                input: { $ifNull: [`$before.${k2}`, []] },
-                                as: 'b',
-                                in: '$$b._id',
-                            },
-                        },
-                    ],
-                },
-            },
-        },
-    };
-    const oldItems = {
-        $map: {
-            input: { $ifNull: [`$before.${k2}`, []] },
-            as: 'b',
-            in: {
-                before: '$$b',
-                after: {
-                    $ifNull: [
-                        {
-                            $first: {
-                                $filter: {
-                                    input: `$after.${k2}`,
-                                    as: 'a',
-                                    cond: { $eq: ['$$a._id', '$$b._id'] },
-                                },
-                            },
-                        },
-                        null,
-                    ],
-                },
-            },
-        },
-    };
-    const ifNull = (k, part, str = `$${k}.${part}._id`) => outer2 && k == k2 ? { $ifNull: [str, 'null'] } : str;
-    const interDot = ([a, b]) => [a, middle ?? '.', b];
-    const partReplace = (part) => {
-        const def = {
-            _id: k
-                ? ifNull(k, part)
-                : {
-                    $concat: interDot([k1, k2].sort().map(k => ifNull(k, part))),
-                },
-            [k1]: `$${k1}.${part}`,
-            [k2]: outer2
-                ? {
-                    $cond: {
-                        if: `$${k2}.${part}._id`,
-                        then: `$${k2}.${part}`,
-                        else: null,
-                    },
-                }
-                : `$${k2}.${part}`,
+            expr: field({
+                before: ['before', nil],
+                after: ['after', ctx()('a').expr()],
+            }),
+        });
+        const deltas = mergeObjects(field(map1(k1, k1Delta)), field(map1(k2, concatArray(kept, newDeltas))));
+        const doc = root();
+        const parentId = doc.of('_id').expr();
+        const k1At = (side) => doc.of(k1).of(side).expr();
+        const k2Raw = (side) => doc.of(k2).of(side).expr();
+        const docK2Null = root();
+        const k2Keep = (side) => docK2Null.of(k2).of(side).expr();
+        const k2At = (side) => padToNull(k2Raw(side), k2Keep(side));
+        const rowOf = (id, a, b) => mergeObjects(mergeObjects(field({ _id: ['_id', id] }), field(map1(k1, a))), field(map1(k2, b)));
+        const docK1 = root();
+        const k2RawK1 = (side) => docK1.of(k2).of(side).expr();
+        const k2KeepK1K2 = (side) => root().of(k2).of(side).expr();
+        const rowOnK1 = (side) => {
+            const t = docK1.of(k1).of(side);
+            return rowOf(t.of('_id').expr(), t.expr(), padToNull(k2RawK1(side), k2KeepK1K2(side)));
         };
-        const skipNulls = [{ $eq: [`$${k1}.${part}`, null] }, { $eq: [`$${k2}.${part}`, null] }].filter((_, i) => ![outer1, outer2][i]);
-        if (skipNulls.length === 0)
-            return def;
-        return {
-            $cond: {
-                if: skipNulls.length === 1 ? skipNulls[0] : { $or: skipNulls },
-                then: null,
-                else: def,
-            },
+        const docK2 = root();
+        const k1AtK2 = (side) => docK2.of(k1).of(side).expr();
+        const rowOnK2 = (side) => {
+            const u = docK2.of(k2).of(side);
+            return rowOf(u.of('_id').expr(), k1AtK2(side), u.expr());
         };
+        const docK1K2 = root();
+        const k1AtK1K2 = (side) => docK1K2.of(k1).of(side).expr();
+        const k2AtK1K2 = (side) => docK1K2.of(k2).of(side).expr();
+        const k1IdK1K2 = (side) => docK1K2.of(k1).of(side).of('_id').expr();
+        const k2IdK1K2 = (side) => docK1K2.of(k2).of(side).of('_id').expr();
+        const completeId = (side) => joinIdOf(k, k1, k1IdK1K2(side), k2IdK1K2(side));
+        const rowK1K2 = (side) => rowOf(completeId(side), k1AtK1K2(side), k2AtK1K2(side));
+        const liftRowId = $replaceWith_(mergeObjects(root().expr(), field({
+            _id: [
+                '_id',
+                $ifNull(root()
+                    .of('before')
+                    .of('_id')
+                    .expr(), root()
+                    .of('after')
+                    .of('_id')
+                    .expr(), root().of('_id').expr()),
+            ],
+        })));
+        const padded = (side) => isPad(k2Raw(side));
+        const emptyObj = field({});
+        const deletedFlags = mergeObjects(ite(padded('before'), field({ before: ['before', val(true)] }), emptyObj), ite(padded('after'), field({ after: ['after', val(true)] }), emptyObj));
+        const joinAt = (side) => join({
+            k1: k1At(side),
+            k2: k2At(side),
+            rowK1K2: rowK1K2(side),
+            rowOnK1: rowOnK1(side),
+            rowOnK2: rowOnK2(side),
+            k2Keep: k2Keep(side),
+            k2Raw: k2Raw(side),
+            k2RawK1: k2RawK1(side),
+            k2KeepK1K2: k2KeepK1K2(side),
+        });
+        const joinDelta = mergeObjects(field({
+            _id: ['_id', parentId],
+            before: ['before', joinAt('before')],
+            after: ['after', joinAt('after')],
+        }), ite(or(padded('before'), padded('after')), field({ deleted: ['deleted', deletedFlags] }), emptyObj));
+        return link()
+            .with($replaceWith_(mergeObjects(src.expr(), deltas)))
+            .with($unwind_(k2))
+            .with($replaceWith_(joinDelta))
+            .with(matchDelta())
+            .with(liftRowId).stages;
     };
-    const part = (k) => root().of(k).expr();
-    const stages = link()
-        .with(asStages([
-        {
-            $set: {
-                [k1]: {
-                    before: { $ifNull: [`$before.${k1}`, null] },
-                    after: { $ifNull: [`$after.${k1}`, null] },
-                },
-                [k2]: {
-                    $concatArrays: [
-                        outer2
-                            ? {
-                                $cond: {
-                                    if: { $eq: [`$before.${k2}`, []] },
-                                    then: {
-                                        $cond: {
-                                            if: { $eq: [`$after.${k2}`, []] },
-                                            then: [{ before: {}, after: {} }],
-                                            else: [{ before: {}, after: null }],
-                                        },
-                                    },
-                                    else: oldItems,
-                                },
-                            }
-                            : oldItems,
-                        {
-                            $map: {
-                                input: outer2
-                                    ? {
-                                        $cond: {
-                                            if: {
-                                                $and: [{ $ne: [`$before.${k2}`, []] }, { $eq: [`$after.${k2}`, []] }],
-                                            },
-                                            then: [{}],
-                                            else: newItems,
-                                        },
-                                    }
-                                    : newItems,
-                                as: 'a',
-                                in: { before: null, after: '$$a' },
-                            },
-                        },
-                    ],
-                },
-            },
-        },
-    ]))
-        .with($unwind_(k2))
-        .with(asStages([
-        {
-            $replaceWith: {
-                _id: '$_id',
-                before: partReplace('before'),
-                after: partReplace('after'),
+    const noPadToNull = (k2) => k2;
+    const neverPad = (_k2) => val(false);
+    if (includeNull2 === null) {
+        const padObj = field({});
+        const padDelta = (after) => field({
+            before: ['before', padObj],
+            after: ['after', after],
+        });
+        const addedPadded = k === k1
+            ? array()
+            : ite(and(not(k2Empty('before')), k2Empty('after')), array(padObj), added);
+        const padToNull = (k2, keep) => ite(eqTyped(k2, field({})), nil, keep);
+        const isPad = (k2) => ite(eqTyped(k2, field({})), val(true), val(false));
+        const keptMatched = ite(k2Empty('before'), ite(k2Empty('after'), array(padDelta(padObj)), array(padDelta(nil))), kept);
+        const padded = { added: addedPadded, padToNull, isPad };
+        if (includeNull1 === null) {
+            if (k === k1) {
+                return unwindJoin({
+                    ...padded,
+                    kept: k1Slot(padObj),
+                    join: ({ k1: k1Val, rowOnK1 }) => andAlso(k1Val, rowOnK1),
+                });
+            }
+            if (k === k2) {
+                return unwindJoin({
+                    ...padded,
+                    kept: keptMatched,
+                    join: ({ k2Raw, k2Keep, rowOnK2 }) => notObjAndAlso(k2Raw, andAlso(k2Keep, rowOnK2)),
+                });
+            }
+            return unwindJoin({
+                ...padded,
+                kept: keptMatched,
+                join: ({ k1: k1Val, k2RawK1, k2KeepK1K2, rowK1K2 }) => andAlso(k1Val, notObjAndAlso(k2RawK1, andAlso(k2KeepK1K2, rowK1K2))),
+            });
+        }
+        const eq2 = literalsEqaul();
+        if (k === k1) {
+            return unwindJoin({
+                ...padded,
+                kept: k1Slot(padObj),
+                join: ({ k1: k1Val, rowOnK1 }) => andAlso(k1Val, rowOnK1),
+            });
+        }
+        return unwindJoin({
+            ...padded,
+            kept: keptMatched,
+            join: ({ k1: k1Val, k2RawK1, k2KeepK1K2, rowK1K2 }) => andAlso(k1Val, notObjAndAlso(k2RawK1, andAlso(k2KeepK1K2, eq2.forward(rowK1K2)))),
+        });
+    }
+    if (includeNull1 === null) {
+        const eq1 = literalsEqaul();
+        return unwindJoin({
+            kept,
+            added,
+            padToNull: noPadToNull,
+            isPad: neverPad,
+            join: ({ k1, k2: k2Val, k2KeepK1K2, rowK1K2, rowOnK2 }) => {
+                return k === k2
+                    ? andAlso(k2Val, rowOnK2)
+                    : andAlso(k1, andAlso(k2KeepK1K2, eq1.forward(rowK1K2)));
             },
-        },
-        ...(!k && middle ? [{ $set: { _id: { $ifNull: ['$before._id', '$after._id'] } } }] : []),
-    ]))
-        .with($match_($expr(ne(part('before'))(part('after'))))).stages;
-    return stages;
+        });
+    }
+    return unwindJoin({
+        kept,
+        added,
+        padToNull: noPadToNull,
+        isPad: neverPad,
+        join: ({ k1, k2KeepK1K2, rowK1K2 }) => andAlso(k1, andAlso(k2KeepK1K2, rowK1K2)),
+    });
 };
 
-const $unwind = (k, dict, middle) => {
+const $unwind = (k, dict, middle = '.') => {
+    const joinK = ['left', middle, 'right'];
     return {
         delta: link()
             .with($replaceWithDelta(field({
@@ -1236,22 +1349,32 @@ const $unwind = (k, dict, middle) => {
             left: ['left', root().expr()],
             right: ['right', root().of(k).expr()],
         })))
-            .with($unwindDelta('left', 'right', false, middle))
+            .with($unwindDelta('left', 'right', joinK))
             .with($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
             key: root().of('right').expr(),
             id: root().of('_id').expr(),
         }, dict)))).stages,
-        raw: $unwind1(k),
+        raw: (f) => link()
+            .with($unwind1(k)(f))
+            .with($set1(set()({
+            _id: [
+                '_id',
+                to(joinIdOf(joinK, 'left', root().of('_id').expr(), root().of(k).of('_id').expr())),
+            ],
+        }))(f)).stages,
     };
 };
 
 const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, includeNull1, includeNull2) => {
     const omit = omitRORec();
-    const hash = crypto$1.createHash('md5').update(coll.collectionName + jsonCanonicalize.canonicalize(input) + jsonCanonicalize.canonicalize(exec)).digest('base64url');
-    const ss = (f) => to($ifNull(root().of(f).of(k1).with(field1).expr(), val(hash)));
+    const hash = crypto$1
+        .createHash('md5')
+        .update(coll.collectionName + jsonCanonicalize.canonicalize(input) + jsonCanonicalize.canonicalize(exec))
+        .digest('base64url');
+    const normForeignKey = (f) => to($ifNull(root().of(f).of(k1).with(field1).expr(), val(hash)));
     return link()
         .with($replaceWithDelta(field(map1(k1, root().expr()))))
-        .with($set_(set()({ bId: ['bId', ss('before')], aId: ['aId', ss('after')] })))
+        .with($set_(set()({ bId: ['bId', normForeignKey('before')], aId: ['aId', normForeignKey('after')] })))
         .with($simpleLookup_({
         coll,
         k: 'a',
@@ -1284,16 +1407,22 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
             return $ifNull(root().of(f).expr(), field(omit.backward(mergeExpr(omit.forward(map1(k2, otherField.of(k2).expr())), map1(k1, nil)))));
         })
         : link().stages)
-        .with($unwindDelta(k1, k2, k, undefined, includeNull1, includeNull2)).stages;
+        .with($unwindDelta(k1, k2, k, includeNull1, includeNull2)).stages;
 };
 
 const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
-    root().of('_id').expr();
+    const left = root().of('_id').expr();
+    const right = root().of(k2).of('_id').expr();
+    const keepLeft = k === 'left';
+    const composedId = typeof k === 'string' ? right : concat(left, val(k[1]), right);
     return link()
         .with($simpleLookup1({
         coll,
         k: k2,
-        fields: { local: field1, foreign: root().of('before').with(field2) },
+        fields: {
+            local: field1,
+            foreign: root().of('before').with(field2),
+        },
         vars: {},
         pipeline: link()
             .with(input)
@@ -1301,8 +1430,11 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNul
             .with($replaceWith_(root().of('before').expr())).stages,
     })(f))
         .with($unwind1(k2, includeNull)(f))
-        .with(link().stages
-        ).stages;
+        .with(keepLeft
+        ? link().stages
+        : $set1(set()({
+            _id: ['_id', to($ifNull(composedId, left))],
+        }))(f)).stages;
 };
 
 const asBefore = (f) => f(() => root().of('before'));
@@ -1498,9 +1630,11 @@ const runCont = async (it, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
+const join = ({ lField, rField, left, right, as, toMany }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft, middle = '.') => {
     const rightJoinField = { field1: lField, field2: rField };
-    const joinId = 'left';
+    const joinId = rField.str() === '_id' && toMany !== true
+        ? 'left'
+        : ['left', middle, 'right'];
     const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
@@ -1512,7 +1646,10 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
             const leftJoinField = { field1: rField, field2: lField };
             const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId, outerLeft);
             const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, undefined, outerLeft);
-            const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({ a: root().of('right').expr(), b: root().of('_id').expr() }, dictId))), stagesUntilNextLookup.delta);
+            const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
+                a: root().of('right').expr(),
+                b: root().of('_id').expr(),
+            }, dictId))), stagesUntilNextLookup.delta);
             const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
             const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
             const getRunner = (f, stages, final) => f.out({
@@ -1541,6 +1678,7 @@ const $lookup = (p) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
+    toMany: p.toMany,
 });
 const $outerLookup = (p) => (l) => $lookup1({
     right: p.from,
@@ -1548,28 +1686,9 @@ const $outerLookup = (p) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
+    toMany: p.toMany,
 }, null);
 
-const filterUndefined = (applyOperator) => {
-    return (op, args) => applyOperator(op, args.filter(defined));
-};
-const combine = (op, applyOperatorToPreItems) => (...args) => {
-    const mapToItems = applyOperatorToPreItems(op, args);
-    return mapToItems && { raw: field => mapToItems(x => x.raw(field)) };
-};
-const all = (op, x) => x.length === 0 ? undefined : f => ({ [op]: x.map(f) });
-const first = (op, x) => (x.length === 1 ? f => f(x[0]) : all(op, x));
-const $and = combine('$and', filterUndefined(first));
-const $nor = combine('$nor', filterUndefined(all));
-const $or = combine('$or', filterUndefined(first));
-
-const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), $match_($or(root().of('after').has($ne(null)), root().of('before').has($ne(null)))));
-
-const $match = (query) => ({
-    raw: $match1($expr(query)),
-    delta: $matchDelta(query),
-});
-
 const $setCore = (updater) => ({
     delta: $setDelta(updater),
     raw: $set1(updater),
@@ -1590,7 +1709,10 @@ const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
         teardown: c => c({
             collection: out,
             method: 'updateMany',
-            params: [filter, [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }]],
+            params: [
+                filter,
+                [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }],
+            ],
         }),
         raw: () => {
             const replacer = map(mergeObjects(expr, field(mergeExpr(extExpr, {
@@ -1614,7 +1736,10 @@ const $insertPart = (out, ext) => {
     const extExpr = mapExact(ext, (v) => val(v));
     return $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(extExpr), {
         deletedAt: ['deletedAt', current],
-        _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
+        _id: [
+            '_id',
+            assertNotNull(root().of('before').of('_id').expr()),
+        ],
         touchedAt: ['touchedAt', current],
     })), x), ext, extExpr);
 };
@@ -1861,6 +1986,19 @@ const actions = {
     ],
 };
 
+const filterUndefined = (applyOperator) => {
+    return (op, args) => applyOperator(op, args.filter(defined));
+};
+const combine = (op, applyOperatorToPreItems) => (...args) => {
+    const mapToItems = applyOperatorToPreItems(op, args);
+    return mapToItems && { raw: field => mapToItems(x => x.raw(field)) };
+};
+const all = (op, x) => x.length === 0 ? undefined : f => ({ [op]: x.map(f) });
+const first = (op, x) => (x.length === 1 ? f => f(x[0]) : all(op, x));
+const $and = combine('$and', filterUndefined(first));
+const $nor = combine('$nor', filterUndefined(all));
+const $or = combine('$or', filterUndefined(first));
+
 const previous = (ts) => new mongodb.Timestamp({ t: ts.high - 60, i: 0 });
 const getFirstStages = (view, needs) => {
     const { projection, hardMatch: pre, match } = view;
@@ -2393,6 +2531,7 @@ exports.gte = gte;
 exports.inArray = inArray;
 exports.isArray = isArray;
 exports.ite = ite;
+exports.joinIdOf = joinIdOf;
 exports.last = last;
 exports.log = log;
 exports.lt = lt;
@@ -2402,6 +2541,7 @@ exports.map1 = map1;
 exports.mapFromPlainDateTime = mapFromPlainDateTime;
 exports.mapToPlainDateTime = mapToPlainDateTime;
 exports.mapVal = mapVal;
+exports.matchDelta = matchDelta;
 exports.max = max;
 exports.maxDate = maxDate;
 exports.mergeExact = mergeExact;