@omegup/msync 0.0.31 → 0.0.32-test2

package/index.js

@@ -467,7 +467,12 @@ const $replaceWith1 = (expr) => f => {
         { $replaceWith: parts.reduce((v, k) => ({ [k]: v }), expr.raw(f()).get()) },
     ]);
 };
-const $unwind1 = (k) => f => asStages([{ $unwind: `$${f().of(k).str()}` }]);
+const $unwind1 = (k, includeNull) => f => {
+    const path = `$${f().of(k).str()}`;
+    return asStages([
+        { $unwind: path },
+    ]);
+};
 const $group1 = (id, args) => (f) => asStages([
     {
         $group: {
@@ -498,7 +503,7 @@ const $simpleLookup1 = (args) => f => {
 const $match_ = (query) => $match1(query)(root);
 const $set_ = (updater) => $set1(updater)(root);
 const $replaceWith_ = (expr) => $replaceWith1(expr)(root);
-const $unwind_ = (k) => $unwind1(k)(root);
+const $unwind_ = (k, includeNull) => $unwind1(k)(root);
 const $group_ = () => (id, args) => $group1(id, args)(root);
 const $project_ = $project1;
 const $simpleLookup_ = (args) => $simpleLookup1(args)(root);
@@ -614,29 +619,6 @@ const $groupMerge = (id, args, out, gid, extra, idPrefix = '') => ({
 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 $expr = (expr) => ({
-    raw: f => ({ $expr: expr.raw(f).get() }),
-});
-
-const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
-    root().of('_id').expr();
-    root().of(k2).of('_id').expr();
-    return link()
-        .with($simpleLookup1({
-        coll,
-        k: k2,
-        vars: map1('local', root().with(field1).expr()),
-        pipeline: link()
-            .with(input)
-            .with($match_($expr(eq(ctx()('local').expr())(root().of('before').with(field2).expr()))))
-            .with(exec)
-            .with($replaceWith_(root().of('before').expr())).stages,
-    })(f))
-        .with($unwind1(k2)(f))
-        .with(link().stages
-        ).stages;
-};
-
 const deltaExpr = (expr) => (field) => {
     return ite(eqTyped($ifNull(root().of(field).expr(), nil), nil), nil, expr(field));
 };
@@ -666,7 +648,82 @@ const $setDelta = (updater) => {
         .with($setEach(k => to(nil), dict)).stages;
 };
 
-const $unwindDelta = (k1, k2, k) => {
+const $unwindDelta = (k1, k2, k, includeNull) => {
+    const outer = includeNull === null;
+    const newItems = {
+        $filter: {
+            input: { $ifNull: [`$after.${k2}`, []] },
+            as: 'a',
+            cond: {
+                $not: {
+                    $in: [
+                        '$$a._id',
+                        {
+                            $map: {
+                                input: { $ifNull: [`$before.${k2}`, []] },
+                                as: 'b',
+                                in: '$$b._id',
+                            },
+                        },
+                    ],
+                },
+            },
+        },
+    };
+    const oldItems = {
+        $filter: {
+            input: {
+                $map: {
+                    input: { $ifNull: [`$before.${k2}`, []] },
+                    as: 'b',
+                    in: {
+                        before: '$$b',
+                        after: {
+                            $ifNull: [
+                                {
+                                    $first: {
+                                        $filter: {
+                                            input: `$after.${k2}`,
+                                            as: 'a',
+                                            cond: { $eq: ['$$a._id', '$$b._id'] },
+                                        },
+                                    },
+                                },
+                                null,
+                            ],
+                        },
+                    },
+                },
+            },
+            as: 'a',
+            cond: { $ne: ['$$a.before', '$$a.after'] },
+        },
+    };
+    const ifNull = (k, part, str = `$${[k1, k2].sort()[0]}.${part}._id`) => outer && k == k2 ? { $ifNull: [str, 'null'] } : str;
+    const interDot = ([a, b]) => [a, '.', b];
+    const partReplace = (part) => ({
+        $cond: {
+            if: { $or: [{ $eq: [`$${k1}.${part}`, null] }, { $eq: [`$${k2}.${part}`, null] }] },
+            then: null,
+            else: {
+                _id: k
+                    ? `$${k}.${part}._id`
+                    : {
+                        $concat: interDot([k1, k2].sort().map(k => ifNull(k, part))),
+                    },
+                [k1]: `$${k1}.${part}`,
+                [k2]: outer
+                    ? {
+                        $cond: {
+                            if: `$${k2}.${part}._id`,
+                            then: `$${k2}.${part}`,
+                            else: null,
+                        },
+                    }
+                    : `$${k2}.${part}`,
+            },
+        },
+    });
     const stages = link()
         .with(asStages([
         {
@@ -677,51 +734,34 @@ const $unwindDelta = (k1, k2, k) => {
                 },
                 [k2]: {
                     $concatArrays: [
-                        {
-                            $map: {
-                                input: { $ifNull: [`$before.${k2}`, []] },
-                                as: 'b',
-                                in: {
-                                    before: '$$b',
-                                    after: {
-                                        $ifNull: [
-                                            {
-                                                $first: {
-                                                    $filter: {
-                                                        input: `$after.${k2}`,
-                                                        as: 'a',
-                                                        cond: { $eq: ['$$a._id', '$$b._id'] },
-                                                    },
-                                                },
-                                            },
-                                            null,
-                                        ],
+                        outer
+                            ? {
+                                $cond: {
+                                    if: { $eq: [`$before.${k2}`, []] },
+                                    then: {
+                                        $cond: {
+                                            if: { $eq: [`$after.${k2}`, []] },
+                                            then: [],
+                                            else: [{ before: {}, after: null }],
+                                        },
                                     },
+                                    else: oldItems,
                                 },
-                            },
-                        },
+                            }
+                            : oldItems,
                         {
                             $map: {
-                                input: {
-                                    $filter: {
-                                        input: { $ifNull: [`$after.${k2}`, []] },
-                                        as: 'a',
-                                        cond: {
-                                            $not: {
-                                                $in: [
-                                                    '$$a._id',
-                                                    {
-                                                        $map: {
-                                                            input: { $ifNull: [`$before.${k2}`, []] },
-                                                            as: 'b',
-                                                            in: '$$b._id',
-                                                        },
-                                                    },
-                                                ],
+                                input: outer
+                                    ? {
+                                        $cond: {
+                                            if: {
+                                                $and: [{ $ne: [`$before.${k2}`, []] }, { $eq: [`$after.${k2}`, []] }],
                                             },
+                                            then: [{}],
+                                            else: newItems,
                                         },
-                                    },
-                                },
+                                    }
+                                    : newItems,
                                 as: 'a',
                                 in: { before: null, after: '$$a' },
                             },
@@ -735,45 +775,9 @@ const $unwindDelta = (k1, k2, k) => {
         .with(asStages([
         {
             $replaceWith: {
-                _id: "$_id",
-                before: {
-                    $cond: {
-                        if: { $or: [{ $eq: [`$${k1}.before`, null] }, { $eq: [`$${k2}.before`, null] }] },
-                        then: null,
-                        else: {
-                            _id: {
-                                $concat: k
-                                    ? `$${k}.before._id`
-                                    : [
-                                        `$${[k1, k2].sort()[0]}.before._id`,
-                                        '.',
-                                        `$${[k1, k2].sort()[1]}.before._id`,
-                                    ],
-                            },
-                            [k1]: `$${k1}.before`,
-                            [k2]: `$${k2}.before`,
-                        },
-                    },
-                },
-                after: {
-                    $cond: {
-                        if: { $or: [{ $eq: [`$${k1}.after`, null] }, { $eq: [`$${k2}.after`, null] }] },
-                        then: null,
-                        else: {
-                            _id: {
-                                $concat: k
-                                    ? `$${k}.after._id`
-                                    : [
-                                        `$${[k1, k2].sort()[0]}.after._id`,
-                                        '.',
-                                        `$${[k1, k2].sort()[1]}.after._id`,
-                                    ],
-                            },
-                            [k1]: `$${k1}.after`,
-                            [k2]: `$${k2}.after`,
-                        },
-                    },
-                },
+                _id: '$_id',
+                before: partReplace('before'),
+                after: partReplace('after'),
             },
         },
     ])).stages;
@@ -793,7 +797,7 @@ const $unwind = (k, dict) => ({
     raw: $unwind1(k),
 });
 
-const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k) => {
+const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k, includeNull) => {
     return link()
         .with($replaceWithDelta(field(map1(k1, root().expr()))))
         .with($simpleLookup_({
@@ -822,8 +826,30 @@ const $lookupDelta = ({ field1, field2 }, { coll, exec, input }, k1, k2, k) => {
         const a = root().of(f1).of('before').expr();
         const part = root().of(f);
         return ite(eq(root().of(f).expr())(nil), nil, field(omit.backward(mergeExpr(omit.forward(map1(k2, a)), map1(k1, part.of(k1).expr())))));
-    }))
-        .with($unwindDelta(k1, k2, k)).stages;
+    })).with($unwindDelta(k1, k2, k, includeNull)).stages;
+};
+
+const $expr = (expr) => ({
+    raw: f => ({ $expr: expr.raw(f).get() }),
+});
+
+const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k) => (f) => {
+    root().of('_id').expr();
+    root().of(k2).of('_id').expr();
+    return link()
+        .with($simpleLookup1({
+        coll,
+        k: k2,
+        vars: map1('local', root().with(field1).expr()),
+        pipeline: link()
+            .with(input)
+            .with($match_($expr(eq(ctx()('local').expr())(root().of('before').with(field2).expr()))))
+            .with(exec)
+            .with($replaceWith_(root().of('before').expr())).stages,
+    })(f))
+        .with($unwind1(k2)(f))
+        .with(link().stages
+        ).stages;
 };
 
 const asBefore = (f) => f(() => root().of('before'));
@@ -939,9 +965,9 @@ const runCont = async ({ next }, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup) => {
-    createIndex(leftSnapshot.coll, { [lField.str()]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
-    createIndex(rightSnapshot.coll, { [rField.str()]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
+const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, includeNull) => {
+    createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
+    createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }).catch(e => e.code == 86 || Promise.reject(e));
     const rightJoinField = { field1: lField, field2: rField };
     const joinId = 'left';
     const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as));
@@ -954,7 +980,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         out: (finalInput) => {
             const leftJoinField = { field1: rField, field2: lField };
             const joinL_Delta = $lookupDelta(leftJoinField, leftSnapshot, 'right', 'left', joinId);
-            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId);
+            const joinR_Delta = $lookupDelta(rightJoinField, rightSnapshot, 'left', 'right', joinId, includeNull);
             const mergeForeignIntoDoc = concatStages($replaceWithDelta(mergeObjects(root().of('left').expr(), fieldM({ a: root().of('right').expr(), b: root().of('_id').expr() }, dictId))), stagesUntilNextLookup.delta);
             const lRunnerInput = concatStages(joinR_Delta, mergeForeignIntoDoc);
             const rRunnerInput = concatStages(joinL_Delta, mergeForeignIntoDoc);
@@ -968,7 +994,7 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
         },
     };
 };
-const $lookup1 = (p) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input)));
+const $lookup1 = (p, includeNull) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, includeNull)));
 const $lookup = (p) => (l) => $lookup1({
     right: p.from,
     as: p.as,
@@ -976,6 +1002,13 @@ const $lookup = (p) => (l) => $lookup1({
     rField: p.foreignField,
     left: l(emptyDelta()),
 });
+const $outerLookup = (p) => (l) => $lookup1({
+    right: p.from,
+    as: p.as,
+    lField: p.localField,
+    rField: p.foreignField,
+    left: l(emptyDelta()),
+}, null);
 
 const operator = () => (op) => (operand) => {
     return {
@@ -1188,7 +1221,7 @@ const makeWatchStream = (db, { collection, projection: p, hardMatch: m }, startA
 };
 
 const actions = {
-    updateMany: (c, args) => [c.updateMany(...args), [`db['${c.collectionName}'].updateMany(`, ...args, ')']],
+    updateMany: (c, args) => [c.updateMany(...args), [`db['${c.collectionName}'].updateMany(...`, args, ')']],
 };
 const streamNames = {};
 const executes$1 = (view, input, streamName) => {
@@ -1268,9 +1301,9 @@ const executes$1 = (view, input, streamName) => {
                     params: p,
                 };
                 const [action, out] = actions[method](collection, params);
-                log('teardown', `db.['${snapshotCollection.collectionName}'].drop()`, ...out);
+                log('teardown', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
                 await Promise.all([snapshotCollection.drop(), action]);
-                log('teardown done', `db.['${snapshotCollection.collectionName}'].drop()`, ...out);
+                log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
             };
             if (exists && !same)
                 await handleTeardown(exists);
@@ -1780,6 +1813,7 @@ exports.$ne = $ne;
 exports.$nin = $nin;
 exports.$nor = $nor;
 exports.$or = $or;
+exports.$outerLookup = $outerLookup;
 exports.$pushDict = $pushDict;
 exports.$rand = $rand;
 exports.$replaceWith = $replaceWith;

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.0.31",
+    "version": "0.0.32-test2",
     "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,10 +0,0 @@
-import type { OPick, RWCollection } from '../../types';
-import type { ID, N, O, Rec, Replace, StrKey, doc } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Delta, StreamRunnerParam, TS } from '../types';
-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;
-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>) => StreamRunnerParam<Source, "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>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-export {};

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

@@ -1,11 +0,0 @@
-import type { RWCollection } from '../../types';
-import type { ID, O, doc } from '../../types/json';
-import type { Del, Delta, Expr, StreamRunnerParam, TS } from '../types';
-type ND = {
-    readonly deletedAt?: null;
-};
-export type Merge<T extends ID> = (T & ND & TS) | Del;
-export 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">;
-export declare const $simpleInsert: <T extends doc>(out: RWCollection<Merge<T>>) => StreamRunnerParam<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" | keyof Omit<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,15 +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>;
-export type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Partial<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,8 +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';

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

@@ -1,10 +0,0 @@
-import type { AsLiteral, ID, N, O, Rec } 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> = Delta<Rec<K1, LE> & Rec<Exclude<KK2, BA | K1>, RE> & ID>;
-export declare const $lookupDelta: <LQ extends O, LE extends LQ & O, RQ extends O, RE extends RQ, BRB extends UBefore<RQ>, RS extends UBefore<RQ>, S, K1 extends s, KK2 extends s>({ 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: K1 | Exclude<KK2, BA | K1> | false) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE>>;
-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>({ 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" | "right" | false) => <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,11 +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 {};

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>(k: K) => RawStages<O<T>, T & Rec<K, Arr<U>>, T & Rec<K, 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>;

package/lib/aggregate/out.d.ts

@@ -1,34 +0,0 @@
-import type { O, RWCollection, ReadonlyCollection, Replace, jsonItem } from '../../types';
-import type { ExprsExact } from '../expression/concat';
-import { type Field } from '../field';
-import type { RawStages } from '../types';
-export type MergeInto<T extends O, Out extends O, E = unknown> = {
-    whenNotMatched: 'insert';
-    into: RWCollection<T, Out>;
-} | {
-    whenNotMatched: 'discard' | 'fail';
-    into: ReadonlyCollection<Out> & E;
-};
-export type MergeArgs<T extends O, Out extends O, Ctx, In extends O> = {
-    on: Field<T, jsonItem> & Field<Out, jsonItem>;
-} & MergeInto<T, Out> & (({
-    stages?: undefined;
-} & ({
-    whenMatched: 'keepExisting' | 'fail';
-} | {
-    whenMatched: 'replace';
-    into: RWCollection<T, Out>;
-} | {
-    whenMatched: 'merge';
-    into: RWCollection<Replace<Out, T>, Out>;
-})) | {
-    stages: true;
-    into: RWCollection<In, Out>;
-    whenMatched: RawStages<unknown, Out, In>;
-} | {
-    stages: 'ctx';
-    vars: ExprsExact<Ctx, T>;
-    into: RWCollection<In, Out>;
-    whenMatched: RawStages<unknown, Out, In, Ctx>;
-});
-export declare const $merge_: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>({ into, on, whenNotMatched, ...notMatched }: MergeArgs<T, Out, Ctx, In>) => RawStages<unknown, T, "out", unknown, number>;

package/lib/aggregate/prefix.d.ts

@@ -1,33 +0,0 @@
-import type { App, HKT, O2, O3, O, RawObj } from '../../types';
-import type { Delta, DeltaStages, FRawStages, RawStages, Stream, TStages } from '../types';
-import type { Equal } from '../utils/guard';
-type n = number;
-export declare const asStages: <Q, T extends Q, V extends Q, C = unknown, M extends n = number>(x: readonly RawObj[]) => RawStages<Q, T, V, C, M>;
-export declare const same: <T extends Dom, V extends Dom, F extends HKT<Dom, Q>, Dom = unknown, Q = unknown, C = unknown, M extends n = number>(_: Equal<Dom, T, V>) => RawStages<Q, App<F, T>, App<F, V>, C, M>;
-export declare const concatStages: <Q, T extends Q, V extends Q, W extends Q, C, M extends n = number>(part1: RawStages<Q, T, V, C, M>, part2: RawStages<Q, V, W, C, M>) => RawStages<Q, T, W, C, M>;
-export declare const concatFStages: <Q, T extends Q & O, V extends Q & O, W extends Q & O, C, M extends n = number>(part1: FRawStages<Q, T, V, C, M>, part2: FRawStages<Q, V, W, C, M>) => FRawStages<Q, T, W, C, M>;
-export declare const concatDelta: <Q extends O, T extends Q, V extends Q, W extends Q>(part1: DeltaStages<Q, T, V>, part2: DeltaStages<Q, V, W>) => DeltaStages<Q, T, W>;
-type Concat<out Q, in T extends Q, out V extends Q, in out C, in out M extends n = n> = {
-    with: <Q2, W extends Q2>(extra: RawStages<Q | Q2, V, W, C, M>) => Concat<Q | Q2, T, W, C, M>;
-    stages: RawStages<Q, T, V, C, M>;
-};
-type FConcat<out Q, in T extends Q & O, out V extends Q & O, in out C, in out M extends n = n> = {
-    with: <Q2, W extends Q2 & O>(extra: FRawStages<Q | Q2, V, W, C, M>) => FConcat<Q | Q2, T, W, C, M>;
-    stages: FRawStages<Q, T, V, C, M>;
-};
-export type DeltaPipe<Q extends O, T extends Q, F extends HKT<O2>, G extends HKT<O3>> = {
-    with: <Q2 extends O, V extends Q2>(map: (a: Stream<Q, T, F, G>) => Stream<Q | Q2, V, F, G>) => DeltaPipe<Q | Q2, V, F, G>;
-    then: <Q2 extends O, V extends Q2>(next: App<G, [Q2 | T, T, V]>) => DeltaPipe<Q | Q2, V, F, G>;
-    get: () => App<F, [Q, T]>;
-};
-export declare const pipe: <Q extends O, S extends Q, T extends Q, F extends HKT<O2>, G extends HKT<O3>>(stream: Stream<Q, S, F, G>, s: App<G, [Q, S, T]>, concat: <Q_1 extends O, T_1 extends Q_1, V extends Q_1, W extends Q_1>(part1: App<G, [Q_1, T_1, V]>, part2: App<G, [Q_1, V, W]>) => App<G, [Q_1, T_1, W]>, empty: <T_2 extends Q>() => App<G, [Q, T_2, T_2]>) => DeltaPipe<Q, T, F, G>;
-type Link = <T, C = unknown, M extends n = n>() => Concat<T, T, T, C, M>;
-type FLink = <T extends O, C = unknown, M extends n = n>() => FConcat<T, T, T, C, M>;
-export declare const link: Link;
-export declare const flink: FLink;
-export declare const emptyDelta: <T extends O>() => {
-    delta: RawStages<Delta<T>, Delta<T>, Delta<T>, unknown, number>;
-    raw: <F extends HKT<O>>() => RawStages<App<F, T>, App<F, T>, App<F, T>, unknown, number>;
-};
-export declare const concatTStages: <S, Q, B extends Q, T extends Q, V extends Q>({ coll, exec, input }: TStages<S, Q, B, T>, stages: RawStages<Q, T, V>) => TStages<S, Q, B, V>;
-export {};

package/lib/aggregate/raws.d.ts

@@ -1,17 +0,0 @@
-import type { App, Arr, ConstHKT, HKT, O, Rec, StrKey, rawItem } from '../../types';
-import type { ExprsExact } from '../expression/concat';
-import { type Field } from '../field';
-import type { Accumulators, Expr, FRawStages, LookupArgs, Query, RawStages } from '../types';
-import type { Updater } from '../update/updater';
-import { type ExactKeys } from '../utils/map-object';
-type s = string;
-export declare const $match1: <T extends O, C = unknown>(query?: Query<T, C>) => FRawStages<T, T, T, C>;
-export declare const $set1: <Q, T extends Q & O, V extends Q & O, C = unknown>(updater: Updater<T, T, V, C>) => FRawStages<Q, T, V, C, 1>;
-export declare const $project1: <T extends O, K extends StrKey<T>>(projection: ExactKeys<K>) => RawStages<T, T, T, unknown, 1>;
-export declare const $replaceWith1: <T extends O, V extends O, C = unknown>(expr: Expr<V, T, C>) => FRawStages<O, T, V, C, 1>;
-export declare const $unwind1: <T extends O, K extends s, R>(k: K) => FRawStages<T, T & Rec<K, Arr<R>>, T & Rec<K, R>>;
-export declare const $group1: <T extends O, ID, V extends O, C>(id: Expr<ID, T, C>, args: Accumulators<T, V, C>) => <F extends HKT<O, O>>(f: <T_1 extends O>() => Field<App<F, T_1>, T_1>) => RawStages<O, App<F, T>, Rec<"_id", ID> & V, C, 1>;
-export declare const $documents1: <Q extends O, T extends Q & O, C>(docs: Expr<Arr<T>, unknown, C>) => <F extends HKT<O, O>>(f: <T_1 extends O>() => Field<App<F, T_1>, T_1>) => RawStages<unknown, null, App<F, T>, C, 1>;
-export declare const rawVars: <T, Ctx, C, V extends O>(vars: ExprsExact<Ctx, T, C>, f: Field<V, T, unknown>) => import("../utils/map-object").ExactPart1<Ctx, ConstHKT<rawItem, unknown>>;
-export declare const $simpleLookup1: <T extends O, U extends O, R, K extends s, Ctx, C = unknown, S = string>(args: LookupArgs<T, U, R, K, Ctx, C, S>) => FRawStages<T, T, T & Rec<K, Arr<U>>, C, 1>;
-export {};