@omegup/msync 0.1.9 → 0.1.11

package/index.d.ts

@@ -412,7 +412,7 @@ declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec
 
 type MergeInto<T extends O, Out extends O, E = unknown> = {
     whenNotMatched: 'insert';
-    into: RWCollection<T, Out>;
+    into: RWCollection<T, Out> & E;
 } | {
     whenNotMatched: 'discard' | 'fail';
     into: ReadonlyCollection<Out> & E;
@@ -455,12 +455,14 @@ type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
 type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
 type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V<VV, GG>;
 type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type OrReplace<T, V> = T | Replace<T, V>;
+type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
 
 type Denied<GID = never> = keyof (TS & ID) | GID;
 type GI<GG> = Exclude<GG, keyof TS>;
-declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, V, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
-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" | Exclude<keyof V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+declare const $groupMerge: <T extends O, Grp extends notArr, V extends O, GG extends string, EE = {}, Out extends Loose<Grp, V, GG> = Loose<Grp, V, GG>>(id: Expr<Grp, T>, args: DeltaAccumulators<T, O & Omit<V, Denied<GI<GG>>>>, out: MergeInto<Strict<Grp, V, GG, EE>, Out, WriteonlyCollection<MergedInput<Out, V, Grp, GG, EE>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, V, GG>, V_Grp<V, GG, Grp>>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
+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<MergedInput<Out, V, string, "_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<MergedInput<Out, V, Grp, "_grp", EE> | Strict<Grp, V, "_grp", EE>, Out>, extra: ExprsExact<Omit<EE, IdAndTsKeys | "_grp" | Exclude<keyof V, IdAndTsKeys | "_grp">>, Rec<"_grp", Grp> & Omit<V, IdAndTsKeys | "_grp">>, idPrefix?: string) => StreamRunnerParam<Delta<T>, "out">;
 
 type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
     localField: Field<LQ, S>;

package/index.esm.js

@@ -544,134 +544,6 @@ const subGroup = (id, args, addGrp) => {
         .with(replaceWith(field(addGrp(mapExact(args, (_, k) => $getField(root().expr(), k)))))).stages;
 };
 
-const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
-const set = () => (fields) => ({
-    raw: f => {
-        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
-    },
-});
-const weaken = (updater) => ({ raw: f => updater.raw(f) });
-const to = (expr) => ({
-    raw: f => [['', expr.raw(f).get()]],
-});
-
-const dbcoll = (x) => ({
-    db: x.dbName,
-    coll: x.collectionName,
-});
-
-const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
-    {
-        $merge: {
-            into: dbcoll(into),
-            on: on.str(),
-            ...(whenNotMatched && { whenNotMatched }),
-            ...(notMatched.stages && {
-                whenMatched: notMatched.whenMatched,
-                ...(notMatched.stages === 'ctx' && { let: rawVars(notMatched.vars, root()) }),
-            }),
-        },
-    },
-]);
-const $merge2 = (args) => $merge_(args);
-
-const subMerge = (args, out, gid, extra, idPrefix, first) => {
-    const doubleReplace = (x) => x;
-    const mergeAggregates = $set_(set()(mapExact0(args, (v, k) => to(first
-        ? ctx()('new').of(k).expr()
-        : v.merge(root().of(k).expr(), ctx()('new').of(k).expr())))));
-    const gidPath = root().of(gid).expr();
-    const mapId = (k, v) => map1(k, v);
-    const F1 = {
-        _id: ['_id', to(idPrefix ? concat$1(val(idPrefix), $rand) : $rand)],
-        touchedAt: ['touchedAt', to(current)],
-    };
-    const F2 = mapId(gid, to(gidPath));
-    const addExtraAndMerge = {
-        ...mapExact0(extra, to),
-        ...F1,
-        ...F2,
-    };
-    const addTSAndExtra = {
-        ...mapExact0(extra, to),
-        touchedAt: ['touchedAt', to(current)],
-    };
-    const updater = set()(addTSAndExtra);
-    return (link()
-        .with($set_(set()(addExtraAndMerge)))
-        .with($merge_({
-        ...out,
-        on: root().of(gid),
-        vars: { new: ['new', root().expr()] },
-        stages: 'ctx',
-        whenMatched: link()
-            .with(mergeAggregates)
-            .with(doubleReplace($set_(updater))).stages,
-    })).stages);
-};
-
-const addGrp = (gid) => (expr) => {
-    const omit = omitPick();
-    return omit.backward(mergeExpr(omit.forward(expr), map1(gid, root().of('_id').expr())));
-};
-const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
-    raw: (first) => link()
-        .with(subGroup(id, args, addGrp(gid)))
-        .with(subMerge(args, out, gid, extra, idPrefix, first)).stages,
-    teardown: c => c(out.whenNotMatched === 'insert'
-        ? {
-            collection: out.into,
-            method: 'deleteMany',
-            params: [{}],
-        }
-        : {
-            collection: out.into,
-            method: 'updateMany',
-            params: [
-                {},
-                [
-                    {
-                        $unset: Object.keys({
-                            ...mapExactToObject(extra, () => 1),
-                            ...mapExactToObject(args, () => 1),
-                        }),
-                    },
-                ],
-            ],
-        }),
-});
-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 deltaExpr = (expr) => (field) => {
-    return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
-};
-const $setEach1 = (updater, dict) => {
-    return $set1(set()(mapExact1(dict, updater)));
-};
-const $setEach = (updater, dict) => $setEach1(updater, dict)(root);
-const $replaceWithEach1 = (t) => {
-    return $setEach(k => to(t(k)), {
-        after: ['after', 'after'],
-        before: ['before', 'before'],
-    });
-};
-const $replaceWithEach = (expr) => $replaceWithEach1(deltaExpr(expr));
-
-const $replaceWithDelta = (expr) => $replaceWithEach((field) => sub(expr, root().of(field)));
-const $setDelta = (updater) => {
-    const dict = {
-        after1: ['after1', 'after'],
-        before1: ['before1', 'before'],
-    };
-    const update = (k) => subUpdater(weaken(updater), root().of(k));
-    return link()
-        .with($setEach(k => to(root().of(k).expr()), dict))
-        .with($setEach(update, dict))
-        .with($replaceWithEach(field => root().of(`${field}1`).expr()))
-        .with($setEach(k => to(nil), dict)).stages;
-};
-
 const dayAndMonthPart = (date) => asExpr({
     raw: f => asExprRaw({ $dateToString: { date: date.raw(f).get(), format: '%m-%d' } }),
 });
@@ -908,6 +780,217 @@ const $map0 = ({ as, expr, input, }) => asExpr({
 const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item')) });
 const $map = (ex, map) => $map1(ex, i => map(i.expr()));
 
+const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const set = () => (fields) => ({
+    raw: f => {
+        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+    },
+});
+const weaken = (updater) => ({ raw: f => updater.raw(f) });
+const to = (expr) => ({
+    raw: f => [['', expr.raw(f).get()]],
+});
+
+const dbcoll = (x) => ({
+    db: x.dbName,
+    coll: x.collectionName,
+});
+
+const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
+    {
+        $merge: {
+            into: dbcoll(into),
+            on: on.str(),
+            ...(whenNotMatched && { whenNotMatched }),
+            ...(notMatched.stages && {
+                whenMatched: notMatched.whenMatched,
+                ...(notMatched.stages === 'ctx' && { let: rawVars(notMatched.vars, root()) }),
+            }),
+        },
+    },
+]);
+const $merge2 = (args) => $merge_(args);
+
+const getWhenMatched = (whenNotMatched) => {
+    const setDeleted = whenNotMatched === 'discard';
+    const orNull = (e) => (setDeleted ? $ifNull(e, nil) : e);
+    const preMergeOld = setDeleted
+        ? mergeObjects(root().of('old').expr(), field({
+            deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
+            touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
+        }))
+        : root().of('old').expr();
+    const same = eq(preMergeOld)(root().of('merged').expr());
+    const newOrOld = whenNotMatched ===
+        'insert'
+        ? ctx()('new')
+        : root();
+    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
+        deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
+    }));
+    return link()
+        .with($replaceWith_(field({
+        old: ['old', root().expr()],
+        merged: ['merged', merged],
+    })))
+        .with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
+};
+const $mergeX = (out, keys, f, map, ext) => {
+    const patch = mapExact(keys, v => sub(v, f));
+    const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    const setDeleted = out.whenNotMatched === 'discard';
+    const replacer = map(field(omitPick().backward(spread(patch, {
+        _id: ['_id', f.of('_id').expr()],
+        touchedAt: ['touchedAt', current],
+    }))));
+    const sss = setDeleted
+        ? link()
+            .with($set_(set()({
+            deletedAt: ['deletedAt', to(current)],
+        })))
+            .with($merge_({
+            into: out.coll,
+            on: root().of('_id'),
+            whenNotMatched: 'insert',
+            stages: true,
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages
+        : link().with($merge_({
+            into: out.coll,
+            on: root().of('_id'),
+            whenNotMatched: 'fail',
+            stages: true,
+            whenMatched: getWhenMatched(out.whenNotMatched),
+        })).stages;
+    const teardown = (coll) => ({
+        collection: coll,
+        method: 'updateMany',
+        params: [
+            filter,
+            [
+                {
+                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
+                },
+            ],
+        ],
+    });
+    return {
+        raw: (first) => link().with($replaceWith_(replacer)).with(sss)
+            .stages,
+        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
+    };
+};
+const $mergeId = () => (out, keys, id, ext) => {
+    const omRORec = omitRORec();
+    return $mergeX(out, keys, root().of('after'), or => {
+        return ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
+            _id: ['_id', id],
+            touchedAt: ['touchedAt', current],
+        }))), or);
+    }, ext);
+};
+const $simpleMergePart = () => (out, keys, ext) => $mergeX(out, keys, root(), id$1, ext);
+const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {});
+const $mergePart = () => (out, keys, ext) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext);
+const $merge = () => (out, keys) => $mergePart()(out, keys, {});
+const assertNotNull$1 = (expr) => expr;
+
+const subMerge = (args, out, gid, extra, idPrefix, first) => {
+    const e = extra;
+    const mergeAggregates = $set_(set()(mapExact0(args, (v, k) => to(first
+        ? ctx()('new').of(k).expr()
+        : v.merge(root().of(k).expr(), ctx()('new').of(k).expr())))));
+    const gidPath = root().of(gid).expr();
+    const mapId = (k, v) => map1(k, v);
+    const F1 = {
+        _id: ['_id', to(idPrefix ? concat$1(val(idPrefix), $rand) : $rand)],
+        touchedAt: ['touchedAt', to(current)],
+    };
+    const F2 = mapId(gid, to(gidPath));
+    const addExtraAndMerge = {
+        ...mapExact0(extra, to),
+        ...F1,
+        ...F2,
+    };
+    const addExtra = mapExact0(e, to);
+    const updater = set()(addExtra);
+    return link()
+        .with($set_(set()(addExtraAndMerge)))
+        .with($merge_({
+        ...out,
+        whenNotMatched: 'fail',
+        on: root().of(gid),
+        vars: { new: ['new', root().expr()] },
+        stages: 'ctx',
+        whenMatched: link()
+            .with(mergeAggregates)
+            .with($set_(updater))
+            .with(getWhenMatched(out.whenNotMatched)).stages,
+    })).stages;
+};
+
+const addGrp = (gid) => (expr) => {
+    const omit = omitPick();
+    return omit.backward(mergeExpr(omit.forward(expr), map1(gid, root().of('_id').expr())));
+};
+const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
+    raw: (first) => link()
+        .with(subGroup(id, args, addGrp(gid)))
+        .with(subMerge(args, out, gid, extra, idPrefix, first)).stages,
+    teardown: c => c(out.whenNotMatched === 'insert'
+        ? {
+            collection: out.into,
+            method: 'deleteMany',
+            params: [{}],
+        }
+        : {
+            collection: out.into,
+            method: 'updateMany',
+            params: [
+                {},
+                [
+                    {
+                        $unset: Object.keys({
+                            ...mapExactToObject(extra, () => 1),
+                            ...mapExactToObject(args, () => 1),
+                        }),
+                    },
+                ],
+            ],
+        }),
+});
+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 deltaExpr = (expr) => (field) => {
+    return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
+};
+const $setEach1 = (updater, dict) => {
+    return $set1(set()(mapExact1(dict, updater)));
+};
+const $setEach = (updater, dict) => $setEach1(updater, dict)(root);
+const $replaceWithEach1 = (t) => {
+    return $setEach(k => to(t(k)), {
+        after: ['after', 'after'],
+        before: ['before', 'before'],
+    });
+};
+const $replaceWithEach = (expr) => $replaceWithEach1(deltaExpr(expr));
+
+const $replaceWithDelta = (expr) => $replaceWithEach((field) => sub(expr, root().of(field)));
+const $setDelta = (updater) => {
+    const dict = {
+        after1: ['after1', 'after'],
+        before1: ['before1', 'before'],
+    };
+    const update = (k) => subUpdater(weaken(updater), root().of(k));
+    return link()
+        .with($setEach(k => to(root().of(k).expr()), dict))
+        .with($setEach(update, dict))
+        .with($replaceWithEach(field => root().of(`${field}1`).expr()))
+        .with($setEach(k => to(nil), dict)).stages;
+};
+
 const operator = () => (op) => (operand) => {
     return {
         raw: { [op]: operand },
@@ -1365,90 +1448,6 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const getWhenMatched = (whenNotMatched) => {
-    const setDeleted = whenNotMatched === 'discard';
-    const orNull = (e) => (setDeleted ? $ifNull(e, nil) : e);
-    const preMergeOld = setDeleted
-        ? mergeObjects(root().of('old').expr(), field({
-            deletedAt: ['deletedAt', orNull(root().of('old').of('deletedAt').expr())],
-            touchedAt: ['touchedAt', root().of('merged').of('touchedAt').expr()],
-        }))
-        : root().of('old').expr();
-    const same = eq(preMergeOld)(root().of('merged').expr());
-    const newOrOld = whenNotMatched ===
-        'insert'
-        ? ctx()('new')
-        : root();
-    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
-        deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
-    }));
-    return link()
-        .with($replaceWith_(field({
-        old: ['old', root().expr()],
-        merged: ['merged', merged],
-    })))
-        .with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
-};
-const $mergeX = (out, keys, f, map, ext) => {
-    const patch = mapExact(keys, v => sub(v, f));
-    const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    const setDeleted = out.whenNotMatched === 'discard';
-    const replacer = map(field(omitPick().backward(spread(patch, {
-        _id: ['_id', f.of('_id').expr()],
-        touchedAt: ['touchedAt', current],
-    }))));
-    const sss = setDeleted
-        ? link()
-            .with($set_(set()({
-            deletedAt: ['deletedAt', to(current)],
-        })))
-            .with($merge_({
-            into: out.coll,
-            on: root().of('_id'),
-            whenNotMatched: 'insert',
-            stages: true,
-            whenMatched: getWhenMatched(out.whenNotMatched),
-        })).stages
-        : link().with($merge_({
-            into: out.coll,
-            on: root().of('_id'),
-            whenNotMatched: 'fail',
-            stages: true,
-            whenMatched: getWhenMatched(out.whenNotMatched),
-        })).stages;
-    const teardown = (coll) => ({
-        collection: coll,
-        method: 'updateMany',
-        params: [
-            filter,
-            [
-                {
-                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                },
-            ],
-        ],
-    });
-    return {
-        raw: (first) => link().with($replaceWith_(replacer)).with(sss)
-            .stages,
-        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
-    };
-};
-const $mergeId = () => (out, keys, id, ext) => {
-    const omRORec = omitRORec();
-    return $mergeX(out, keys, root().of('after'), or => {
-        return ite(eqTyped(root().of('after').expr(), nil), field(omRORec.backward(spread(mapExact(keys, () => nil), {
-            _id: ['_id', id],
-            touchedAt: ['touchedAt', current],
-        }))), or);
-    }, ext);
-};
-const $simpleMergePart = () => (out, keys, ext) => $mergeX(out, keys, root(), id$1, ext);
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {});
-const $mergePart = () => (out, keys, ext) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext);
-const $merge = () => (out, keys) => $mergePart()(out, keys, {});
-const assertNotNull$1 = (expr) => expr;
-
 const $insertX = (out, expr, map, ext, extExpr) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     return {