@omegup/msync 0.1.8 → 0.1.10

package/index.js

@@ -546,134 +546,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' } }),
 });
@@ -910,6 +782,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 },
@@ -1367,86 +1450,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 {
@@ -1469,23 +1472,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;
         },
@@ -2096,6 +2083,7 @@ exports.firstSure = firstSure;
 exports.floor = floor;
 exports.from = from;
 exports.func = func;
+exports.getWhenMatched = getWhenMatched;
 exports.gt = gt;
 exports.gte = gte;
 exports.inArray = inArray;

package/package.json

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

package/lib/accumulators/index.d.ts

@@ -1,10 +0,0 @@
-import type { AppMap, Arr, N, O, Rec } from '../../types';
-import type { ExprHKT } from '../expression/concat';
-import { type NoRaw } from '../expression/val';
-import type { DeltaAccumulator, Expr, Part } from '../types';
-export declare const $sum: <D extends O, C = unknown>(expr: Expr<number | N, D, C>) => DeltaAccumulator<D, number, C>;
-export declare const $accumulator: <D, T, Ctx, A extends readonly unknown[]>(init: () => NoRaw<T>, accumulateArgs: AppMap<ExprHKT<Part<D>, Ctx>, A>, accumulate: (a: NoRaw<T>, ...args: NoRaw<A>) => NoRaw<T>, merge: (...args: NoRaw<[T | N, T]>) => NoRaw<T>) => DeltaAccumulator<D, T, Ctx>;
-export declare const $countDict: <D extends O, C = unknown>(expr: Expr<string, D, C>) => DeltaAccumulator<D, Rec<string, number>, C>;
-export declare const $pushDict: <D extends O, V, C = unknown>(key: Expr<string, D, C>, value: Expr<V, D, C>) => DeltaAccumulator<D, Rec<string, Rec<"0" | "1", Arr<V>>>, C>;
-export declare const $keys: <D extends O, C = unknown>(expr: Expr<Rec<string, number>, D, C>) => Expr<Arr<string>, D, C>;
-export declare const $entries: <D extends O, V, C = unknown>(expr: Expr<Rec<string, Rec<"1" | "0", Arr<V>>>, D, C>) => Expr<Arr<Rec<"k", string> & Rec<"v", V>>, D, C>;

package/lib/aggregate/$merge.d.ts

@@ -1,19 +0,0 @@
-import type { IdHKT, OPick, RWCollection } from '../../types';
-import type { ID, N, O, RORec, Rec, Replace, StrKey, doc, rawItem } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Delta, Expr, StreamRunnerParam, TS } from '../types';
-import { type Exact } from '../utils/map-object';
-type OutInputE<T, E, A = T | null> = ID & Rec<'after', A> & E;
-type Allowed<K extends string> = Exclude<K, keyof (TS & ID)>;
-type Patch<V, KK extends StrKey<V> = StrKey<V>> = ((OPick<V, Allowed<KK>> & ID) | (Rec<Allowed<KK>, N> & ID)) & TS;
-type TakeDoc<V, E = ID, KK extends StrKey<V> = StrKey<V>> = OPick<V, Allowed<KK>> & E;
-type ND = {
-    readonly deletedAt?: null;
-};
-type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
-export 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<EEE>, keyof (ND & TS)>, IdHKT>, whenNotMatched: "fail" | "discard") => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-export 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<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
-export 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">;
-export 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<EEE>, keyof (ND & TS)>, IdHKT>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Delta<SourcePart>, "out">;
-export 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">;
-export {};

package/lib/aggregate/$upsert.d.ts

@@ -1,15 +0,0 @@
-import type { IdHKT, RWCollection } from '../../types';
-import type { ID, O, RORec, doc, rawItem } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Del, Delta, Expr, StreamRunnerParam, TS } from '../types';
-import { type Exact } from '../utils/map-object';
-type ND = {
-    readonly deletedAt?: null;
-};
-type SafeE<E> = Omit<E, `$${string}` | keyof ID>;
-export type Merge<T extends doc, E> = Omit<SafeE<E>, keyof (ND & TS)> & ((T & ND & TS) | Del);
-export 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">;
-export declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<T, "out">;
-export 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">;
-export declare const $insert: <T extends doc>(out: RWCollection<Merge<T, {}>>) => StreamRunnerParam<Delta<T>, "out">;
-export {};

package/lib/aggregate/group/$group-merge.d.ts

@@ -1,12 +0,0 @@
-import type { RWCollection, WriteonlyCollection } from '../../../types';
-import type { AsLiteral, ID, O, Rec, Replace, doc, notArr } from '../../../types/json';
-import { type ExprsExact } from '../../expression/concat';
-import type { Delta, DeltaAccumulators, Expr, StreamRunnerParam, TS } from '../../types';
-import type { MergeInto } from '../out';
-import { type Extra, type IdAndTsKeys, type Loose, type Strict, type V_Grp } from './utils/sub-merge';
-type Denied<GID = never> = keyof (TS & ID) | GID;
-type GI<GG> = Exclude<GG, keyof TS>;
-export 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">;
-export 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">;
-export 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">;
-export {};

package/lib/aggregate/group/index.d.ts

@@ -1,2 +0,0 @@
-export { $groupMerge, $groupId, $group } from './$group-merge';
-export type { Loose, Strict } from './utils/sub-merge';

package/lib/aggregate/group/utils/sub-group.d.ts

@@ -1,6 +0,0 @@
-import type { O, RORec, Rec } from '../../../../types';
-import { type ExprsExact } from '../../../expression/concat';
-import type { Delta, Expr, RawStages } from '../../../types';
-import type { DeltaAccumulators } from '../../../types/accumulator';
-export type WithItem<V, Grp> = Rec<'_id', Grp> & Rec<'item', O<V>>;
-export declare const subGroup: <T extends O, Grp, V extends O, GID extends string>(id: Expr<Grp, T>, args: DeltaAccumulators<T, V>, addGrp: <D extends Rec<"_id", Grp>>(src: ExprsExact<V, D>) => ExprsExact<RORec<GID, Grp> & V, D>) => RawStages<unknown, Delta<T>, Rec<GID, Grp> & V>;

package/lib/aggregate/group/utils/sub-merge.d.ts

@@ -1,18 +0,0 @@
-import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
-import { type ExprsExact } from '../../../expression/concat';
-import type { RawStages, TS } from '../../../types';
-import type { DeltaAccumulators } from '../../../types/accumulator';
-import { type MergeInto } from '../../out';
-type GI<GG> = Exclude<GG, keyof TS>;
-export type IdAndTsKeys = keyof (TS & ID);
-type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI<GG>>;
-export type Prepare<Grp, GG extends string> = TS & ID & Rec<GI<GG>, Grp>;
-type Par<T> = {
-    [P in keyof T]?: T[P] | null;
-};
-export type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
-export type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
-export type V_Grp<VV, GG extends string, Grp> = Rec<GI<GG>, Grp> & V<VV, GG>;
-export type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI<GG> | keyof V<VV, GG>>;
-export declare const subMerge: <T extends O, Grp extends notArr, VV extends O, GG extends string, EE = {}, Out extends Loose<Grp, VV, GG> = Loose<Grp, VV, GG>>(args: DeltaAccumulators<T, V<VV, GG>>, out: MergeInto<Strict<Grp, VV, GG, EE>, Out, WriteonlyCollection<Replace<Out, Strict<Grp, VV, GG, EE>>>>, gid: AsLiteral<GI<GG>>, extra: ExprsExact<Extra<EE, VV, GG>, V_Grp<VV, GG, Grp>>, idPrefix: string, first: boolean) => RawStages<unknown, V_Grp<VV, GG, Grp>, "out">;
-export {};

package/lib/aggregate/index.d.ts

@@ -1,9 +0,0 @@
-export * from './group';
-export * from './lookup';
-export * from './match';
-export * from './set';
-export * from './unwind';
-export * from './$merge';
-export * from './$upsert';
-export * from './out';
-export { $group_ } from './mongo-stages';

package/lib/aggregate/lookup/$lookup-delta.d.ts

@@ -1,10 +0,0 @@
-import type { AsLiteral, ID, N, O, Rec, doc, rawItem } from '../../../types';
-import { Field } from '../../field';
-import type { BA, Before, Delta, RawStages, TStages, UBefore } from '../../types';
-type s = string;
-type Both<K1 extends s, LE, KK2 extends s, RE, N1 extends null = never, N2 extends null = never> = Delta<Rec<K1, LE | N1> & Rec<Exclude<KK2, BA | K1>, RE | N2> & ID>;
-export declare const $lookupDelta: <LQ extends O, LE extends LQ & doc, RQ extends O, RE extends RQ & doc, BRB extends UBefore<RQ>, RS extends UBefore<RQ>, S extends rawItem, K1 extends s, KK2 extends s, N1 extends null = never, N2 extends null = never>({ field1, field2 }: {
-    field1: Field<LQ, S | N>;
-    field2: Field<RQ, S | N>;
-}, { coll, exec, input }: TStages<RS, UBefore<RQ>, BRB, Before<RE>>, k1: AsLiteral<K1>, k2: AsLiteral<Exclude<KK2, BA | K1>>, k: ([N1] extends [never] ? K1 : never) | ([N2] extends [never] ? Exclude<KK2, BA | K1> : never) | false, includeNull1?: N1, includeNull2?: N2) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE, N1, N2>>;
-export {};

package/lib/aggregate/lookup/$lookup-raw.d.ts

@@ -1,9 +0,0 @@
-import type { App, AsLiteral, HKT, ID, O, Rec } from '../../../types';
-import { type Field } from '../../field';
-import type { Before, RawStages, TStages } from '../../types';
-type s = string;
-export declare const $lookupRaw: <LQ extends O, LE extends LQ & ID, RQ extends O, RE extends RQ & ID, BRB extends Before<RQ>, RS, S, As extends s, Null extends null = never>({ field1, field2 }: {
-    field1: Field<LQ, S>;
-    field2: Field<RQ, S>;
-}, { coll, exec, input }: TStages<RS, Before<RQ>, BRB, Before<RE>>, k2: AsLiteral<As>, k: "left", includeNull?: Null) => <F extends HKT<O, O>>(f: <T extends O>() => Field<App<F, T>, T>) => RawStages<App<F, LQ>, App<F, LE>, App<F, LE & Rec<As, RE> & ID>>;
-export {};

package/lib/aggregate/lookup/index.d.ts

@@ -1,12 +0,0 @@
-import type { AsLiteral, O, RORec, doc, notArr } from '../../../types';
-import { type Field } from '../../field';
-import type { SnapshotStream, SnapshotStreamExecutionResult } from '../../types/stream';
-type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
-    localField: Field<LQ, S>;
-    foreignField: Field<RQ, S>;
-    from: SnapshotStreamExecutionResult<RQ, RE>;
-    as: AsLiteral<As>;
-};
-export declare const $lookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE>>;
-export declare const $outerLookup: <As extends string, LQ extends doc, RQ extends O, RE extends RQ & doc, S extends notArr>(p: Params<As, LQ, RQ, RE, S>) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ, LE & RORec<As, RE | null>>;
-export {};

package/lib/aggregate/match/$match-delta.d.ts

@@ -1,3 +0,0 @@
-import type { doc } from '../../../types';
-import type { Delta, Expr } from '../../types';
-export declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => import("../../types").RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;

package/lib/aggregate/match/$match.d.ts

@@ -1,3 +0,0 @@
-import type { doc } from '../../../types';
-import type { DeltaStages, Expr } from '../../types';
-export declare const $match: <T extends doc>(query: Expr<boolean, T>) => DeltaStages<T, T, T>;

package/lib/aggregate/match/index.d.ts

@@ -1,2 +0,0 @@
-export { $matchDelta } from './$match-delta';
-export { $match } from './$match';

package/lib/aggregate/mongo-stages.d.ts

@@ -1,13 +0,0 @@
-import type { Arr, O, Rec } from '../../types';
-import type { Accumulators, Expr, LookupArgs, Query, RawStages } from '../types';
-import type { Updater } from '../update/updater';
-export * from './raws';
-type s = string;
-export declare const $match_: <Q, T extends Q & O, C = unknown>(query?: Query<T, C>) => RawStages<O<T>, T, T, C>;
-export declare const $set_: <Q, T extends Q & O, V extends Q & O, C = unknown>(updater: Updater<T, T, V, C>) => RawStages<O<Q>, T, V, C, 1>;
-export declare const $replaceWith_: <T extends O, V extends O, C = unknown>(expr: Expr<V, T, C>) => RawStages<O, T, V, C, 1>;
-export declare const $unwind_: <T extends O, K extends s, U, Null extends null = never>(k: K, includeNull?: Null) => RawStages<O<T>, T & Rec<K, Arr<U>>, T & Rec<K, Null | U>>;
-export 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>;
-export declare const $documents_: <T extends O, C>(docs: Expr<Arr<T>, unknown, C>) => RawStages<unknown, null, T, C, 1>;
-export declare const $project_: <T extends O, K extends import("../..").StrKey<T>>(projection: import("../utils/map-object").ExactKeys<K>) => RawStages<T, T, T, unknown, 1>;
-export declare const $simpleLookup_: <T extends O, U extends O, R, K extends s, Ctx, C = unknown, S = string>(args: LookupArgs<T, U, R, K, Ctx, C, S>) => RawStages<O<T>, T, T & Rec<K, Arr<U>>, C, 1>;