@omegup/msync 0.0.98 → 0.1.0

package/index.d.ts

@@ -491,6 +491,11 @@ declare const $unwind: <TT extends O, K extends s, U extends doc>(k: AsLiteral<K
 type Allowed$2<K extends string> = Exclude<K, keyof (TS & ID)>;
 type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed$2<KK>> & ID) | (Rec<Allowed$2<KK>, N> & ID)) & TS;
 type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed$2<KK>> & E;
+type ND$1 = {
+    readonly deletedAt?: null;
+};
+type SafeE$1<E> = Omit<E, `$${string}` | keyof ID>;
+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 $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">;
 
@@ -698,4 +703,4 @@ declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Pr
 declare const prepare: (testName?: string) => Promise<MongoClient$1>;
 declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;
 
-export { $accumulator, $and, $countDict, $entries, $eq, $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, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $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, 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, $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, 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

@@ -1364,28 +1364,46 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeX = (out, keys, f, map, whenNotMatched = 'fail') => ({
-    raw: (first) => {
-        const patch = mapExact(keys, v => sub(v, f));
-        const or = field(omitPick().backward(spread(patch, {
-            _id: ['_id', f.of('_id').expr()],
-            touchedAt: ['touchedAt', current],
-        })));
-        const replacer = map(or);
-        return link()
+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: whenNotMatched === 'fail' ? 'fail' : 'insert',
             stages: true,
             whenMatched: asStages([
-                { $replaceWith: { old: '$$ROOT', merged: { $mergeObjects: ['$$ROOT', '$$new'] } } },
+                {
+                    $replaceWith: {
+                        old: setDeleted
+                            ? { $mergeObjects: ['$$ROOT', { deletedAt: '$deletedAt' }] }
+                            : '$$ROOT',
+                        merged: {
+                            $mergeObjects: [
+                                '$$ROOT',
+                                '$$new',
+                                ...(setDeleted ? [{ deletedAt: '$deletedAt' }] : []),
+                            ],
+                        },
+                    },
+                },
                 {
                     $replaceWith: {
                         $cond: {
                             if: {
-                                $eq: ['$old', { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] }],
+                                $eq: [
+                                    '$old',
+                                    { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
+                                ],
                             },
                             then: '$old',
                             else: '$merged',
@@ -1393,32 +1411,33 @@ const $mergeX = (out, keys, f, map, whenNotMatched = 'fail') => ({
                     },
                 },
             ]),
-        })).stages;
-    },
-    teardown: c => c({
-        collection: out,
-        method: 'updateMany',
-        params: [
-            {},
-            [
-                {
-                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                },
+        })).stages,
+        teardown: c => c({
+            collection: out,
+            method: 'updateMany',
+            params: [
+                filter,
+                [
+                    {
+                        $unset: Object.keys(mapExactToObject(keys, () => 1)),
+                    },
+                ],
             ],
-        ],
-    }),
-});
-const $mergeId = () => (out, keys, id, whenNotMatched = 'fail') => {
+        }),
+    };
+};
+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);
+    }, whenNotMatched, ext);
 };
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX(out, keys, root(), id$1, whenNotMatched);
-const $merge = () => (out, keys, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), whenNotMatched);
+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 $merge = () => (out, keys, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), {}, whenNotMatched);
 const assertNotNull$1 = (expr) => expr;
 
 const $insertX = (out, expr, map, ext, extExpr) => {
@@ -1983,4 +2002,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, $merge_, $ne, $nin, $nor, $or, $outerLookup, $pushDict, $rand, $reduce, $replaceWith, $set, $simpleInsert, $simpleMerge, $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, $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 };

package/index.js

@@ -1366,28 +1366,46 @@ const $replaceWith = (expr) => ({
     lin: $replaceWith_(expr),
 });
 
-const $mergeX = (out, keys, f, map, whenNotMatched = 'fail') => ({
-    raw: (first) => {
-        const patch = mapExact(keys, v => sub(v, f));
-        const or = field(omitPick().backward(spread(patch, {
-            _id: ['_id', f.of('_id').expr()],
-            touchedAt: ['touchedAt', current],
-        })));
-        const replacer = map(or);
-        return link()
+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: whenNotMatched === 'fail' ? 'fail' : 'insert',
             stages: true,
             whenMatched: asStages([
-                { $replaceWith: { old: '$$ROOT', merged: { $mergeObjects: ['$$ROOT', '$$new'] } } },
+                {
+                    $replaceWith: {
+                        old: setDeleted
+                            ? { $mergeObjects: ['$$ROOT', { deletedAt: '$deletedAt' }] }
+                            : '$$ROOT',
+                        merged: {
+                            $mergeObjects: [
+                                '$$ROOT',
+                                '$$new',
+                                ...(setDeleted ? [{ deletedAt: '$deletedAt' }] : []),
+                            ],
+                        },
+                    },
+                },
                 {
                     $replaceWith: {
                         $cond: {
                             if: {
-                                $eq: ['$old', { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] }],
+                                $eq: [
+                                    '$old',
+                                    { $mergeObjects: ['$merged', { touchedAt: '$old.touchedAt' }] },
+                                ],
                             },
                             then: '$old',
                             else: '$merged',
@@ -1395,32 +1413,33 @@ const $mergeX = (out, keys, f, map, whenNotMatched = 'fail') => ({
                     },
                 },
             ]),
-        })).stages;
-    },
-    teardown: c => c({
-        collection: out,
-        method: 'updateMany',
-        params: [
-            {},
-            [
-                {
-                    $unset: Object.keys(mapExactToObject(keys, () => 1)),
-                },
+        })).stages,
+        teardown: c => c({
+            collection: out,
+            method: 'updateMany',
+            params: [
+                filter,
+                [
+                    {
+                        $unset: Object.keys(mapExactToObject(keys, () => 1)),
+                    },
+                ],
             ],
-        ],
-    }),
-});
-const $mergeId = () => (out, keys, id, whenNotMatched = 'fail') => {
+        }),
+    };
+};
+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);
+    }, whenNotMatched, ext);
 };
-const $simpleMerge = () => (out, keys, whenNotMatched = 'fail') => $mergeX(out, keys, root(), id$1, whenNotMatched);
-const $merge = () => (out, keys, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), whenNotMatched);
+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 $merge = () => (out, keys, whenNotMatched = 'fail') => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()), {}, whenNotMatched);
 const assertNotNull$1 = (expr) => expr;
 
 const $insertX = (out, expr, map, ext, extExpr) => {
@@ -2030,6 +2049,7 @@ exports.$replaceWith = $replaceWith;
 exports.$set = $set;
 exports.$simpleInsert = $simpleInsert;
 exports.$simpleMerge = $simpleMerge;
+exports.$simpleMergePart = $simpleMergePart;
 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.0.98",
+    "version": "0.1.0",
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",