@omegup/msync 0.0.76 → 0.0.78

package/index.d.ts

@@ -106,9 +106,10 @@ 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 Del = O<{
+type DDel = {
     readonly deletedAt: Timestamp;
-} & ID & TS>;
+} & ID & TS;
+type Del = O<DDel>;
 type D = O<{
     readonly deletedAt?: Timestamp | null | undefined;
 } & ID>;
@@ -479,10 +480,10 @@ declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V
 declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
 
 type s$1 = string;
-declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc, Null extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, includeNull?: Null) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U | Null> & ID>>;
+declare const $unwindDelta: <K1 extends s$1, T extends doc, K2 extends s$1, U extends doc, Null extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, includeNull?: Null, middle?: string) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U | Null> & ID>>;
 
 type s = string;
-declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;
+declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">, middle?: string) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;
 
 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;
@@ -493,10 +494,12 @@ declare const $merge: <V extends O>() => <Out extends doc, SourcePart extends do
 type ND = {
     readonly deletedAt?: null;
 };
-type Merge<T extends ID> = (T & ND & TS) | Del;
-declare const $insertX: <T extends doc, D extends O>(out: RWCollection<Merge<T>>, expr: Expr<T, D>, map: (x: Expr<T & ND & TS, D>) => Expr<Merge<T>, D>) => StreamRunnerParam<D, "out">;
-declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T>>) => StreamRunnerParam<T, "out">;
-declare const $insert: <T extends doc>(out: RWCollection<Merge<T>>) => StreamRunnerParam<Delta<T>, "out">;
+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>(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: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>) => StreamRunnerParam<D, "out">;
+declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
+declare const $insertPart: <T extends doc, EEE>(out: RWCollection<Merge<T, EEE>>, ext: ExprsExact<Omit<SafeE<EEE>, keyof (ND & TS)>, unknown>) => StreamRunnerParam<Delta<T>, "out">;
+declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
 
 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>;
 
@@ -692,4 +695,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, $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, $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

@@ -339,6 +339,7 @@ const assertEqual = () => ({
 });
 const omitRORec = () => assertEqual();
 const omitPick = () => assertEqual();
+const translateOmit = () => assertEqual();
 
 const asStages = (x) => x;
 const concatStages = (part1, part2) => asStages([...part1, ...part2]);
@@ -931,7 +932,7 @@ const dualIn = operator();
 const $in = dualIn('$in');
 const $nin = dualIn('$nin');
 
-const $unwindDelta = (k1, k2, k, includeNull) => {
+const $unwindDelta = (k1, k2, k, includeNull, middle) => {
     const outer = includeNull === null;
     const newItems = {
         $filter: {
@@ -977,7 +978,7 @@ const $unwindDelta = (k1, k2, k, includeNull) => {
         },
     };
     const ifNull = (k, part, str = `$${k}.${part}._id`) => outer && k == k2 ? { $ifNull: [str, 'null'] } : str;
-    const interDot = ([a, b]) => [a, '.', b];
+    const interDot = ([a, b]) => [a, middle ?? '.', b];
     const partReplace = (part) => ({
         $cond: {
             if: { $or: [{ $eq: [`$${k1}.${part}`, null] }, { $eq: [`$${k2}.${part}`, null] }] },
@@ -1058,18 +1059,25 @@ const $unwindDelta = (k1, k2, k, includeNull) => {
                 after: partReplace('after'),
             },
         },
+        ...(!k && middle
+            ? [
+                {
+                    $set: { _id: { $ifNull: ['$before._id', '$after._id'] } },
+                },
+            ]
+            : []),
     ]))
         .with($match_($expr(ne(part('before'))(part('after'))))).stages;
     return stages;
 };
 
-const $unwind = (k, dict) => ({
+const $unwind = (k, dict, middle) => ({
     delta: link()
         .with($replaceWithDelta(field({
         left: ['left', root().expr()],
         right: ['right', root().of(k).expr()],
     })))
-        .with($unwindDelta('left', 'right', false))
+        .with($unwindDelta('left', 'right', false, undefined, middle))
         .with($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
         key: root().of('right').expr(),
     }, dict)))).stages,
@@ -1378,30 +1386,40 @@ const $simpleMerge = () => (out, keys) => $mergeX(out, keys, root(), id$1);
 const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()));
 const assertNotNull$1 = (expr) => expr;
 
-const $insertX = (out, expr, map) => ({
-    teardown: c => c({
-        collection: out,
-        method: 'updateMany',
-        params: [{}, [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }]],
-    }),
-    raw: () => {
-        const replacer = map(mergeObjects(expr, field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
-        return link()
-            .with($replaceWith_(replacer))
-            .with($merge_({
-            into: out,
-            on: root().of('_id'),
-            whenMatched: 'merge',
-            whenNotMatched: 'insert',
-        })).stages;
-    },
-});
-const $simpleInsert = (out) => $insertX(out, root().expr(), id$1);
-const $insert = (out) => $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field({
+const $insertX = (out, expr, map, ext) => {
+    const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    return {
+        teardown: c => c({
+            collection: out,
+            method: 'updateMany',
+            params: [
+                filter,
+                [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }],
+            ],
+        }),
+        raw: () => {
+            const replacer = map(mergeObjects(expr, field(mergeExpr(ext, {
+                deletedAt: ['deletedAt', nil],
+                touchedAt: ['touchedAt', current],
+            }))));
+            return link()
+                .with($replaceWith_(replacer))
+                .with($merge_({
+                into: out,
+                on: root().of('_id'),
+                whenMatched: 'merge',
+                whenNotMatched: 'insert',
+            })).stages;
+        },
+    };
+};
+const $simpleInsert = (out) => $insertX(out, root().expr(), id$1, {});
+const $insertPart = (out, ext) => $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(ext), {
     deletedAt: ['deletedAt', current],
     _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
     touchedAt: ['touchedAt', current],
-}), x));
+})), x), ext);
+const $insert = (out) => $insertPart(out, {});
 const assertNotNull = (expr) => expr;
 
 const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
@@ -1899,4 +1917,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, $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, $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

@@ -341,6 +341,7 @@ const assertEqual = () => ({
 });
 const omitRORec = () => assertEqual();
 const omitPick = () => assertEqual();
+const translateOmit = () => assertEqual();
 
 const asStages = (x) => x;
 const concatStages = (part1, part2) => asStages([...part1, ...part2]);
@@ -933,7 +934,7 @@ const dualIn = operator();
 const $in = dualIn('$in');
 const $nin = dualIn('$nin');
 
-const $unwindDelta = (k1, k2, k, includeNull) => {
+const $unwindDelta = (k1, k2, k, includeNull, middle) => {
     const outer = includeNull === null;
     const newItems = {
         $filter: {
@@ -979,7 +980,7 @@ const $unwindDelta = (k1, k2, k, includeNull) => {
         },
     };
     const ifNull = (k, part, str = `$${k}.${part}._id`) => outer && k == k2 ? { $ifNull: [str, 'null'] } : str;
-    const interDot = ([a, b]) => [a, '.', b];
+    const interDot = ([a, b]) => [a, middle ?? '.', b];
     const partReplace = (part) => ({
         $cond: {
             if: { $or: [{ $eq: [`$${k1}.${part}`, null] }, { $eq: [`$${k2}.${part}`, null] }] },
@@ -1060,18 +1061,25 @@ const $unwindDelta = (k1, k2, k, includeNull) => {
                 after: partReplace('after'),
             },
         },
+        ...(!k && middle
+            ? [
+                {
+                    $set: { _id: { $ifNull: ['$before._id', '$after._id'] } },
+                },
+            ]
+            : []),
     ]))
         .with($match_($expr(ne(part('before'))(part('after'))))).stages;
     return stages;
 };
 
-const $unwind = (k, dict) => ({
+const $unwind = (k, dict, middle) => ({
     delta: link()
         .with($replaceWithDelta(field({
         left: ['left', root().expr()],
         right: ['right', root().of(k).expr()],
     })))
-        .with($unwindDelta('left', 'right', false))
+        .with($unwindDelta('left', 'right', false, undefined, middle))
         .with($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({
         key: root().of('right').expr(),
     }, dict)))).stages,
@@ -1380,30 +1388,40 @@ const $simpleMerge = () => (out, keys) => $mergeX(out, keys, root(), id$1);
 const $merge = () => (out, keys) => $mergeId()(out, keys, assertNotNull$1(root().of('before').of('_id').expr()));
 const assertNotNull$1 = (expr) => expr;
 
-const $insertX = (out, expr, map) => ({
-    teardown: c => c({
-        collection: out,
-        method: 'updateMany',
-        params: [{}, [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }]],
-    }),
-    raw: () => {
-        const replacer = map(mergeObjects(expr, field({ deletedAt: ['deletedAt', nil], touchedAt: ['touchedAt', current] })));
-        return link()
-            .with($replaceWith_(replacer))
-            .with($merge_({
-            into: out,
-            on: root().of('_id'),
-            whenMatched: 'merge',
-            whenNotMatched: 'insert',
-        })).stages;
-    },
-});
-const $simpleInsert = (out) => $insertX(out, root().expr(), id$1);
-const $insert = (out) => $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field({
+const $insertX = (out, expr, map, ext) => {
+    const filter = mapExactToObject(ext, v => ({ $eq: v }));
+    return {
+        teardown: c => c({
+            collection: out,
+            method: 'updateMany',
+            params: [
+                filter,
+                [{ $set: { deletedAt: '$$NOW', touchedAt: '$$CLUSTER_TIME' } }],
+            ],
+        }),
+        raw: () => {
+            const replacer = map(mergeObjects(expr, field(mergeExpr(ext, {
+                deletedAt: ['deletedAt', nil],
+                touchedAt: ['touchedAt', current],
+            }))));
+            return link()
+                .with($replaceWith_(replacer))
+                .with($merge_({
+                into: out,
+                on: root().of('_id'),
+                whenMatched: 'merge',
+                whenNotMatched: 'insert',
+            })).stages;
+        },
+    };
+};
+const $simpleInsert = (out) => $insertX(out, root().expr(), id$1, {});
+const $insertPart = (out, ext) => $insertX(out, assertNotNull(root().of('after').expr()), x => ite(eq(root().of('after').expr())(nil), field(mergeExpr(translateOmit().forward(ext), {
     deletedAt: ['deletedAt', current],
     _id: ['_id', assertNotNull(root().of('before').of('_id').expr())],
     touchedAt: ['touchedAt', current],
-}), x));
+})), x), ext);
+const $insert = (out) => $insertPart(out, {});
 const assertNotNull = (expr) => expr;
 
 const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
@@ -1920,6 +1938,7 @@ exports.$gteTs = $gteTs;
 exports.$ifNull = $ifNull;
 exports.$in = $in;
 exports.$insert = $insert;
+exports.$insertPart = $insertPart;
 exports.$insertX = $insertX;
 exports.$keys = $keys;
 exports.$let = $let;

package/package.json

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