@omegup/msync 0.0.55 → 0.0.57

package/index.d.ts

@@ -449,31 +449,6 @@ declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG ext
 declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<string, V, "_id"> = Loose<string, V, "_id">>(id: Expr<string, T>, args: DeltaAccumulators<T, O & Omit<V, Denied>>, out: RWCollection<Replace<Out, Strict<string, V, "_id", EE>>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | keyof Omit<V, IdAndTsKeys>>, doc & Omit<V, IdAndTsKeys>>) => StreamRunnerParam<Delta<T>, "out">;
 declare const $group: <T extends O, Grp extends notArr, V extends O, EE = {}, Out extends Loose<Grp, V, "_grp"> = Loose<Grp, V, "_grp">>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<"_grp">>>, out: RWCollection<Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | keyof Omit<V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
 
-declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
-declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
-declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
-    expr: Expr<Arr<T>, D, C>;
-    as: K;
-    cond: Expr<unknown, D, C & RORec<K, T>>;
-    limit?: Expr<number, D, C>;
-}) => Expr<Arr<T>, D, C>;
-declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
-    expr: Expr<Arr<T>, D, C>;
-    sortBy: K;
-    order?: 1 | -1;
-}) => Expr<Arr<T>, D, C>;
-declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
-declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
-declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
-declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-type NullToOBJ<N extends null> = N extends null ? O : N;
-declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(exprs_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
-declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
-declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
-declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
-
 type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
     localField: Field<LQ, S>;
     foreignField: Field<RQ, S>;
@@ -481,10 +456,9 @@ 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, LNull extends null = never, RNull extends null = never>(p: Params<As, LQ, RQ, RE, S>, outer: {
-    left?: LNull;
-    right?: RNull;
-}) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ | NullToOBJ<RNull>, (LE | NullToOBJ<RNull>) & RORec<As, RE | LNull>>;
+declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr, Null extends null = never>(p: Params<As, LQ, RQ, RE, S>, outer?: {
+    left?: Null;
+}) => <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>;
 
@@ -539,7 +513,7 @@ interface SnapshotStreamHKT extends HKT<O2> {
 interface DeltaHKT extends HKT<O3> {
     readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
 }
-declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, streamName: string) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT, DeltaHKT>;
+declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed$1<KK>>, streamName: string, skip?: boolean) => DeltaPipe<AllowedPick$1<V, KK>, AllowedPick$1<V, KK>, SnapshotStreamHKT, DeltaHKT>;
 
 type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
 type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
@@ -576,6 +550,31 @@ declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
 declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
 declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
 
+declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
+declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
+declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
+    expr: Expr<Arr<T>, D, C>;
+    as: K;
+    cond: Expr<unknown, D, C & RORec<K, T>>;
+    limit?: Expr<number, D, C>;
+}) => Expr<Arr<T>, D, C>;
+declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
+    expr: Expr<Arr<T>, D, C>;
+    sortBy: K;
+    order?: 1 | -1;
+}) => Expr<Arr<T>, D, C>;
+declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
+declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
+declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
+declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
+type NullToOBJ<N extends null> = N extends null ? O : N;
+declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(exprs_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
+declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
+declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
+declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;
+
 declare const dayAndMonthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;
 declare const now: <D, C>() => Expr<Date, D, C>;
 declare const monthPart: <D, C>(date: Expr<Date, D, C>) => Expr<string, D, C>;

package/index.esm.js

@@ -468,7 +468,7 @@ const $replaceWith1 = (expr) => f => {
 const $unwind1 = (k, includeNull) => f => {
     const path = `$${f().of(k).str()}`;
     return asStages([
-        { $unwind: path },
+        { $unwind: includeNull === null ? { path, preserveNullAndEmptyArrays: true } : path },
     ]);
 };
 const $group1 = (id, args) => (f) => asStages([
@@ -501,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, includeNull) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k, includeNull)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -1086,9 +1086,8 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
     })).with($unwindDelta(k1, k2, k, includeNull)).stages;
 };
 
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
     root().of('_id').expr();
-    root().of(k2).of('_id').expr();
     return link()
         .with($simpleLookup1({
         coll,
@@ -1100,7 +1099,7 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) =>
             .with(exec)
             .with($replaceWith_(root().of('before').expr())).stages,
     })(f))
-        .with($unwind1(k2)(f))
+        .with($unwind1(k2, includeNull)(f))
         .with(link().stages
         ).stages;
 };
@@ -1235,12 +1234,12 @@ 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, outerRight) => {
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
     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));
+    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
     const idB = { _id: 'b' };
@@ -1249,7 +1248,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         stages: consume => consume(concatTStages(resultingSnapshot, asBefore(stagesUntilNextLookup.raw))),
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
-            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId, outerRight);
+            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
             const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, 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 lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
@@ -1264,7 +1263,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p, outer) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outer?.left, outer?.right)));
+const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -1278,7 +1277,7 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
-}, outer);
+}, outer?.left);
 
 const filterUndefined = (applyOperator) => {
     return (op, args) => applyOperator(op, args.filter(defined));
@@ -1482,7 +1481,7 @@ const actions = {
     ],
 };
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes$1 = (view, input, streamName, skip = false) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1662,7 +1661,9 @@ const executes$1 = (view, input, streamName) => {
             })
                 .then(doc => (doc ? next(step3({ _id: streamName, ts: l.ts }), 'restart') : step8(l))), 'wait for change');
         };
-        return stop;
+        return skip
+            ? withStop(() => SynchronousPromise.resolve(next(step3(null), 'clone into new collection')))
+            : stop;
     };
     const hasBefore = root().of('before').has($ne(null));
     return {
@@ -1674,7 +1675,7 @@ const executes$1 = (view, input, streamName) => {
         out: run,
     };
 };
-const staging = (view, streamName) => pipe(input => executes$1(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
+const staging = (view, streamName, skip = false) => pipe(input => executes$1(view, input, streamName, skip), emptyDelta(), concatDelta, emptyDelta);
 
 const executes = (view, input, streamName) => {
     const hash = crypto$1

package/index.js

@@ -470,7 +470,7 @@ const $replaceWith1 = (expr) => f => {
 const $unwind1 = (k, includeNull) => f => {
     const path = `$${f().of(k).str()}`;
     return asStages([
-        { $unwind: path },
+        { $unwind: includeNull === null ? { path, preserveNullAndEmptyArrays: true } : path },
     ]);
 };
 const $group1 = (id, args) => (f) => asStages([
@@ -503,7 +503,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, includeNull) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k, includeNull)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -1088,9 +1088,8 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, incl
     })).with($unwindDelta(k1, k2, k, includeNull)).stages;
 };
 
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNull) => (f) => {
     root().of('_id').expr();
-    root().of(k2).of('_id').expr();
     return link()
         .with($simpleLookup1({
         coll,
@@ -1102,7 +1101,7 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) =>
             .with(exec)
             .with($replaceWith_(root().of('before').expr())).stages,
     })(f))
-        .with($unwind1(k2)(f))
+        .with($unwind1(k2, includeNull)(f))
         .with(link().stages
         ).stages;
 };
@@ -1237,12 +1236,12 @@ 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, outerRight) => {
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
     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));
+    const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
     const idB = { _id: 'b' };
@@ -1251,7 +1250,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         stages: consume => consume(concatTStages(resultingSnapshot, asBefore(stagesUntilNextLookup.raw))),
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
-            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId, outerRight);
+            const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
             const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, 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 lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
@@ -1266,7 +1265,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p, outer) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outer?.left, outer?.right)));
+const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -1280,7 +1279,7 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     lField: p.localField,
     rField: p.foreignField,
     left: l(emptyDelta()),
-}, outer);
+}, outer?.left);
 
 const filterUndefined = (applyOperator) => {
     return (op, args) => applyOperator(op, args.filter(defined));
@@ -1484,7 +1483,7 @@ const actions = {
     ],
 };
 const streamNames = {};
-const executes$1 = (view, input, streamName) => {
+const executes$1 = (view, input, streamName, skip = false) => {
     const hash = crypto$1
         .createHash('md5')
         .update(new Error().stack + '')
@@ -1664,7 +1663,9 @@ const executes$1 = (view, input, streamName) => {
             })
                 .then(doc => (doc ? next(step3({ _id: streamName, ts: l.ts }), 'restart') : step8(l))), 'wait for change');
         };
-        return stop;
+        return skip
+            ? withStop(() => synchronousPromise.SynchronousPromise.resolve(next(step3(null), 'clone into new collection')))
+            : stop;
     };
     const hasBefore = root().of('before').has($ne(null));
     return {
@@ -1676,7 +1677,7 @@ const executes$1 = (view, input, streamName) => {
         out: run,
     };
 };
-const staging = (view, streamName) => pipe(input => executes$1(view, input, streamName), emptyDelta(), concatDelta, emptyDelta);
+const staging = (view, streamName, skip = false) => pipe(input => executes$1(view, input, streamName, skip), emptyDelta(), concatDelta, emptyDelta);
 
 const executes = (view, input, streamName) => {
     const hash = crypto$1

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.0.55",
+    "version": "0.0.57",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",