@omegup/msync 0.1.46 → 0.1.48

package/index.d.ts

@@ -39,6 +39,7 @@ interface RawObj {
 type raw = readonly rawItem[] | RawObj;
 type StrKey<T> = string & keyof T;
 type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
+type ReplaceQ<R extends Q, VV, Q extends O> = Omit<R, StrKey<VV>> & Omit<VV, StrKey<Q>> & Q;
 type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? {} extends {
     [K in T]: 1;
 } ? never : V : V;
@@ -206,10 +207,10 @@ type BoolExpr<in D1, in D2, in Ctx = unknown> = {
 
 type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
 type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
-type MapO<T, F extends HKT<StrKey<T>>> = MapOPart<T, F> & {
-    readonly [P: string]: readonly [StrKey<T>, unknown];
+type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
+    readonly [P: string]: readonly [K, unknown];
 };
-type MapOPart<T, F extends HKT<StrKey<T>>, K extends keyof T = StrKey<T>> = {
+type MapOPart<T, F extends HKT<K>, K extends keyof T = StrKey<T>> = {
     readonly [P in K]: readonly [P, App<F, P & string>];
 };
 type Exact<T, F extends HKT<T[StrKey<T>]>> = MapO<T, MappedHKT<T, F>>;
@@ -419,17 +420,17 @@ declare const $merge2: <T extends O, Out extends O = T, Ctx = unknown, In extend
 
 type GI$1<GG> = Exclude<GG, keyof TS>;
 type IdAndTsKeys = keyof (TS & ID);
-type V<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
+type V$1<VV, GG extends string> = Omit<VV, IdAndTsKeys | GI$1<GG>>;
 type Prepare<Grp, GG extends string> = TS & ID & Rec<GI$1<GG>, Grp>;
 type Par<T> = {
     [P in keyof T]?: T[P] | null;
 };
-type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V<VV, GG>>;
-type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
-type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V<VV, GG>;
-type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V<VV, GG>>;
+type Loose<Grp, VV, GG extends string> = Prepare<Grp, GG> & Par<V$1<VV, GG>>;
+type Strict<Grp, VV, GG extends string, EE> = Prepare<Grp, GG> & V$1<VV, GG> & Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
+type V_Grp<VV, GG extends string, Grp> = Rec<GI$1<GG>, Grp> & V$1<VV, GG>;
+type Extra<EE, VV, GG extends string> = Omit<EE, IdAndTsKeys | GI$1<GG> | keyof V$1<VV, GG>>;
 type OrReplace<T, V> = T | Replace<T, V>;
-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>>;
+type MergedInput<Out, VV, Grp, GG extends string, EE> = OrReplace<Replace<Replace<Out, V$1<VV, GG>>, Extra<EE, VV, GG>> & Model, TS & ID & V_Grp<VV, GG, Grp> & Extra<EE, VV, GG>>;
 
 type Denied<GID = never> = keyof (TS & ID) | GID;
 type GI<GG> = Exclude<GG, keyof TS>;
@@ -438,18 +439,21 @@ declare const $groupId: <T extends O, V extends O, EE = {}, Out extends Loose<st
 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">;
 
 type Params<As extends string, LQ extends O, RQ extends O, RE extends RQ, S extends notArr> = {
-    foreignField: Field<RQ, S | Arr<S>>;
     from: SnapshotStreamExecutionResult<RQ, RE>;
     as: AsLiteral<As>;
 } & ({
-    localField: Field<LQ, S>;
-    toMany?: never;
+    to: 'one';
+    localField: Field<LQ, string>;
+    foreignField?: never;
+    middle?: never;
 } | {
-    localField: Field<LQ, Arr<S>>;
-    toMany: true;
+    to: 'many';
+    middle: string;
+    localField: Field<LQ, S | Arr<S>>;
+    foreignField: Field<RQ, S | Arr<S>>;
 });
-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>>;
-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>>;
+declare const $lookup: <As extends string, LQ extends doc, RQ extends doc, 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>>;
+declare const $outerLookup: <As extends string, LQ extends doc, RQ extends doc, 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>>;
 
 declare const $matchDelta: <T extends doc>(query: Expr<boolean, T>) => RawStages<unknown, Delta<T>, Delta<T>, unknown, number>;
 declare const matchDelta: <D>() => RawStages<unknown, Delta<D | null>, Delta<D>>;
@@ -462,14 +466,18 @@ type Updater<in R, in T, out V, in C = unknown> = {
     [Type]?(x: typeof Updater, r: R, t: T, c: C): V;
     readonly raw: <D extends O>(f: Field<D, R | N>) => readonly (readonly [string, rawItem])[];
 };
-interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends HKT<StrKey<V>> {
-    readonly out: Updater<R, Get<Old, I<StrKey<V>, this>, K>, V2[I<StrKey<V>, this>], C>;
+interface UpdaterHKT<R, Old, V, C, K extends keyof Old = keyof Old, V2 extends V = V> extends UpdaterQHKT<R, Old, V2, StrKey<V>, C, K> {
+}
+interface UpdaterQHKT<R, Old, V, KV extends StrKey<V>, C, K extends keyof Old = keyof Old> extends HKT<KV> {
+    readonly out: Updater<R, Get<Old, I<KV, this>, K>, V[I<KV, this>], C>;
 }
 type Get<T, P extends string, K extends keyof T = never> = P extends K ? T[P] : P extends keyof T ? T[P] : undefined;
 declare const set: <V>() => <R, Old extends notArr, C = unknown, K extends keyof Old = never>(fields: MapO<V, UpdaterHKT<R, Old, V, C, K>>) => Updater<R, Old, O & Omit$1<Old, StrKey<V>> & V, C> & Updater<R, Arr<Old>, Arr<Omit$1<Old, StrKey<V>> & V>, C>;
 declare const to: <R, V, C = unknown, T = unknown>(expr: Expr<V, R, C>) => Updater<R, T, V, C>;
 
-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>;
+type V<VV, Q> = Exclude<StrKey<VV>, StrKey<Q>>;
+type $Set<VV extends O, Q extends O> = <R extends Q, C = unknown>(fields: MapO<Omit<VV, StrKey<Q>>, UpdaterQHKT<R, R, VV, V<VV, Q>, C>, V<VV, Q>>) => DeltaStages<Q, R, Q & ReplaceQ<R, VV, Q>, C> & LinStages<Q, R, Q & ReplaceQ<R, VV, Q>, C>;
+declare const $set: <VV extends O, Q extends O = O>() => $Set<VV, Q>;
 declare const $replaceWith: <T extends O, V extends O>(expr: Expr<V, T>) => DeltaStages<O, T, V> & LinStages<O, T, V>;
 
 type s$1 = string;

package/index.esm.js

@@ -864,11 +864,17 @@ const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item'
 const $map = (ex, map) => $map1(ex, i => map(i.expr()));
 
 const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const rawSet = (fields) => (f) => {
+    return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+};
 const set = () => (fields) => ({
-    raw: f => {
-        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
-    },
+    raw: rawSet(fields),
 });
+const setQ = () => {
+    return (fields) => ({
+        raw: rawSet(fields),
+    });
+};
 const weaken = (updater) => ({ raw: f => updater.raw(f) });
 const to = (expr) => ({
     raw: f => [['', expr.raw(f).get()]],
@@ -1628,11 +1634,10 @@ const runCont = async (it, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as, toMany }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft, middle = '.') => {
+const join = (params, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
+    const { lField, rField, left, right, as } = params;
     const rightJoinField = { field1: lField, field2: rField };
-    const joinId = rField.str() === '_id' && toMany !== true
-        ? 'left'
-        : ['left', middle, 'right'];
+    const joinId = params.to === 'one' ? 'left' : ['left', params.middle, 'right'];
     const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
@@ -1670,31 +1675,49 @@ const join = ({ lField, rField, left, right, as, toMany }, leftSnapshot, rightSn
     };
 };
 const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
-const $lookup = (p) => (l) => $lookup1({
-    right: p.from,
-    as: p.as,
-    lField: p.localField,
-    rField: p.foreignField,
-    left: l(emptyDelta()),
-    toMany: p.toMany,
-});
-const $outerLookup = (p) => (l) => $lookup1({
-    right: p.from,
-    as: p.as,
-    lField: p.localField,
-    rField: p.foreignField,
-    left: l(emptyDelta()),
-    toMany: p.toMany,
-}, null);
+const $lookup = (p) => (l) => p.to === 'one'
+    ? $lookup1({
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: root().of('_id'),
+        left: l(emptyDelta()),
+        to: 'one',
+    })
+    : $lookup1({
+        to: 'many',
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: p.foreignField,
+        left: l(emptyDelta()),
+        middle: p.middle,
+    });
+const $outerLookup = (p) => (l) => p.to === 'one'
+    ? $lookup1({
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: root().of('_id'),
+        left: l(emptyDelta()),
+        to: 'one',
+    }, null)
+    : $lookup1({
+        to: 'many',
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: p.foreignField,
+        left: l(emptyDelta()),
+        middle: p.middle,
+    }, null);
 
 const $setCore = (updater) => ({
     delta: $setDelta(updater),
     raw: $set1(updater),
     lin: $set_(updater),
 });
-const $set = () => (fields) => {
-    return $setCore(set()(fields));
-};
+const $set = () => (fields) => $setCore(setQ()(fields));
 const $replaceWith = (expr) => ({
     delta: $replaceWithDelta(expr),
     raw: $replaceWith1(expr),

package/index.js

@@ -866,11 +866,17 @@ const $map1 = (ex, map) => $map0({ input: ex, as: 'item', expr: map(ctx()('item'
 const $map = (ex, map) => $map1(ex, i => map(i.expr()));
 
 const subUpdater = (a, f) => ({ raw: (g) => a.raw(g.with(f)) });
+const rawSet = (fields) => (f) => {
+    return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
+};
 const set = () => (fields) => ({
-    raw: f => {
-        return Object.entries(mapExactToObject0(fields, v => v)).flatMap(([k, v]) => v.raw(f).map(([l, v]) => [`.${k}${l}`, v]));
-    },
+    raw: rawSet(fields),
 });
+const setQ = () => {
+    return (fields) => ({
+        raw: rawSet(fields),
+    });
+};
 const weaken = (updater) => ({ raw: f => updater.raw(f) });
 const to = (expr) => ({
     raw: f => [['', expr.raw(f).get()]],
@@ -1630,11 +1636,10 @@ const runCont = async (it, cb) => {
 };
 
 const merge = ({ lsource: L, rsource: R, }) => mergeIterators({ sources: { L, R } });
-const join = ({ lField, rField, left, right, as, toMany }, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft, middle = '.') => {
+const join = (params, leftSnapshot, rightSnapshot, stagesUntilNextLookup, outerLeft) => {
+    const { lField, rField, left, right, as } = params;
     const rightJoinField = { field1: lField, field2: rField };
-    const joinId = rField.str() === '_id' && toMany !== true
-        ? 'left'
-        : ['left', middle, 'right'];
+    const joinId = params.to === 'one' ? 'left' : ['left', params.middle, 'right'];
     const joinR_Snapshot = asBefore($lookupRaw(rightJoinField, rightSnapshot, as, joinId, outerLeft));
     const resultingSnapshot = concatTStages(leftSnapshot, joinR_Snapshot);
     const dict = { [as]: 'a' };
@@ -1672,31 +1677,49 @@ const join = ({ lField, rField, left, right, as, toMany }, leftSnapshot, rightSn
     };
 };
 const $lookup1 = (p, outerLeft) => (input) => p.left.stages((lStages) => p.right.stages((rStages) => join(p, lStages, rStages, input, outerLeft)));
-const $lookup = (p) => (l) => $lookup1({
-    right: p.from,
-    as: p.as,
-    lField: p.localField,
-    rField: p.foreignField,
-    left: l(emptyDelta()),
-    toMany: p.toMany,
-});
-const $outerLookup = (p) => (l) => $lookup1({
-    right: p.from,
-    as: p.as,
-    lField: p.localField,
-    rField: p.foreignField,
-    left: l(emptyDelta()),
-    toMany: p.toMany,
-}, null);
+const $lookup = (p) => (l) => p.to === 'one'
+    ? $lookup1({
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: root().of('_id'),
+        left: l(emptyDelta()),
+        to: 'one',
+    })
+    : $lookup1({
+        to: 'many',
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: p.foreignField,
+        left: l(emptyDelta()),
+        middle: p.middle,
+    });
+const $outerLookup = (p) => (l) => p.to === 'one'
+    ? $lookup1({
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: root().of('_id'),
+        left: l(emptyDelta()),
+        to: 'one',
+    }, null)
+    : $lookup1({
+        to: 'many',
+        right: p.from,
+        as: p.as,
+        lField: p.localField,
+        rField: p.foreignField,
+        left: l(emptyDelta()),
+        middle: p.middle,
+    }, null);
 
 const $setCore = (updater) => ({
     delta: $setDelta(updater),
     raw: $set1(updater),
     lin: $set_(updater),
 });
-const $set = () => (fields) => {
-    return $setCore(set()(fields));
-};
+const $set = () => (fields) => $setCore(setQ()(fields));
 const $replaceWith = (expr) => ({
     delta: $replaceWithDelta(expr),
     raw: $replaceWith1(expr),

package/package.json

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