@omegup/msync 0.0.31 → 0.0.32-test2

package/index.d.ts

@@ -55,7 +55,7 @@ declare const root: <T extends O>() => Field<T, T, unknown>;
 declare const ctx: <T>() => <K extends string>(k: K) => Field<unknown, T, RORec<K, T>>;
 
 declare const QueryRaw: unique symbol;
-type QueryRaw<T, C> = RawObj & {
+type QueryRaw<T, C = unknown> = RawObj & {
     [Type]?(x: typeof QueryRaw, y: T, c: C): void;
 };
 declare const Query: unique symbol;
@@ -457,6 +457,7 @@ type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S exte
     as: AsLiteral<As>;
 };
 declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
+declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE | null>>;
 
 declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
 
@@ -478,7 +479,7 @@ declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V
 declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
 
 type s$1 = string;
-declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U> & ID>>;
+declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc, Null extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, includeNull?: Null) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U | Null> & ID>>;
 
 type s = string;
 declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;
@@ -662,4 +663,4 @@ declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Pr
 declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleInsert, $simpleMerge, $sum, $unwind, $unwindDelta, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $replaceWith, $set, $simpleInsert, $simpleMerge, $sum, $unwind, $unwindDelta, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, Expr, type ExprHKT, type Exprs, type ExprsExact, type ExprsExactHKT, type ExprsPart, Field, type ID, type Loose, Machine, type Merge, type MergeArgs, type MergeInto, type MergeMapOArgs, type Model, type N, type NoRaw, type O, type OPick, type OPickD, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, type doc, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, type notArr, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };

package/index.esm.js

@@ -465,7 +465,12 @@ const $replaceWith1 = (expr) => f => {
         { $replaceWith: parts.reduce((v, k) => ({ [k]: v }), expr.raw(f()).get()) },
     ]);
 };
-const $unwind1 = (k) => f => asStages([{ $unwind: `$${f().of(k).str()}` }]);
+const $unwind1 = (k, includeNull) => f => {
+    const path = `$${f().of(k).str()}`;
+    return asStages([
+        { $unwind: path },
+    ]);
+};
 const $group1 = (id, args) => (f) => asStages([
     {
         $group: {
@@ -496,7 +501,7 @@ const $simpleLookup1 = (args) => f => {
 const $match_ = (query) => $match1(query)(root);
 const $set_ = (updater) => $set1(updater)(root);
 const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
-const $unwind_ = (k) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -612,29 +617,6 @@ const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
 const $groupId = (id, args, out, extra) => $groupMerge(id, args, { into: out, whenNotMatched: 'fail' }, '_id', extra);
 const $group = (id, args, out, extra, idPrefix = '') => $groupMerge(id, args, { into: out, whenNotMatched: 'insert' }, '_grp', extra, idPrefix);
 
-const $expr = (expr) => ({
-    raw: f => ({ $expr: expr.raw(f).get() }),
-});
-
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
-    root().of('_id').expr();
-    root().of(k2).of('_id').expr();
-    return link()
-        .with($simpleLookup1({
-        coll,
-        k: k2,
-        vars: map1('local', root().with(field1).expr()),
-        pipeline: link()
-            .with(input)
-            .with($match_($expr(eq(ctx()('local').expr())(root().of('before').with(field2).expr()))))
-            .with(exec)
-            .with($replaceWith_(root().of('before').expr())).stages,
-    })(f))
-        .with($unwind1(k2)(f))
-        .with(link().stages
-        ).stages;
-};
-
 const deltaExpr = (expr) => (field) => {
     return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
 };
@@ -664,7 +646,82 @@ const $setDelta = (updater) => {
         .with($setEach(k => to(nil), dict)).stages;
 };
 
-const $unwindDelta = (k1, k2, k) => {
+const $unwindDelta = (k1, k2, k, includeNull) => {
+    const outer = includeNull === null;
+    const newItems = {
+        $filter: {
+            input: { $ifNull: [`$after.${k2}`, []] },
+            as: 'a',
+            cond: {
+                $not: {
+                    $in: [
+                        '$$a._id',
+                        {
+                            $map: {
+                                input: { $ifNull: [`$before.${k2}`, []] },
+                                as: 'b',
+                                in: '$$b._id',
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    const oldItems = {
+        $filter: {
+            input: {
+                $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,
+                            ],
+                        },
+                    },
+                },
+            },
+            as: 'a',
+            cond: { $ne: ['$$a.before', '$$a.after'] },
+        },
+    };
+    const ifNull = (k, part, str = `$${[k1, k2].sort()[0]}.${part}._id`) => outer && k == k2 ? { $ifNull: [str, 'null'] } : str;
+    const interDot = ([a, b]) => [a, '.', b];
+    const partReplace = (part) => ({
+        $cond: {
+            if: { $or: [{ $eq: [`$${k1}.${part}`, null] }, { $eq: [`$${k2}.${part}`, null] }] },
+            then: null,
+            else: {
+                _id: k
+                    ? `$${k}.${part}._id`
+                    : {
+                        $concat: interDot([k1, k2].sort().map(k => ifNull(k, part))),
+                    },
+                [k1]: `$${k1}.${part}`,
+                [k2]: outer
+                    ? {
+                        $cond: {
+                            if: `$${k2}.${part}._id`,
+                            then: `$${k2}.${part}`,
+                            else: null,
+                        },
+                    }
+                    : `$${k2}.${part}`,
+            },
+        },
+    });
     const stages = link()
         .with(asStages([
         {
@@ -675,51 +732,34 @@ const $unwindDelta = (k1, k2, k) => {
                 },
                 [k2]: {
                     $concatArrays: [
-                        {
-                            $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,
-                                        ],
+                        outer
+                            ? {
+                                $cond: {
+                                    if: { $eq: [`$before.${k2}`, []] },
+                                    then: {
+                                        $cond: {
+                                            if: { $eq: [`$after.${k2}`, []] },
+                                            then: [],
+                                            else: [{ before: {}, after: null }],
+                                        },
                                     },
+                                    else: oldItems,
                                 },
-                            },
-                        },
+                            }
+                            : oldItems,
                         {
                             $map: {
-                                input: {
-                                    $filter: {
-                                        input: { $ifNull: [`$after.${k2}`, []] },
-                                        as: 'a',
-                                        cond: {
-                                            $not: {
-                                                $in: [
-                                                    '$$a._id',
-                                                    {
-                                                        $map: {
-                                                            input: { $ifNull: [`$before.${k2}`, []] },
-                                                            as: 'b',
-                                                            in: '$$b._id',
-                                                        },
-                                                    },
-                                                ],
+                                input: outer
+                                    ? {
+                                        $cond: {
+                                            if: {
+                                                $and: [{ $ne: [`$before.${k2}`, []] }, { $eq: [`$after.${k2}`, []] }],
                                             },
+                                            then: [{}],
+                                            else: newItems,
                                         },
-                                    },
-                                },
+                                    }
+                                    : newItems,
                                 as: 'a',
                                 in: { before: null, after: '$$a' },
                             },
@@ -733,45 +773,9 @@ const $unwindDelta = (k1, k2, k) => {
         .with(asStages([
         {
             $replaceWith: {
-                _id: "$_id",
-                before: {
-                    $cond: {
-                        if: { $or: [{ $eq: [`$${k1}.before`, null] }, { $eq: [`$${k2}.before`, null] }] },
-                        then: null,
-                        else: {
-                            _id: {
-                                $concat: k
-                                    ? `$${k}.before._id`
-                                    : [
-                                        `$${[k1, k2].sort()[0]}.before._id`,
-                                        '.',
-                                        `$${[k1, k2].sort()[1]}.before._id`,
-                                    ],
-                            },
-                            [k1]: `$${k1}.before`,
-                            [k2]: `$${k2}.before`,
-                        },
-                    },
-                },
-                after: {
-                    $cond: {
-                        if: { $or: [{ $eq: [`$${k1}.after`, null] }, { $eq: [`$${k2}.after`, null] }] },
-                        then: null,
-                        else: {
-                            _id: {
-                                $concat: k
-                                    ? `$${k}.after._id`
-                                    : [
-                                        `$${[k1, k2].sort()[0]}.after._id`,
-                                        '.',
-                                        `$${[k1, k2].sort()[1]}.after._id`,
-                                    ],
-                            },
-                            [k1]: `$${k1}.after`,
-                            [k2]: `$${k2}.after`,
-                        },
-                    },
-                },
+                _id: '$_id',
+                before: partReplace('before'),
+                after: partReplace('after'),
             },
         },
     ])).stages;
@@ -791,7 +795,7 @@ const $unwind = (k, dict) => ({
     raw: $unwind1(k),
 });
 
-const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k) => {
+const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, includeNull) => {
     return link()
         .with($replaceWithDelta(field(map1(k1, root().expr()))))
         .with($simpleLookup_({
@@ -820,8 +824,30 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k) => {
         const a = root().of(f1).of('before').expr();
         const part = root().of(f);
         return ite(eq(root().of(f).expr())(nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, a)), map1(k1, part.of(k1).expr())))));
-    }))
-        .with($unwindDelta(k1, k2, k)).stages;
+    })).with($unwindDelta(k1, k2, k, includeNull)).stages;
+};
+
+const $expr = (expr) => ({
+    raw: f => ({ $expr: expr.raw(f).get() }),
+});
+
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+    root().of('_id').expr();
+    root().of(k2).of('_id').expr();
+    return link()
+        .with($simpleLookup1({
+        coll,
+        k: k2,
+        vars: map1('local', root().with(field1).expr()),
+        pipeline: link()
+            .with(input)
+            .with($match_($expr(eq(ctx()('local').expr())(root().of('before').with(field2).expr()))))
+            .with(exec)
+            .with($replaceWith_(root().of('before').expr())).stages,
+    })(f))
+        .with($unwind1(k2)(f))
+        .with(link().stages
+        ).stages;
 };
 
 const asBefore = (f) => f(() => root().of('before'));
@@ -937,9 +963,9 @@ const runCont = async ({ next }, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup) => {
-    createIndex(leftSnapshot.coll, { [lField.str()]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
-    createIndex(rightSnapshot.coll, { [rField.str()]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, includeNull) => {
+    createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
+    createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     const rightJoinField = { field1: lField, field2: rField };
     const joinId = 'left';
     const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as));
@@ -952,7 +978,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
             const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
-            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId);
+            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, includeNull);
             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);
@@ -966,7 +992,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input)));
+const $lookup1 = (p, includeNull) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, includeNull)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -974,6 +1000,13 @@ const $lookup = (p) => (l) => $lookup1({
     rField: p.foreignField,
     left: l(emptyDelta()),
 });
+const $outerLookup = (p) => (l) => $lookup1({
+    right: p.from,
+    as: p.as,
+    lField: p.localField,
+    rField: p.foreignField,
+    left: l(emptyDelta()),
+}, null);
 
 const operator = () => (op) => (operand) => {
     return {
@@ -1186,7 +1219,7 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
 };
 
 const actions = {
-    updateMany: (c, args) => [c.updateMany(...args), [`db['${c.collectionName}'].updateMany(`, ...args, ')']],
+    updateMany: (c, args) => [c.updateMany(...args), [`db['${c.collectionName}'].updateMany(...`, args, ')']],
 };
 const streamNames = {};
 const executes$1 = (view, input, streamName) => {
@@ -1266,9 +1299,9 @@ const executes$1 = (view, input, streamName) => {
                     params: p,
                 };
                 const [action, out] = actions[method](collection, params);
-                log('teardown', `db.['${snapshotCollection.collectionName}'].drop()`, ...out);
+                log('teardown', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
                 await Promise.all([snapshotCollection.drop(), action]);
-                log('teardown done', `db.['${snapshotCollection.collectionName}'].drop()`, ...out);
+                log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
             };
             if (exists && !same)
                 await handleTeardown(exists);
@@ -1745,4 +1778,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $pushDict, $rand, $replaceWith, $set, $simpleInsert, $simpleMerge, $sum, $unwind, $unwindDelta, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $expr, $getField, $group, $groupId, $groupMerge, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map1, $match, $matchDelta, $merge, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $replaceWith, $set, $simpleInsert, $simpleMerge, $sum, $unwind, $unwindDelta, Field, Machine, add, and, array, ceil, comp, concat$1 as concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first$1 as first, firstSure, floor, from, func, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, notNull, now, or, pair, prepare, rand, range, root, set, setField, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };