@omegup/msync 0.1.36 → 0.1.38

package/index.d.ts

@@ -236,6 +236,7 @@ declare const concat: {
     <D, C>(...expr: Expr<string, D, C>[]): Expr<string, D, C>;
     <D, C>(...expr: Expr<string | N, D, C>[]): Expr<string | N, D, C>;
 };
+declare const $substr: <D, C>(expr: Expr<string, D, C>, start: Expr<number, D, C>, length: Expr<number, D, C>) => Expr<string, D, C>;
 declare const padLeft: <D, C>(expr: Expr<string, D, C>, pad: string) => Expr<string, D, C>;
 declare const regex: <D, C>(expr: Expr<string, D, C>, regex: Expr<string, D, C>, options?: Expr<string, D, C>) => Expr<boolean, D, C>;
 declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
@@ -453,7 +454,15 @@ type ND$1 = {
     readonly deletedAt?: null;
 };
 type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
-declare const getWhenMatchedForMerge: <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 Args<P, Out> = [added: Expr<P, unknown, {
+    new: P;
+}>, old: Expr<Out, Out>];
+type Result<P> = Expr<P, unknown, {
+    new: P;
+}>;
+type Update$1<P, Out> = (...args: Args<P, Out>) => Result<P>;
+type UpdateF<P, Out> = <K extends keyof IsDeleted>(...args: Args<Replace<P, RORec<K, Timestamp>>, Out>) => Result<Replace<P, RORec<K, Timestamp>>>;
+declare const getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert", update: Update$1<Replace<P, RORec<K, Timestamp>>, Out>) => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
 declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
 type MergeCollection<V extends O, Out extends Model> = {
     coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
@@ -462,18 +471,23 @@ type MergeCollection<V extends O, Out extends Model> = {
     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 MergeUpdate<V, Out> = UpdateF<((OPick<V, Allowed$2<StrKey<V>>> & ID) | (Rec<Allowed$2<StrKey<V>>, N> & ID)) & TS, Out>;
+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>, update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => 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", update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => 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>, update?: MergeUpdate<V, Out>) => StreamRunnerParam<Delta<SourcePart>, "out">;
 
 type ND = {
     readonly deletedAt?: null;
 };
 type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
 type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
-declare const $insertX: <T extends doc, D extends O, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS & Omit<SafeE<EEE>, keyof (ND & TS)>, D>) => Expr<Merge<T, EEE>, D>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, extExpr: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>) => StreamRunnerParam<D, "out">;
+type ExprP<P> = Expr<P, unknown, {
+    new: P;
+}>;
+type Update<P, Out> = (added: ExprP<P>, old: Expr<Out, Out>) => ExprP<P>;
+declare const $insertX: <T extends doc, D extends O, EEE extends RORec<string, rawItem>>(out: RWCollection<Merge<T, EEE>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS & Omit<SafeE<EEE>, keyof (ND & TS)>, D>) => Expr<Merge<T, EEE>, D>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>, extExpr: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>, update?: Update<Replace<Merge<T, EEE>, {}>, Merge<T, EEE>>) => StreamRunnerParam<D, "out">;
 declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
 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">;
@@ -686,5 +700,5 @@ 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, $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, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, 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, $substr, $sum, $type, $unwind, $unwindDelta, Expr, Field, Machine, Type, add, and, anyElementTrue, array, ceil, comp, concat, concatArray, createIndex, ctx, current, dateAdd, dateDiff, dateLt, datePart, dayAndMonthPart, divide, enablePreAndPostImages, eq, eqTyped, except, exprMapVal, field, fieldF, fieldM, filter, filterDefined, first, firstSure, floor, from, func, getWhenMatched, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, pair, prepare, rand, range, regex, root, set, setField, single, size, slice, sortArray, staging, startOf, str, sub, subtract, to, toInt, val, weekPart, wrap, year };
 export type { Accumulators, Arr, AsLiteral, Delta, DeltaAccumulator, DeltaAccumulators, ExactKeys, ExprHKT, Exprs, ExprsExact, ExprsExactHKT, ExprsPart, ID, Loose, Merge, MergeArgs, MergeInto, MergeMapOArgs, Model, MongoTypeNames, N, NoRaw, NullToOBJ, O, OPick, OPickD, Patch, RONoRaw, RORec, RawStages, Rec, Replace, SnapshotStreamExecutionResult, StrKey, Strict, TS, WriteonlyCollection, doc, jsonPrim, notArr };

package/index.esm.js

@@ -299,6 +299,11 @@ const $entries = (expr) => func(function (obj) {
 const concat$1 = (...expr) => asExpr({
     raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
 });
+const $substr = (expr, start, length) => asExpr({
+    raw: f => asExprRaw({
+        $substrCP: [expr.raw(f).get(), start.raw(f).get(), length.raw(f).get()],
+    }),
+});
 const padLeft = (expr, pad) => asExpr({
     raw: f => asExprRaw({
         $let: {
@@ -839,13 +844,13 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
 ]);
 const $merge2 = (args) => $merge_(args);
 
-const getWhenMatchedForMerge = (whenNotMatched) => {
+const getWhenMatchedForMerge = (whenNotMatched, update) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const newOrOld = whenNotMatched ===
         'insert'
         ? ctx()('new')
         : root();
-    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
+    const merged = mergeObjects(root().expr(), update(ctx()('new').expr(), root().expr()), field({
         deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
     }));
     return link()
@@ -864,7 +869,7 @@ const getWhenMatched = (whenNotMatched) => {
     const same = eq(preMergeOld)(root().of('merged').expr());
     return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
 };
-const $mergeX = (out, keys, f, map, ext) => {
+const $mergeX = (out, keys, f, map, ext, update) => {
     const patch = mapExact(keys, v => sub(v, f));
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     const setDeleted = out.whenNotMatched === 'discard';
@@ -882,14 +887,14 @@ const $mergeX = (out, keys, f, map, ext) => {
             on: root().of('_id'),
             whenNotMatched: 'insert',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
         })).stages
         : link().with($merge_({
             into: out.coll,
             on: root().of('_id'),
             whenNotMatched: 'fail',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
         })).stages;
     const teardown = (coll) => ({
         collection: coll,
@@ -906,22 +911,22 @@ const $mergeX = (out, keys, f, map, ext) => {
     return {
         raw: (first) => link().with($replaceWith_(replacer)).with(sss)
             .stages,
-        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
+        teardown: c => c(teardown(out.coll)),
     };
 };
-const $mergeId = () => (out, keys, id, ext) => {
+const $mergeId = () => (out, keys, id, ext, update = x => x) => {
     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);
+    }, ext, update);
 };
-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 $simpleMergePart = () => (out, keys, ext, update = x => x) => $mergeX(out, keys, root(), id$1, ext, update);
+const $simpleMerge = () => (out, keys, whenNotMatched = 'fail', update = x => x) => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {}, update);
+const $mergePart = () => (out, keys, ext, update = x => x) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, update);
+const $merge = () => (out, keys, update = x => x) => $mergePart()(out, keys, {}, update);
 const assertNotNull$1 = (expr) => expr;
 
 const subMerge = (args, out, gid, extra, idPrefix, first) => {
@@ -1557,7 +1562,7 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $insertX = (out, expr, map, ext, extExpr) => {
+const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     return {
         teardown: c => c({
@@ -1576,7 +1581,7 @@ const $insertX = (out, expr, map, ext, extExpr) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: getWhenMatchedForMerge('insert'),
+                whenMatched: getWhenMatchedForMerge('insert', update),
                 whenNotMatched: 'insert',
             })).stages;
         },
@@ -2274,4 +2279,4 @@ const executes = (view, input, needs) => {
 };
 const single = (view, needs = {}) => pipe(input => executes(view, input, needs), emptyDelta(), concatDelta, emptyDelta);
 
-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, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, 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, $substr, $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, getWhenMatchedForMerge, gt, gte, inArray, isArray, ite, last, log, lt, lte, makeCol, map1, mapFromPlainDateTime, mapToPlainDateTime, mapVal, max, maxDate, mergeExact, mergeExact0, mergeExpr, mergeObjects, minDate, monthPart, multiply, ne, nil, noop, not, notNull, now, or, padLeft, 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.js

@@ -301,6 +301,11 @@ const $entries = (expr) => func(function (obj) {
 const concat$1 = (...expr) => asExpr({
     raw: f => asExprRaw({ $concat: expr.map(e => e.raw(f).get()) }),
 });
+const $substr = (expr, start, length) => asExpr({
+    raw: f => asExprRaw({
+        $substrCP: [expr.raw(f).get(), start.raw(f).get(), length.raw(f).get()],
+    }),
+});
 const padLeft = (expr, pad) => asExpr({
     raw: f => asExprRaw({
         $let: {
@@ -841,13 +846,13 @@ const $merge_ = ({ into, on, whenNotMatched, ...notMatched }) => asStages([
 ]);
 const $merge2 = (args) => $merge_(args);
 
-const getWhenMatchedForMerge = (whenNotMatched) => {
+const getWhenMatchedForMerge = (whenNotMatched, update) => {
     const orNull = (e) => whenNotMatched === 'discard' ? $ifNull(e, nil) : e;
     const newOrOld = whenNotMatched ===
         'insert'
         ? ctx()('new')
         : root();
-    const merged = mergeObjects(root().expr(), ctx()('new').expr(), field({
+    const merged = mergeObjects(root().expr(), update(ctx()('new').expr(), root().expr()), field({
         deletedAt: ['deletedAt', orNull(newOrOld.of('deletedAt').expr())],
     }));
     return link()
@@ -866,7 +871,7 @@ const getWhenMatched = (whenNotMatched) => {
     const same = eq(preMergeOld)(root().of('merged').expr());
     return link().with($replaceWith_(ite(same, root().of('old').expr(), root().of('merged').expr()))).stages;
 };
-const $mergeX = (out, keys, f, map, ext) => {
+const $mergeX = (out, keys, f, map, ext, update) => {
     const patch = mapExact(keys, v => sub(v, f));
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     const setDeleted = out.whenNotMatched === 'discard';
@@ -884,14 +889,14 @@ const $mergeX = (out, keys, f, map, ext) => {
             on: root().of('_id'),
             whenNotMatched: 'insert',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
         })).stages
         : link().with($merge_({
             into: out.coll,
             on: root().of('_id'),
             whenNotMatched: 'fail',
             stages: true,
-            whenMatched: getWhenMatchedForMerge(out.whenNotMatched),
+            whenMatched: getWhenMatchedForMerge(out.whenNotMatched, update),
         })).stages;
     const teardown = (coll) => ({
         collection: coll,
@@ -908,22 +913,22 @@ const $mergeX = (out, keys, f, map, ext) => {
     return {
         raw: (first) => link().with($replaceWith_(replacer)).with(sss)
             .stages,
-        teardown: c => (setDeleted ? c(teardown(out.coll)) : c(teardown(out.coll))),
+        teardown: c => c(teardown(out.coll)),
     };
 };
-const $mergeId = () => (out, keys, id, ext) => {
+const $mergeId = () => (out, keys, id, ext, update = x => x) => {
     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);
+    }, ext, update);
 };
-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 $simpleMergePart = () => (out, keys, ext, update = x => x) => $mergeX(out, keys, root(), id$1, ext, update);
+const $simpleMerge = () => (out, keys, whenNotMatched = 'fail', update = x => x) => $mergeX({ coll: out, whenNotMatched }, keys, root(), id$1, {}, update);
+const $mergePart = () => (out, keys, ext, update = x => x) => $mergeId()({ coll: out, whenNotMatched: 'fail' }, keys, assertNotNull$1(root().of('before').of('_id').expr()), ext, update);
+const $merge = () => (out, keys, update = x => x) => $mergePart()(out, keys, {}, update);
 const assertNotNull$1 = (expr) => expr;
 
 const subMerge = (args, out, gid, extra, idPrefix, first) => {
@@ -1559,7 +1564,7 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $insertX = (out, expr, map, ext, extExpr) => {
+const $insertX = (out, expr, map, ext, extExpr, update = x => x) => {
     const filter = mapExactToObject(ext, v => ({ $eq: v }));
     return {
         teardown: c => c({
@@ -1578,7 +1583,7 @@ const $insertX = (out, expr, map, ext, extExpr) => {
                 into: out,
                 on: root().of('_id'),
                 stages: true,
-                whenMatched: getWhenMatchedForMerge('insert'),
+                whenMatched: getWhenMatchedForMerge('insert', update),
                 whenNotMatched: 'insert',
             })).stages;
         },
@@ -2325,6 +2330,7 @@ exports.$set = $set;
 exports.$simpleInsert = $simpleInsert;
 exports.$simpleMerge = $simpleMerge;
 exports.$simpleMergePart = $simpleMergePart;
+exports.$substr = $substr;
 exports.$sum = $sum;
 exports.$type = $type;
 exports.$unwind = $unwind;

package/package.json

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