@omegup/msync 0.1.8 → 0.1.10

package/index.d.ts

@@ -106,13 +106,15 @@ type Stream<out Q extends O, in out T extends Q, in out F extends HKT<[O, O]>, i
 type TS = {
     readonly touchedAt: Timestamp;
 };
-type DDel = {
+type IsDeleted = {
     readonly deletedAt: Timestamp;
-} & ID & TS;
+};
+type DDel = IsDeleted & ID & TS;
 type Del = O<DDel>;
-type D = O<{
+type DeletedAt = {
     readonly deletedAt?: Timestamp | null | undefined;
-} & ID>;
+};
+type D = O<DeletedAt & ID>;
 type Model = D & TS;
 type BA = 'before' | 'after';
 type PreDelta<T, K extends BA = BA, E = unknown> = Rec<K, T> & E;
@@ -410,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;
@@ -431,7 +433,7 @@ type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
     stages: true;
     into: RWCollection<In, Out>;
     whenMatched: RawStages<unknown, Out, In, {
-        new: In;
+        new: T;
     }>;
 } | {
     stages: 'ctx';
@@ -453,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>;
@@ -503,11 +507,19 @@ type ND$1 = {
     readonly deletedAt?: null;
 };
 type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
-declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends doc, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>, whenNotMatched: "fail" | "discard") => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched: "fail" | "discard", ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
-declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
-declare const $mergePart: <V extends O>() => <Out extends doc, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Delta<SourcePart>, "out">;
-declare const $merge: <V extends O>() => <Out extends doc, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Delta<SourcePart>, "out">;
+declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
+type MergeCollection<V extends O, Out extends Model> = {
+    coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
+    whenNotMatched: 'discard';
+} | {
+    coll: RWCollection<Out | Replace<Out, Patch<V>>, Out>;
+    whenNotMatched: 'fail';
+};
+declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
+declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends Model, EEE extends RORec<string, rawItem>>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
+declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends Model>(out: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
+declare const $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE$1<EEE>, keyof (ND$1 & TS)>, IdHKT>) => StreamRunnerParam<Delta<SourcePart>, "out">;
+declare const $merge: <V extends O>() => <Out extends Model, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>) => StreamRunnerParam<Delta<SourcePart>, "out">;
 
 type ND = {
     readonly deletedAt?: null;
@@ -519,6 +531,17 @@ declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) =>
 declare const $insertPart: <T extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<T>, "out">;
 declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
 
+declare const log: (...args: unknown[]) => void;
+
+declare const createIndex: (collection: {
+    readonly createIndex: Collection["createIndex"];
+}, indexSpec: IndexSpecification, options?: CreateIndexesOptions) => Promise<void>;
+
+declare const noop: () => void;
+declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
+    readonly [_: string]: [K, Im];
+};
+
 declare const $group_: <V extends O>() => <ID, T extends O, C = unknown>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => RawStages<O, T, Rec<"_id", ID> & V, C, 1>;
 
 type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
@@ -608,7 +631,7 @@ 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 mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(...exprs: readonly [Expr<T1 | N, D, C>, ...[...Expr<T1 | T2 | N, D, C>[], Expr<T2, D, C>]]) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
 declare const anyElementTrue: <D, C = unknown>(expr: Expr<Arr<boolean>, D, C>) => Expr<boolean, D, C>;
 type Reduce<T, V> = RORec<'value', V> & RORec<'this', T>;
 declare const $reduce: <T, V, D, C>(input: Expr<Arr<T>, D, C>, initialValue: Expr<V, D, C>, inExpr: Expr<V, D, C & Reduce<T, V>>) => Expr<V, D, C>;
@@ -706,19 +729,8 @@ declare const $and: Combiner;
 declare const $nor: Combiner;
 declare const $or: Combiner;
 
-declare const log: (...args: unknown[]) => void;
-
-declare const createIndex: (collection: {
-    readonly createIndex: Collection["createIndex"];
-}, indexSpec: IndexSpecification, options?: CreateIndexesOptions) => Promise<void>;
-
-declare const noop: () => void;
-declare const map1: <K extends string, Im>(k: AsLiteral<K>, to: Im) => { readonly [P in K]: [P, Im]; } & {
-    readonly [_: string]: [K, Im];
-};
-
 declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<Document>;
 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, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $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 MongoTypeNames, type N, type NoRaw, type NullToOBJ, 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, anyElementTrue, 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, type jsonPrim, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, type notArr, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $unwind, $unwindDelta, type Accumulators, type Arr, type AsLiteral, type Delta, type DeltaAccumulator, type DeltaAccumulators, type ExactKeys, 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 MongoTypeNames, type N, type NoRaw, type NullToOBJ, type O, type OPick, type OPickD, type Patch, type RONoRaw, type RORec, type RawStages, type Rec, type Replace, type SnapshotStreamExecutionResult, type StrKey, type Strict, type TS, Type, type WriteonlyCollection, add, and, anyElementTrue, 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, getWhenMatched, gt, gte, inArray, isArray, ite, type jsonPrim, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, type notArr, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };

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_({
+        into: null,
+        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,86 +1448,6 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeX = (out, keys, f, map, whenNotMatched = 'fail', ext) => {
-    const patch = mapExact(keys, v => sub(v, f));
-    const filter = mapExactToObject(ext, v => ({ $eq: v }));
-    const setDeleted = whenNotMatched === 'discard';
-    const replacer = map(field(omitPick().backward(spread(patch, {
-        _id: ['_id', f.of('_id').expr()],
-        touchedAt: ['touchedAt', current],
-        deletedAt: [setDeleted ? 'deletedAt' : 'touchedAt', current],
-    }))));
-    return {
-        raw: (first) => link()
-            .with($replaceWith_(replacer))
-            .with($merge_({
-            into: out,
-            on: root().of('_id'),
-            whenNotMatched: whenNotMatched === 'fail' ? 'fail' : 'insert',
-            stages: true,
-            whenMatched: asStages([
-                {
-                    $replaceWith: {
-                        old: '$$ROOT',
-                        merged: {
-                            $mergeObjects: [
-                                '$$ROOT',
-                                '$$new',
-                                ...(setDeleted ? [{ deletedAt: { $ifNull: ['$deletedAt', null] } }] : []),
-                            ],
-                        },
-                    },
-                },
-                {
-                    $replaceWith: {
-                        $cond: {
-                            if: {
-                                $eq: [
-                                    {
-                                        $mergeObjects: [
-                                            '$old',
-                                            { deletedAt: { $ifNull: ['$old.deletedAt', null] } },
-                                        ],
-                                    },
-                                    { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                ],
-                            },
-                            then: '$old',
-                            else: '$merged',
-                        },
-                    },
-                },
-            ]),
-        })).stages,
-        teardown: c => c({
-            collection: out,
-            method: 'updateMany',
-            params: [
-                filter,
-                [
-                    {
-                        $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                    },
-                ],
-            ],
-        }),
-    };
-};
-const $mergeId = () => (out, keys, id, ext, whenNotMatched) => {
-    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);
-    }, whenNotMatched, ext);
-};
-const $simpleMergePart = () => (out, keys, whenNotMatched, ext) => $mergeX(out, keys, root(), id$1, whenNotMatched, ext);
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX(out, keys, root(), id$1, whenNotMatched, {});
-const $mergePart = () => (out, keys, ext, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, whenNotMatched);
-const $merge = () => (out, keys, whenNotMatched = 'fail') => $mergePart()(out, keys, {}, whenNotMatched);
-const assertNotNull$1 = (expr) => expr;
-
 const $insertX = (out, expr, map, ext, extExpr) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     return {
@@ -1467,23 +1470,7 @@ const $insertX = (out, expr, map, ext, extExpr) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: asStages([
-                    { $replaceWith: { old: '$$ROOT', merged: { $mergeObjects: ['$$ROOT', '$$new'] } } },
-                    {
-                        $replaceWith: {
-                            $cond: {
-                                if: {
-                                    $eq: [
-                                        '$old',
-                                        { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
-                                    ],
-                                },
-                                then: '$old',
-                                else: '$merged',
-                            },
-                        },
-                    },
-                ]),
+                whenMatched: getWhenMatched('insert'),
                 whenNotMatched: 'insert',
             })).stages;
         },
@@ -2007,4 +1994,4 @@ const makeCol = async (docs, database, name) => {
     }
 };
 
-export { $accumulator, $and, $countDict, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, 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, not, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
+export { $accumulator, $and, $countDict, $entries, $eq, $exists, $expr, $getField, $group, $groupId, $groupMerge, $group_, $gt, $gtTs, $gte, $gteTs, $ifNull, $in, $insert, $insertPart, $insertX, $keys, $let, $lookup, $lt, $lte, $map, $map0, $map1, $match, $matchDelta, $merge, $merge2, $mergeId, $mergePart, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $simpleMergePart, $sum, $type, $unwind, $unwindDelta, Field, Machine, add, and, anyElementTrue, 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, getWhenMatched, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };