@omegup/msync 0.0.44 → 0.0.46

package/index.esm.js

@@ -1122,6 +1122,7 @@ const createIndex = async (collection, indexSpec, options) => {
                 await new Promise(res => setTimeout(res, 300));
                 continue;
             }
+            console.error('Error creating index', e);
             throw e;
         }
         break;
@@ -1275,18 +1276,18 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     left: l(emptyDelta()),
 }, outer);
 
-const make = (alter) => {
-    return (op, args) => alter(op, args.filter(defined));
+const filterUndefined = (applyOperator) => {
+    return (op, args) => applyOperator(op, args.filter(defined));
 };
-const combine = (op, make) => (...args) => {
-    const q = make(op, args);
-    return q && { raw: field => q(x => x.raw(field)) };
+const combine = (op, applyOperatorToPreItems) => (...args) => {
+    const mapToItems = applyOperatorToPreItems(op, args);
+    return mapToItems && { raw: field => mapToItems(x => x.raw(field)) };
 };
-const all = (op, x) => (x.length === 0 ? undefined : f => ({ [op]: x.map(f) }));
+const all = (op, x) => x.length === 0 ? undefined : f => ({ [op]: x.map(f) });
 const first = (op, x) => (x.length === 1 ? f => f(x[0]) : all(op, x));
-const $and = combine('$and', make(first));
-const $nor = combine('$nor', make(all));
-const $or = combine('$or', make(first));
+const $and = combine('$and', filterUndefined(first));
+const $nor = combine('$nor', filterUndefined(all));
+const $or = combine('$or', filterUndefined(first));
 
 const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), $match_($or(root().of('after').has($ne(null)), root().of('before').has($ne(null)))));
 
@@ -1483,7 +1484,9 @@ const executes$1 = (view, input, streamName) => {
         streamNames[streamName] = hash;
     else if (streamNames[streamName] != hash)
         throw new Error(`streamName ${streamName} already used`);
-    const { collection, projection, hardMatch, match } = view;
+    const { collection, projection, hardMatch: pre, match } = view;
+    const removeNotYetSynchronizedFields = Object.values(mapExactToObject(projection, (_, k) => k.startsWith('_') ? root().of(k).has($ne(null)) : null));
+    const hardMatch = $and(pre, ...removeNotYetSynchronizedFields);
     const job = {};
     const db = collection.s.db, coll = collection.collectionName;
     db.command({
@@ -1492,7 +1495,7 @@ const executes$1 = (view, input, streamName) => {
     });
     createIndex(collection, { touchedAt: 1 }, hardMatch
         ? {
-            partialFilterExpression: hardMatch,
+            partialFilterExpression: hardMatch.raw(root()),
             name: 'touchedAt_hard_' + new UUID().toString('base64'),
         }
         : {}).catch(e => e.code == 86 || Promise.reject(e));
@@ -1636,7 +1639,10 @@ const executes$1 = (view, input, streamName) => {
         const step8 = (l) => {
             return nextData(l.aggResult.cursor.firstBatch)(() => l.stream
                 .tryNext()
-                .catch(err => { log('restarting', err); return 1; })
+                .catch(err => {
+                log('restarting', err);
+                return 1;
+            })
                 .then(doc => (doc ? next(step2, 'restart') : step8(l))), 'wait for change');
         };
         return stop;

package/index.js

@@ -1124,6 +1124,7 @@ const createIndex = async (collection, indexSpec, options) => {
                 await new Promise(res => setTimeout(res, 300));
                 continue;
             }
+            console.error('Error creating index', e);
             throw e;
         }
         break;
@@ -1277,18 +1278,18 @@ const $outerLookup = (p, outer) => (l) => $lookup1({
     left: l(emptyDelta()),
 }, outer);
 
-const make = (alter) => {
-    return (op, args) => alter(op, args.filter(defined));
+const filterUndefined = (applyOperator) => {
+    return (op, args) => applyOperator(op, args.filter(defined));
 };
-const combine = (op, make) => (...args) => {
-    const q = make(op, args);
-    return q && { raw: field => q(x => x.raw(field)) };
+const combine = (op, applyOperatorToPreItems) => (...args) => {
+    const mapToItems = applyOperatorToPreItems(op, args);
+    return mapToItems && { raw: field => mapToItems(x => x.raw(field)) };
 };
-const all = (op, x) => (x.length === 0 ? undefined : f => ({ [op]: x.map(f) }));
+const all = (op, x) => x.length === 0 ? undefined : f => ({ [op]: x.map(f) });
 const first = (op, x) => (x.length === 1 ? f => f(x[0]) : all(op, x));
-const $and = combine('$and', make(first));
-const $nor = combine('$nor', make(all));
-const $or = combine('$or', make(first));
+const $and = combine('$and', filterUndefined(first));
+const $nor = combine('$nor', filterUndefined(all));
+const $or = combine('$or', filterUndefined(first));
 
 const $matchDelta = (query) => concatStages($replaceWithDelta(ite(query, root().expr(), nil)), $match_($or(root().of('after').has($ne(null)), root().of('before').has($ne(null)))));
 
@@ -1485,7 +1486,9 @@ const executes$1 = (view, input, streamName) => {
         streamNames[streamName] = hash;
     else if (streamNames[streamName] != hash)
         throw new Error(`streamName ${streamName} already used`);
-    const { collection, projection, hardMatch, match } = view;
+    const { collection, projection, hardMatch: pre, match } = view;
+    const removeNotYetSynchronizedFields = Object.values(mapExactToObject(projection, (_, k) => k.startsWith('_') ? root().of(k).has($ne(null)) : null));
+    const hardMatch = $and(pre, ...removeNotYetSynchronizedFields);
     const job = {};
     const db = collection.s.db, coll = collection.collectionName;
     db.command({
@@ -1494,7 +1497,7 @@ const executes$1 = (view, input, streamName) => {
     });
     createIndex(collection, { touchedAt: 1 }, hardMatch
         ? {
-            partialFilterExpression: hardMatch,
+            partialFilterExpression: hardMatch.raw(root()),
             name: 'touchedAt_hard_' + new mongodb.UUID().toString('base64'),
         }
         : {}).catch(e => e.code == 86 || Promise.reject(e));
@@ -1638,7 +1641,10 @@ const executes$1 = (view, input, streamName) => {
         const step8 = (l) => {
             return nextData(l.aggResult.cursor.firstBatch)(() => l.stream
                 .tryNext()
-                .catch(err => { log('restarting', err); return 1; })
+                .catch(err => {
+                log('restarting', err);
+                return 1;
+            })
                 .then(doc => (doc ? next(step2, 'restart') : step8(l))), 'wait for change');
         };
         return stop;

package/package.json

@@ -3,7 +3,7 @@
     "module": "index.esm.js",
     "typings": "index.d.ts",
     "name": "@omegup/msync",
-    "version": "0.0.44",
+    "version": "0.0.46",
     "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, doc } 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, Null extends null = never> = Delta<Rec<K1, LE> & Rec<Exclude<KK2, BA | K1>, RE | Null> & 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, K1 extends s, KK2 extends s, Null 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: K1 | Exclude<KK2, BA | K1> | false, includeNull?: Null) => RawStages<unknown, Delta<LE>, Both<K1, LE, KK2, RE, Null>>;
-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,16 +0,0 @@
-import type { AsLiteral, O, RORec, doc, notArr } from '../../../types';
-import { type NullToOBJ } from '../../expression/array';
-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, LNull extends null = never, RNull extends null = never>(p: Params<As, LQ, RQ, RE, S>, outer: {
-    left?: LNull;
-    right?: RNull;
-}) => <LE extends LQ>(l: SnapshotStream<LQ, LE>) => SnapshotStream<LQ | NullToOBJ<RNull>, (LE | NullToOBJ<RNull>) & RORec<As, RE | LNull>>;
-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>;

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, 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 {};

package/lib/aggregate/set/$replace-with-each.d.ts

@@ -1,12 +0,0 @@
-import type { ConstHKT, HKT, I, N, O, RORec, Rec, jsonItem } from '../../../types';
-import type { BA, Delta, Expr, FRawStages, RawStages } from '../../types';
-import { type Updater } from '../../update/updater';
-import { type MapK } from '../../utils/map-object';
-export interface ParDeltaHKT<K extends BA, T extends jsonItem, E> extends HKT<jsonItem> {
-    readonly out: RORec<K, I<jsonItem, this>> & Delta<T> & E;
-}
-type Delta2<T extends jsonItem, BA2 extends string> = Delta<T> & Partial<RORec<BA2, T | null>>;
-export declare const $setEach1: <T extends jsonItem, V extends jsonItem, BA2 extends string, E = unknown, C = unknown>(updater: (k: BA) => Updater<Delta<T> & Partial<RORec<BA2, T | null>> & E, T | N, V | null, C>, dict: MapK<BA2, ConstHKT<BA>>) => FRawStages<unknown, Delta2<T, BA2> & E, Rec<BA2, V | null> & Omit<Delta<T> & E, BA2>, C, 1>;
-export declare const $setEach: <T extends O, V extends jsonItem, BA2 extends string, E = unknown, C = unknown>(updater: (k: BA) => Updater<Delta<T> & E, T | N, V | null, C>, dict: MapK<BA2, ConstHKT<BA>>) => RawStages<unknown, Delta2<T, BA2> & E, Rec<BA2, V | null> & Omit<Delta<T> & E, BA2>, C, 1>;
-export declare const $replaceWithEach: <T extends O, V extends jsonItem, E = unknown>(expr: <K extends BA>(field: K) => Expr<V | null, Rec<K, T> & Delta<T> & E>) => RawStages<unknown, Delta<T> & E, Delta<V> & Omit<E, BA>>;
-export {};

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

@@ -1,5 +0,0 @@
-import type { O, jsonItem } from '../../../types';
-import type { Delta, Expr, RawStages } from '../../types';
-import { type Updater } from '../../update/updater';
-export declare const $replaceWithDelta: <T extends O, V extends jsonItem>(expr: Expr<V, T>) => RawStages<unknown, Delta<T>, Delta<V>>;
-export declare const $setDelta: <T extends O, V extends O, C = unknown>(updater: Updater<T, T, V, C>) => RawStages<unknown, Delta<T>, Delta<V>, C, number>;

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

@@ -1,6 +0,0 @@
-import type { O, Replace } from '../../../types';
-import type { DeltaStages, Expr, LinStages } from '../../types';
-import { type UpdaterHKT } from '../../update/updater';
-import type { MapO } from '../../utils/map-object';
-export declare const $set: <V extends O>() => <R extends O, C = unknown>(fields: MapO<V, UpdaterHKT<R, R, V, C>>) => DeltaStages<O, R, Replace<R, V>, C> & LinStages<O, R, Replace<R, V>, C>;
-export declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;

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

@@ -1 +0,0 @@
-export { $replaceWith, $set } from './$set';

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

@@ -1,5 +0,0 @@
-import type { Arr, AsLiteral, ID, Rec, doc } from '../../../types';
-import type { Delta, RawStages } from '../../types';
-type s = string;
-export declare const $unwindDelta: <K1 extends s, T extends doc, K2 extends s, U extends doc, Null extends null = never>(k1: AsLiteral<K1>, k2: AsLiteral<K2>, k: K1 | K2 | false, includeNull?: Null) => RawStages<Delta<Rec<K1, T>>, Delta<Rec<K1, T> & Rec<K2, Arr<U>>>, Delta<Rec<K1, T> & Rec<K2, U | Null> & ID>>;
-export {};

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

@@ -1,5 +0,0 @@
-import type { Arr, AsLiteral, doc, O, Rec, RORec } from '../../../types';
-import type { DeltaStages } from '../../types';
-export { $unwindDelta } from './$unwind-delta';
-type s = string;
-export declare const $unwind: <T extends doc, K extends s, U extends doc>(k: AsLiteral<K>, dict: RORec<K, "key">) => DeltaStages<O, T & Rec<K, Arr<U>>, T & Rec<K, U>>;

package/lib/boot/boot-simpl.d.ts

@@ -1,14 +0,0 @@
-import type { O2, O3, OPickD, RORec, StrKey, View } from '../../types';
-import type { HKT, I } from '../../types/hkt';
-import type { RawStages } from '../types';
-import type { Model, SimpleStreamExecutionResult } from '../types/stream';
-type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
-type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
-interface StreamRunnerHKT extends HKT<O2> {
-    readonly out: SimpleStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
-}
-interface StagesHKT extends HKT<O3> {
-    readonly out: RORec<'lin', RawStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2], unknown, 1>>;
-}
-export declare const from: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string) => import("../aggregate/prefix").DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, StreamRunnerHKT, StagesHKT>;
-export {};

package/lib/boot/boot.d.ts

@@ -1,36 +0,0 @@
-import { Collection, type Timestamp } from 'mongodb';
-import type { BSON, O2, O3, OPickD, RawObj, StrKey, View } from '../../types';
-import type { HKT, I } from '../../types/hkt';
-import { type DeltaPipe } from '../aggregate/prefix';
-import type { SnapshotStreamExecutionResult } from '../types';
-import type { Actions, DeltaStages, Model } from '../types/stream';
-type Allowed<K> = Exclude<K, 'deletedAt' | '_id'>;
-type AllowedPick<V extends Model, K extends StrKey<V>> = OPickD<V, Allowed<K>>;
-export type Teardown = {
-    collection: string;
-    method: string;
-    params: unknown[];
-};
-export type TsData = {
-    input: readonly RawObj[];
-    finalInput: readonly RawObj[];
-    finalInputFirst: readonly RawObj[];
-    teardown: Teardown;
-};
-export type Last = {
-    _id: string;
-    ts: Timestamp;
-    data?: TsData;
-};
-export declare const actions: {
-    [K in keyof Actions<unknown>]: <W extends BSON.Document>(col: Collection<W>, x: Actions<W>[K]) => [Promise<unknown>, unknown[]];
-};
-export declare const streamNames: Record<string, string>;
-export interface SnapshotStreamHKT extends HKT<O2> {
-    readonly out: SnapshotStreamExecutionResult<I<O2, this>[0], I<O2, this>[1]>;
-}
-export interface DeltaHKT extends HKT<O3> {
-    readonly out: DeltaStages<I<O3, this>[0], I<O3, this>[1], I<O3, this>[2]>;
-}
-export declare const staging: <V extends Model, KK extends StrKey<V>>(view: View<V, Allowed<KK>>, streamName: string) => DeltaPipe<AllowedPick<V, KK>, AllowedPick<V, KK>, SnapshotStreamHKT, DeltaHKT>;
-export {};

package/lib/boot/index.d.ts

@@ -1,2 +0,0 @@
-export { staging } from './boot';
-export { from } from './boot-simpl';

package/lib/expression/arith.d.ts

@@ -1,26 +0,0 @@
-import type { Expr } from '../types';
-export declare const max: <D, C>(...expr: Expr<number, D, C>[]) => Expr<number, D, C>;
-export declare const lt: <D, C>(expr_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
-export declare const gt: <D, C>(expr_0: Expr<number, D, C>, expr_1: Expr<number, D, C>) => Expr<boolean, D, C>;
-export declare const lte: {
-    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
-    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
-};
-export declare const gte: {
-    <D, C>(...expr: [Expr<Date, D, C>, Expr<Date, D, C>]): Expr<boolean, D, C>;
-    <D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<boolean, D, C>;
-};
-type Num = number | null | undefined;
-export declare function subtract<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
-export declare function subtract<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
-export declare function add<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
-export declare function add<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
-export declare function divide<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
-export declare function divide<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
-export declare function multiply<D, C>(...expr: [Expr<number, D, C>, Expr<number, D, C>]): Expr<number, D, C>;
-export declare function multiply<D, C>(...expr: [Expr<Num, D, C>, Expr<Num, D, C>]): Expr<Num, D, C>;
-export declare function floor<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
-export declare function floor<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
-export declare function ceil<D, C>(expr: Expr<number, D, C>): Expr<number, D, C>;
-export declare function ceil<D, C>(expr: Expr<Num, D, C>): Expr<Num, D, C>;
-export {};

package/lib/expression/array.d.ts

@@ -1,26 +0,0 @@
-import type { App, Arr, HKT, N, O, RORec, notArr } from '../../types';
-import type { Expr } from '../types';
-export declare const size: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<number, D, C>;
-export declare const filterDefined: <T, D, C = unknown>(expr: Expr<Arr<T | N>, D, C>) => Expr<Arr<T>, D, C>;
-export declare const filter: <T, D, K extends string, C = unknown>({ as, cond, expr, limit, }: {
-    expr: Expr<Arr<T>, D, C>;
-    as: K;
-    cond: Expr<unknown, D, C & RORec<K, T>>;
-    limit?: Expr<number, D, C>;
-}) => Expr<Arr<T>, D, C>;
-export declare const sortArray: <T, D, C, K extends keyof T>({ sortBy, expr, order, }: {
-    expr: Expr<Arr<T>, D, C>;
-    sortBy: K;
-    order?: 1 | -1;
-}) => Expr<Arr<T>, D, C>;
-export declare const isArray: <T extends notArr, D, C, F extends HKT<T | Arr<T>>>(expr: Expr<T | Arr<T>, D & (App<F, T> | App<F, Arr<T>>), C>) => import("../types").BoolExpr<D & App<F, Arr<T>>, D & App<F, T>, C>;
-export declare const array: <T, D, C = unknown>(...exprs: Expr<T, D, C>[]) => Expr<Arr<T>, D, C>;
-export declare const concatArray: <T, D, C>(...exprs: Expr<Arr<T>, D, C>[]) => Expr<Arr<T>, D, C>;
-export declare const first: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-export declare const firstSure: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T, D, C>;
-export declare const last: <T, D, C>(expr: Expr<Arr<T>, D, C>) => Expr<T | null, D, C>;
-export type NullToOBJ<N extends null> = N extends null ? O : N;
-export declare const mergeObjects: <T1, T2, D, C = unknown, N extends null = never>(exprs_0: Expr<T1 | N, D, C>, exprs_1: Expr<T2, D, C>) => Expr<(T1 | NullToOBJ<N>) & T2, D, C>;
-export declare const inArray: <T, D, C = unknown>(exprs_0: Expr<T, D, C>, exprs_1: Expr<Arr<T>, D, C>) => Expr<boolean, D, C>;
-export declare const slice: <T, D, C>(array: Expr<Arr<T>, D, C>, start: Expr<number, D, C>, end: Expr<number, D, C>) => Expr<Arr<T>, D, C>;
-export declare const except: <T, D, C>(a: Expr<Arr<T>, D, C>, b: Expr<Arr<T>, D, C>) => Expr<Arr<T>, D, C>;

package/lib/expression/concat.d.ts

@@ -1,30 +0,0 @@
-import type { App, HKT, I, IdHKT, O, RORec, StrKey } from '../../types';
-import type { Expr } from '../types';
-import { type Exact, type ExactPart, type MapO, type MergeHKT } from '../utils/map-object';
-export declare const concat: <D, C>(...expr: Expr<string, D, C>[]) => Expr<string, D, C>;
-export declare const str: <D, C>(expr: Expr<unknown, D, C>) => Expr<string, D, C>;
-export declare const toInt: <D, C>(expr: Expr<unknown, D, C>) => Expr<number, D, C>;
-export declare const fieldM: <M extends RORec<Dom, Ref>, T extends RORec<Ref, unknown>, D, Dom extends string = StrKey<M>, Ref extends string = StrKey<T>, C = unknown>(expr: { readonly [K in Ref]: Expr<T[K], D, C>; }, m: Pick<M, Dom>) => Expr<O<{ readonly [K in Dom]: T[M[K]]; }>, D, C>;
-export type Exprs<out T, in D, in C = unknown> = {
-    readonly [K in StrKey<T>]: Expr<T[K], D, C>;
-};
-type MergeExactArgs<T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>> = readonly [
-    Exact<Omit<T1, keyof T2>, F>,
-    Exact<T2, F>
-];
-export declare const mergeExact: <T1, T2, F extends HKT<T1[StrKey<T1>] | T2[StrKey<T2>]>, E = unknown>(exprsExact1: Exact<Omit<T1, keyof T2>, F>, exprsExact2: Exact<T2, F>) => Exact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, F>;
-export type MergeMapOArgs<T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>> = readonly [MapO<Omit<T1, StrKey<T2>>, F1>, MapO<T2, F2>];
-export declare const mergeExact0: <T1, T2, F1 extends HKT<StrKey<Omit<T1, StrKey<T2>>>>, F2 extends HKT<StrKey<T2>>, E = unknown>(exprsExact1: MapO<Omit<T1, StrKey<T2>>, F1>, exprsExact2: MapO<T2, F2>) => MapO<T2 & Omit<T1, StrKey<T2>> & Pick<E, symbol & keyof E>, MergeHKT<T1, T2, F1, F2, StrKey<T2>>>;
-export declare const mergeExpr: <T1, T2, D, C = unknown, E = unknown>(exprs_0: Exact<Omit<T1, keyof T2>, ExprHKT<D, C, IdHKT<unknown>>>, exprs_1: Exact<T2, ExprHKT<D, C, IdHKT<unknown>>>) => ExprsExact<T2 & Omit<T1, keyof T2> & Pick<E, symbol & keyof E>, D, C>;
-export type ExprsPart<T, D, C> = ExactPart<T, ExprHKT<D, C>>;
-export interface ExprHKT<D, C = unknown, F extends HKT = IdHKT> extends HKT<unknown> {
-    readonly out: Expr<App<F, I<unknown, this>>, D, C>;
-}
-export type ExprsExact<T, D, C = unknown, F extends HKT = IdHKT> = Exact<T, ExprHKT<D, C, F>>;
-export interface ExprsExactHKT<E, D, C = unknown, F extends HKT = IdHKT> extends HKT {
-    readonly out: ExprsExact<E & I<unknown, this>, D, C, F>;
-}
-export declare const pair: <T, D, C, P extends StrKey<T>>(k: P, v: Expr<T[P], D, C>) => ExprsExact<T, D, C>[P];
-export declare const fieldF: <F extends HKT>() => <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C, F>) => Expr<O<{ [K in keyof T]: App<F, T[K]>; }>, D, C>;
-export declare const field: <T extends object, D, C = unknown>(exprs: ExprsExact<T, D, C>) => Expr<O<T>, D, C>;
-export {};