@omegup/msync 0.1.22 → 0.1.24

package/index.js

@@ -1253,19 +1253,48 @@ const $lookupRaw = ({ field1, field2 }, { coll, exec, input }, k2, k, includeNul
 
 const asBefore = (f) => f(() => root().of('before'));
 
-const createIndex = async (collection, indexSpec, options) => {
+const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
+const replace = (s) => s.replace(/\{"\$timestamp":"(\d+)"\}/g, (_, d) => T(d));
+const json = (a) => replace(JSON.stringify(a));
+const log = (...args) => console.log(new Date(), ...args.map(a => (typeof a === 'function' ? a(replace) : a && typeof a === 'object' ? json(a) : a)));
+
+const indexMap = new Map();
+const createIndex = async (collection, indexSpec, op) => {
+    const { name, ...options } = op ?? {};
+    const map = indexMap.get(collection.collectionName) ?? new Map();
+    indexMap.set(collection.collectionName, map);
+    const indexKey = `${JSON.stringify(indexSpec)}-${JSON.stringify(options)}`;
+    if (map.has(indexKey)) {
+        await map.get(indexKey);
+        return;
+    }
+    const promise = createIndexWithRetry(collection, indexSpec, op);
+    map.set(indexKey, promise);
+    await promise;
+};
+const createIndexWithRetry = async (collection, indexSpec, options) => {
+    const log = () => { };
+    log('Creating index', { collection: collection.collectionName, indexSpec, options });
     while (true) {
         try {
             await collection.createIndex(indexSpec, options);
+            log('Index created', { collection: collection.collectionName, indexSpec, options });
         }
         catch (e) {
             if ([85, 276].includes(e.code)) {
+                log('Index created with different name', e.code, { collection: collection.collectionName, indexSpec, options });
                 break;
             }
             if (e.code == 12587) {
                 await new Promise(res => setTimeout(res, 300));
                 continue;
             }
+            log('Error creating index', {
+                collection: collection.collectionName,
+                indexSpec,
+                options,
+                error: e,
+            });
             console.error('Error creating index', e);
             throw e;
         }
@@ -1335,7 +1364,7 @@ const mergeIterators = (params) => {
     };
 };
 
-const state = { steady: false, f: (_) => Promise.resolve() };
+const state = { steady: false };
 let timeout = null;
 const firstWorksMerge = (iters) => {
     const iterator = () => {
@@ -1343,7 +1372,7 @@ const firstWorksMerge = (iters) => {
         const sources = { ...results };
         return mergeIterators({
             sources,
-            interrupt: key => false,
+            interrupt: key => state.steady,
             hooks: {
                 start: (frame, result) => {
                     if (!frame.info.job)
@@ -1411,8 +1440,6 @@ const runCont = async (it, cb) => {
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
 const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
-    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, joinId, outerLeft));
@@ -1432,6 +1459,15 @@ const join = ({ lField, rField, left, right, as }, leftSnapshot, rightSnapshot,
             const getRunner = (f, stages, final) => f.out({
                 raw: first => concatStages(stages, final.raw(first)),
                 teardown: final.teardown,
+            }, async () => {
+                log('Creating indexes for lookup left', leftSnapshot.coll.collectionName, {
+                    [`before.${lField.str()}`]: 1,
+                });
+                await createIndex(leftSnapshot.coll, { [`before.${lField.str()}`]: 1 }, { name: 'left_' + new mongodb.UUID().toString('base64') });
+                log('Creating indexes for lookup right', rightSnapshot.coll.collectionName, {
+                    [`before.${rField.str()}`]: 1,
+                });
+                await createIndex(rightSnapshot.coll, { [`before.${rField.str()}`]: 1 }, { name: 'right_' + new mongodb.UUID().toString('base64') });
             });
             const lRunner = getRunner(left, lRunnerInput, finalInput);
             const rRunner = getRunner(right, rRunnerInput, finalInput);
@@ -1526,11 +1562,6 @@ const $insertPart = (out, ext) => {
 const $insert = (out) => $insertPart(out, {});
 const assertNotNull = (expr) => expr;
 
-const T = (s) => `Timestamp(${parseInt(`${BigInt(s) / 2n ** 32n}`)}, ${parseInt(`${BigInt(s) % 2n ** 32n}`)})`;
-const replace = (s) => s.replace(/\{"\$timestamp":"(\d+)"\}/g, (_, d) => T(d));
-const json = (a) => replace(JSON.stringify(a));
-const log = (...args) => console.log(new Date(), ...args.map(a => (typeof a === 'function' ? a(replace) : a && typeof a === 'object' ? json(a) : a)));
-
 const aggregate = (db, streamName, input, snapshot = true, start = Date.now()) => input(({ coll, input }) => {
     const req = {
         aggregate: coll.collectionName,
@@ -1659,11 +1690,8 @@ const loop = async (db) => {
     log('starting oplog loop');
     let notify = makePromise();
     let batch = [];
-    const last = db.collection('__last');
     const run = async () => {
-        for await (const event of tailOplog(db, {
-            since: (await last.findOne({ _id: 'oplog' }))?.ts,
-        })) {
+        for await (const event of tailOplog(db, {})) {
             if (event?.fields.size === 0)
                 continue;
             batch = event && batch ? [...batch, event] : null;
@@ -1675,11 +1703,6 @@ const loop = async (db) => {
         while (true) {
             await notify.promise;
             const b = batch;
-            if (b?.length) {
-                last
-                    .updateOne({ _id: 'oplog' }, { $set: { ts: b[b.length - 1].doc.ts } }, { upsert: true })
-                    .catch(() => { });
-            }
             batch = [];
             notify = makePromise();
             yield b;
@@ -1741,7 +1764,12 @@ const register = (coll, keys, cb) => {
             watchers.delete(ns);
     };
 };
-const makeWatchStream = ({ collection, projection: p, hardMatch: m }, streamName) => {
+let maxKeysRemoved = null;
+const makeWatchStream = async ({ collection, projection: p, hardMatch: m }, streamName) => {
+    const { db } = collection.s;
+    await (maxKeysRemoved ??= Promise.all((await db.listCollections({}, { nameOnly: true }).toArray()).map(x => void db
+        .collection(x.name)
+        .updateMany({ touchedAt: new mongodb.MaxKey() }, [{ $set: { touchedAt: '$$CLUSTER_TIME' } }]))).then(() => { }));
     const projection = { ...(p ? mapExactToObject(p, v => v) : {}), deletedAt: 1 };
     let resolve = (_) => { };
     const promise = new Promise(r => (resolve = r));
@@ -1851,44 +1879,17 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
         streamNames[streamName] = hash;
     else if (streamNames[streamName] != hash)
         throw new Error(`streamName ${streamName} already used`);
-    db.command({
-        collMod: coll,
-        changeStreamPreAndPostImages: { enabled: true },
-    });
-    createIndex(collection, { touchedAt: 1 }, hardMatch
-        ? {
-            partialFilterExpression: hardMatch.raw(root()),
-            name: 'touchedAt_hard_' + new mongodb.UUID().toString('base64'),
-        }
-        : {}).catch(e => e.code == 86 || Promise.reject(e));
     const last = db.collection('__last');
     const snapshotCollection = db.collection(coll + '_' + streamName + '_snapshot');
-    createIndex(snapshotCollection, { before: 1 }, {
-        partialFilterExpression: { before: null },
-        name: 'before_' + new mongodb.UUID().toString('base64'),
-    });
-    createIndex(snapshotCollection, { updated: 1 }, {
-        partialFilterExpression: { updated: true },
-        name: 'updated_' + new mongodb.UUID().toString('base64'),
-    });
-    createIndex(snapshotCollection, { updated: 1, after: 1, before: 1 }, {
-        partialFilterExpression: { updated: true, after: null, before: null },
-        name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
-    });
-    createIndex(snapshotCollection, { updated: 1, after: 1 }, {
-        partialFilterExpression: { updated: true, after: null },
-        name: 'updated_no_after_' + new mongodb.UUID().toString('base64'),
-    });
-    createIndex(snapshotCollection, { updated: 1 }, {
-        partialFilterExpression: { updated: true, after: null, before: null },
-        name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
-    });
     const job = {};
-    const run = (finalInput) => {
-        const clear = async () => Promise.all([
-            snapshotCollection.drop().catch(noop).catch(noop),
-            last.deleteOne({ _id: streamName }),
-        ]);
+    const run = (finalInput, setup) => {
+        const dropSnapshot = async () => {
+            await snapshotCollection.drop().catch(noop);
+            log('snapshot collection dropped', streamName, `db['${snapshotCollection.collectionName}'].drop()`);
+            log('with', [...(indexMap.get(snapshotCollection.collectionName)?.keys() ?? [])], 'indexes in map before deletion');
+            indexMap.delete(snapshotCollection.collectionName);
+        };
+        const clear = async () => Promise.all([dropSnapshot(), last.deleteOne({ _id: streamName })]);
         const withStop = (next, tr) => {
             return addTeardown(() => ({ stop, next: next(), clear }), tr);
         };
@@ -1913,7 +1914,9 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
         const step0 = () => synchronousPromise.SynchronousPromise.resolve(next(step1, 'empty new collection'));
         const stop = withStop(step0);
         const step1 = async () => {
+            log('reset collection', streamName, `db['${snapshotCollection.collectionName}'].updateMany( updated: true }, { $set: { updated: false, after: null } })`);
             await snapshotCollection.updateMany({ updated: true }, { $set: { updated: false, after: null } });
+            log('reset collection done', streamName);
             return next(step2, 'get last update');
         };
         const step2 = () => Promise.all([
@@ -1936,13 +1939,45 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                 };
                 const [action, out] = actions[method](collection, params);
                 log('teardown', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
-                await Promise.all([snapshotCollection.drop().catch(noop), action]);
+                await Promise.all([dropSnapshot(), action]);
                 log('teardown done', `db['${snapshotCollection.collectionName}'].drop()`, ...out);
             };
             if (!same) {
                 log('not same, new data', streamName, data);
                 await handleTeardown(exists ?? { data });
             }
+            log('creating indexes');
+            await createIndex(snapshotCollection, { before: 1 }, {
+                partialFilterExpression: { before: null },
+                name: 'before_' + new mongodb.UUID().toString('base64'),
+            });
+            await createIndex(snapshotCollection, { updated: 1 }, {
+                partialFilterExpression: { updated: true },
+                name: 'updated_' + new mongodb.UUID().toString('base64'),
+            });
+            await createIndex(snapshotCollection, { updated: 1, after: 1, before: 1 }, {
+                partialFilterExpression: { updated: true, after: null, before: null },
+                name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
+            });
+            await createIndex(snapshotCollection, { updated: 1, after: 1 }, {
+                partialFilterExpression: { updated: true, after: null },
+                name: 'updated_no_after_' + new mongodb.UUID().toString('base64'),
+            });
+            await createIndex(snapshotCollection, { updated: 1 }, {
+                partialFilterExpression: { updated: true, after: null, before: null },
+                name: 'updated_nulls_' + new mongodb.UUID().toString('base64'),
+            });
+            await db.command({
+                collMod: coll,
+                changeStreamPreAndPostImages: { enabled: true },
+            });
+            await createIndex(collection, { touchedAt: 1 }, hardMatch
+                ? {
+                    partialFilterExpression: hardMatch.raw(root()),
+                    name: 'touchedAt_hard_' + new mongodb.UUID().toString('base64'),
+                }
+                : {});
+            await setup?.();
             await after?.();
             return nextData([])(async () => {
                 await new Promise(resolve => setTimeout(resolve, 1000));
@@ -1982,7 +2017,8 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
             const first = ts === undefined;
             const stages = finalInput.raw(first);
             await last.updateOne({ _id: streamName }, { $set: { job: 1 } }, { upsert: true });
-            const stream = makeStream();
+            const stream = await makeStream();
+            const nextRes = stream.tryNext();
             const aggResult = await aggregate(pdb, streamName, c => c({
                 coll: snapshotCollection,
                 input: link()
@@ -1996,7 +2032,6 @@ const executes$2 = (view, input, streamName, skip = false, after, needs = {}) =>
                     .with(input.delta)
                     .with(stages).stages,
             }), false, start);
-            const nextRes = stream.tryNext();
             stages.at(-1).$merge.into.coll;
             return next(step5({ ts: result.cursor.atClusterTime, aggResult, stream, nextRes, first }), 'remove handled deleted updated', () => stream.close());
         };
@@ -2075,14 +2110,6 @@ const executes$1 = (view, input, streamName, needs) => {
         : pre;
     const job = {};
     const db = collection.s.db, coll = collection.collectionName;
-    db.command({
-        collMod: coll,
-        changeStreamPreAndPostImages: { enabled: true },
-    });
-    createIndex(collection, { touchedAt: 1 }, {
-        partialFilterExpression: { deletedAt: { $eq: null } },
-        name: 'touchedAt_' + new mongodb.UUID().toString('base64'),
-    });
     const last = db.collection('__last');
     const projectInput = projection &&
         $project_(spread(projection, {
@@ -2119,10 +2146,24 @@ const executes$1 = (view, input, streamName, needs) => {
         };
         const step0 = () => synchronousPromise.SynchronousPromise.resolve(next(step1, 'get last update'));
         const stop = withStop(step0);
-        const step1 = () => Promise.all([
-            last.findOne({ _id: streamName, data }),
-            last.findOne({ _id: streamName }),
-        ]).then(ts => next(step2_5(ts), 'handle teardown'));
+        const step1 = async () => {
+            log('creating indexes');
+            await db.command({
+                collMod: coll,
+                changeStreamPreAndPostImages: { enabled: true },
+            });
+            await createIndex(collection, { touchedAt: 1 }, {
+                partialFilterExpression: { deletedAt: { $eq: null } },
+                name: 'touchedAt_' + new mongodb.UUID().toString('base64'),
+            });
+            log('stream started', { streamName, data });
+            const ts = await Promise.all([
+                last.findOne({ _id: streamName, data }),
+                last.findOne({ _id: streamName }),
+            ]);
+            log('got last update', { streamName, ts });
+            return next(step2_5(ts), 'handle teardown');
+        };
         const step2_5 = ([same, exists]) => async () => {
             const handleTeardown = async (last) => {
                 if (!last.data)
@@ -2152,12 +2193,12 @@ const executes$1 = (view, input, streamName, needs) => {
         const makeStream = () => makeWatchStream(view, streamName);
         const step4 = (lastTS) => async () => {
             const raw = stages(lastTS).with(finalInput.raw(lastTS === null)).stages;
-            const stream = makeStream();
+            const stream = await makeStream();
+            const nextRes = stream.tryNext();
             const aggResult = await aggregate(pdb, streamName, c => c({
                 coll: collection,
                 input: raw,
             }));
-            const nextRes = stream.tryNext();
             return next(step7({ aggResult, ts: aggResult.cursor.atClusterTime, stream, nextRes }), 'update __last', () => stream.close());
         };
         const step7 = (l) => async () => {

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.1.22",
+    "version": "0.1.24",
     "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,28 +0,0 @@
-import type { IdHKT, OPick, RWCollection, Timestamp } from '../../types';
-import type { doc, ID, N, O, rawItem, Rec, Replace, RORec, StrKey } from '../../types/json';
-import { type ExprsExact } from '../expression/concat';
-import type { Delta, Expr, IsDeleted, Model, RawStages, 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)>;
-export 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 getWhenMatchedForMerge: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Out, Out | Replace<Out, P>, RORec<"new", Replace<P, RORec<K, Timestamp>>>>;
-export declare const getWhenMatched: <Out extends Model, P extends Model, K extends keyof IsDeleted>(whenNotMatched: "discard" | "fail" | "insert") => RawStages<O, Rec<"old" | "merged", Out | Replace<Out, P>>, Out | Replace<Out, P>>;
-type MergeCollection<V extends O, Out extends Model> = {
-    coll: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>;
-    whenNotMatched: 'discard';
-} | {
-    coll: RWCollection<Out | Replace<Out, Patch<V>>, Out>;
-    whenNotMatched: 'fail';
-};
-export declare const $mergeId: <V extends O>() => <SourcePart extends doc, Out extends Model, E = unknown, EEE extends RORec<string, rawItem> = {}>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, id: Expr<string, OutInputE<TakeDoc<V>, E, null>>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<OutInputE<SourcePart, E>, "out">;
-export declare const $simpleMergePart: <V extends O>() => <Source extends doc, Out extends Model, EEE extends RORec<string, rawItem>>(out: MergeCollection<V, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Source, "out">;
-export declare const $simpleMerge: <V extends O>() => <Source extends doc, Out extends Model>(out: RWCollection<Out | Replace<Out, Patch<V>> | Replace<Patch<V>, IsDeleted>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, Source>, whenNotMatched?: "fail" | "discard") => StreamRunnerParam<Source, "out">;
-export declare const $mergePart: <V extends O>() => <Out extends Model, SourcePart extends doc, EEE extends RORec<string, rawItem>>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>, ext: Exact<Omit<SafeE<EEE>, keyof (ND & TS)>, IdHKT>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-export declare const $merge: <V extends O>() => <Out extends Model, SourcePart extends doc>(out: RWCollection<Out | Replace<Out, Patch<V>>, Out>, keys: ExprsExact<TakeDoc<V, unknown>, SourcePart>) => StreamRunnerParam<Delta<SourcePart>, "out">;
-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, 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 MergedInput, 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<MergedInput<Out, V, Grp, 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<MergedInput<Out, V, string, "_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<MergedInput<Out, V, Grp, "_grp", EE> | 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,20 +0,0 @@
-import type { AsLiteral, ID, O, Rec, Replace, WriteonlyCollection, notArr } from '../../../../types';
-import { type ExprsExact } from '../../../expression/concat';
-import type { Model, 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>>;
-type OrReplace<T, V> = T | Replace<T, V>;
-export type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, 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<MergedInput<Out, VV, Grp, 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").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,37 +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> & E;
-} | {
-    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?: never;
-} & ({
-    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, {
-        new: T;
-    }>;
-} | {
-    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>;
-export declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extends O = Out>(args: 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>;
-export 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, Null extends null = never>(k: K, includeNull?: Null) => FRawStages<T, T & Rec<K, Arr<R>>, T & Rec<K, R | Null>>;
-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 {};