@omegup/msync 0.1.61 → 0.1.63

package/lib/utils/coll.d.ts

@@ -1,5 +1,5 @@
-import type { ReadonlyCollection, WriteonlyCollection } from '../../types';
+import type { RawObj, ReadonlyCollection, WriteonlyCollection } from '../../types';
 export declare const dbcoll: (x: ReadonlyCollection<unknown> | WriteonlyCollection<never>) => {
     db: string;
     coll: string;
-};
+} & RawObj;

package/lib/utils/db-indexes.d.ts

@@ -1,7 +1,7 @@
-import type { Collection, CreateIndexesOptions, Db, IndexSpecification } from 'mongodb';
+import type { Collection, CreateIndexesOptions, Db, IndexSpecification } from '../../types';
 export declare const indexMap: Map<string, Map<string, Promise<void>>>;
 export declare const createIndex: (collection: {
-    readonly createIndex: Collection["createIndex"];
+    readonly createIndex: Collection['createIndex'];
     collectionName: string;
 }, indexSpec: IndexSpecification, op?: CreateIndexesOptions) => Promise<void>;
 export declare const ensureCollection: (db: Db, collectionName: string) => Promise<void>;

package/lib/utils/guard.d.ts

@@ -1,4 +1,4 @@
-import type { App, AsLiteral, HKT, jsonItem, N, Par, Rec, RORec } from '../../types';
+import type { App, AsLiteral, HKT, N } from '../../types';
 export type Equal<Dom, T extends Dom, V extends Dom> = {
     forward: <F extends HKT<Dom>>(x: App<F, T>) => App<F, V>;
     forward1: (x: T) => V;
@@ -7,15 +7,5 @@ export type Equal<Dom, T extends Dom, V extends Dom> = {
 };
 export declare const sym: <Dom, T extends Dom, V extends Dom>(eq: Equal<Dom, T, V>) => Equal<Dom, V, T>;
 export declare const reflex: <Dom, T extends Dom>() => Equal<Dom, T, T>;
-export declare const eqExtends: <Im, T, U, F extends HKT<T, Im>, G extends HKT<T, Im>, H extends HKT<T, Im>, M extends Im>(_1: Equal<Im, App<F, T & U>, M | App<G, T & U>>, _2: Equal<Im, App<F, Exclude<T, U>>, M | App<H, Exclude<T, U>>>) => Equal<Im, App<F, T>, M | (T extends U ? App<G, T> : App<H, T>)>;
-export declare const fromEq: <Dom, T extends Dom, V extends Dom>(eq: Pick<Equal<Dom, T, V>, "forward" | "backward">) => Equal<Dom, T, V>;
+export declare const fromEq: <Dom, T extends Dom, V extends Dom>(eq: Pick<Equal<Dom, T, V>, 'forward' | 'backward'>) => Equal<Dom, T, V>;
 export declare const literalsEqaul: <T extends keyof any | boolean | N, V extends T>(_: AsLiteral<T> & V) => Equal<T, T, V>;
-export declare const omitRORec: <K extends string, E extends string, R extends string, T extends unknown>() => Equal<unknown, RORec<Exclude<K, E | R>, T>, Omit<RORec<Exclude<K, E | R>, T>, R>>;
-type s = keyof any;
-export declare const omitPick: <K extends s, E extends s, R extends s, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Pick<T, Exclude<K, E | R>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
-export declare const omitExclude: <K extends s, E extends s, R extends s, T extends RORec<Exclude<K, E | R>, unknown>>() => Equal<unknown, Omit<T, E & Exclude<K, keyof T>>, Omit<Pick<T, Exclude<K, E | R>>, R>>;
-export declare const renamedFields: <K extends s, F extends HKT<K, s>, G extends HKT<App<F, K>>>() => Equal<string | number | symbol, keyof { [P in K as App<F, P>]: App<G, P>; }, App<F, K>>;
-export declare const translateOmit: <T, K extends string, Q extends string, P extends string>() => Equal<unknown, Omit<Omit<T, K | Q>, P>, Omit<Omit<T, K | Q>, Q | P>>;
-export declare const excludeIdem: <K extends s, E extends s, S extends E = E>() => Equal<Exclude<K, E>, Exclude<K, E>, Exclude<Exclude<K, E>, S>>;
-export declare const eqPar: <K extends string, T extends Rec<K, jsonItem>, K2 extends K>() => Equal<unknown, Par<K2, T>, Par<K, T>>;
-export {};

package/lib/utils/json.d.ts

@@ -1,4 +1,5 @@
 import type { AsLiteral, Rec } from '../../types';
+export declare const safeNarrow: <V>() => <T>(x: T & V) => T & V;
 export declare const id: <T>(x: T) => T;
 export declare const defined: <T>(x: T | undefined | null) => x is T;
 export declare const noop: () => void;

package/lib/utils/map-object.d.ts

@@ -1,13 +1,9 @@
-import type { App, HKT, I, IdHKT, RORec, StrKey } from '../../types';
-export declare const map: <T, K extends string & keyof T, V extends RORec<K, unknown>>(x: Pick<T, K>, f: <P extends K>(v: T[P], k: P) => V[P]) => V;
+import type { App, HKT, I, IdHKT, Omit, RORec, StrKey } from '../../types';
 export type ExactPart<T, F extends HKT<T[StrKey<T>]>> = MapOPart<T, MappedHKT<T, F>>;
 export type ExactPart1<T, F extends HKT<StrKey<T>>> = {
     readonly [K in StrKey<T>]: App<F, K>;
 };
 type s = string;
-export type MapKDom<RK extends MapKDom<RK, F>, F extends HKT<StrKey<RK>>> = MapO<RK, F> & {
-    readonly [P in s]?: readonly [keyof RK, unknown];
-};
 export type ExactKeys<K extends string> = Exact<RORec<K, 1>, IdHKT>;
 export type MapO<T, F extends HKT<K>, K extends StrKey<T> = StrKey<T>> = MapOPart<T, F, K> & {
     readonly [P: string]: readonly [K, unknown];

package/lib/utils/merge/merge.d.ts

@@ -1,10 +1,11 @@
+import type { PRRec } from '../../../types';
 import type { Frame, IteratorResult, HasJob } from '../../types';
 import type { KEYS, Race, SourceIteratorResults, SourceResults } from './types';
-export declare const mergeIterators: <K extends KEYS, Result, Info extends Record<K, HasJob>>(params: {
+export declare const mergeIterators: <K extends KEYS, Result, Info extends PRRec<K, HasJob>>(params: {
     sources: SourceIteratorResults<K, Result, Info>;
-    interrupt?: (key: KEYS) => boolean;
-    select?: Race<K, Result, Info>;
+    interrupt?: ((key: KEYS) => boolean) | undefined;
+    select?: Race<K, Result, Info> | undefined;
     hooks?: {
         start?: (frame: Frame<Result, Info[K]>, result: IteratorResult<Result, Info[K]>) => void;
-    };
+    } | undefined;
 }) => IteratorResult<Result, SourceResults<K, Info>>;

package/lib/utils/merge/next-winner.d.ts

@@ -1,3 +1,4 @@
+import type { PRRec } from '../../../types';
 import type { NextFrame, HasJob } from '../../types';
 import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
-export declare const nextWinner: <K extends KEYS, Result, Info extends Record<K, HasJob>>(previousWinner: RaceWinner<K, Result, Info>, previousWinnerNextFrame: NextFrame<Result, Info[K]>, sources: SourceIteratorResults<K, Result, Info>, interrupt?: (key: KEYS) => boolean) => PromiseLike<RaceWinner<K, Result, Info>>;
+export declare const nextWinner: <K extends KEYS, Result, Info extends PRRec<K, HasJob>>(previousWinner: RaceWinner<K, Result, Info>, previousWinnerNextFrame: NextFrame<Result, Info[K]>, sources: SourceIteratorResults<K, Result, Info>, interrupt?: (key: KEYS) => boolean) => PromiseLike<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/types.d.ts

@@ -1,19 +1,23 @@
+import type { PRRec } from '../../../types';
 import type { Frame, IteratorResult, HasJob } from '../../types';
 export type KEYS = string;
-export type SourceIteratorResults<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+export type SourceIteratorResults<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
+    readonly [P in K]?: IteratorResult<Result, Info[P]>;
+};
+export type RSourceIteratorResults<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
     readonly [P in K]: IteratorResult<Result, Info[P]>;
 };
-export type SourceResults<K extends KEYS, Info extends Record<K, HasJob>> = {
+export type SourceResults<K extends KEYS, Info extends PRRec<K, HasJob>> = {
     readonly [P in K]: {
         readonly key: P;
         readonly value: Info[P];
-        readonly job: Info[P]['job'];
+        readonly job: (Info[P] & {})['job'];
     };
 }[K];
-export type RaceWinner<K extends KEYS, Result, Info extends Record<K, unknown>> = {
+export type RaceWinner<K extends KEYS, Result, Info extends PRRec<K, unknown>> = {
     readonly [P in K]: {
         readonly key: P;
         readonly frame: Frame<Result, Info[P]>;
     };
 }[K];
-export type Race<K extends KEYS, Result, Info extends Record<K, HasJob>> = (arg: SourceIteratorResults<K, Result, Info>) => PromiseLike<RaceWinner<K, Result, Info>>;
+export type Race<K extends KEYS, Result, Info extends PRRec<K, HasJob>> = (arg: SourceIteratorResults<K, Result, Info>) => PromiseLike<RaceWinner<K, Result, Info>>;

package/lib/utils/merge/utils.d.ts

@@ -1,4 +1,6 @@
+import type { PRRec } from '../../../types';
 import type { KEYS, RaceWinner, SourceIteratorResults } from './types';
+export declare const map: <T, K extends string & keyof T & keyof V, V>(x: Pick<T, K>, f: <P extends K>(v: Required<T>[P], k: P) => V[P]) => V;
 export declare const patch: <T, K extends keyof T>({ ...x }: T, k: K, v: T[K]) => T;
-export declare const restart: <K extends KEYS, Result, Info extends Record<K, unknown>>(sources: SourceIteratorResults<K, Result, Info>) => SourceIteratorResults<K, Result, Info>;
-export declare const race: <W, K extends KEYS, Result, Info extends Record<K, W>>(sources: SourceIteratorResults<K, Result, Info>) => Promise<RaceWinner<K, Result, Info>>;
+export declare const restart: <K extends KEYS, Result, Info extends PRRec<K, unknown>>(sources: SourceIteratorResults<K, Result, Info>) => SourceIteratorResults<K, Result, Info>;
+export declare const race: <W, K extends KEYS, Result, Info extends PRRec<K, W>>(sources: SourceIteratorResults<K, Result, Info>) => Promise<RaceWinner<K, Result, Info>>;

package/lib/watch.d.ts

@@ -1,12 +1,11 @@
-import { type Db, Timestamp } from 'mongodb';
-import type { O, StrKey, View } from '../types';
+import type { Db, Dict, Document, O, StrKey, Timestamp, View } from '../types';
 import type { Field } from './field';
 import type { Model, Query } from './types';
 export type OplogEntry = {
     ts: Timestamp;
     ns: string;
     op: 'i' | 'u' | 'd' | 'c' | 'n';
-    o: Record<string, unknown>;
+    o: Dict<unknown>;
     o2?: {
         _id: string;
     };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@omegup/msync",
-    "version": "0.1.61",
+    "version": "0.1.63",
     "description": "Keeps derived MongoDB data in sync with the documents it comes from.",
     "repository": {
         "type": "git",
@@ -14,10 +14,29 @@
     "main": "index.js",
     "module": "index.esm.js",
     "typings": "index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./index.d.ts",
+            "import": "./index.esm.js",
+            "require": "./index.js"
+        },
+        "./adapters/mongodb": {
+            "types": "./adapters/mongodb.d.ts",
+            "import": "./adapters/mongodb.esm.js",
+            "require": "./adapters/mongodb.js"
+        }
+    },
     "dependencies": {
         "dayjs": "^1.11.9",
         "dotenv": "^16.3.1",
-        "json-canonicalize": "^2.0.0",
+        "json-canonicalize": "^2.0.0"
+    },
+    "peerDependencies": {
         "mongodb": "^6.8.0"
+    },
+    "peerDependenciesMeta": {
+        "mongodb": {
+            "optional": true
+        }
     }
 }

package/types/global-aug.d.ts

@@ -4,7 +4,7 @@ import type { AsNum, GetDom } from './global';
 export {};
 declare global {
     type Entry<T, K extends keyof T = keyof T> = readonly [string, T[string & K]] & {
-        [k in K]: readonly [string & k, T[k]];
+        [k in K]?: readonly [string & k, T[k]];
     }[K];
     interface ObjectConstructor {
         entries<T, _ = 0>(object?: T): readonly Entry<T>[];

package/types/global.d.ts

@@ -1,2 +1,4 @@
 export type AsNum<R> = R extends `${infer A extends number}` ? A : never;
 export type GetDom<Dom = unknown> = readonly [readonly Dom[], keyof any];
+export type Exclude<T, U> = T & not U;
+export type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

package/types/json.d.ts

@@ -1,5 +1,6 @@
-import type { Timestamp } from 'mongodb';
 import type { Type } from './class';
+import type { Timestamp } from './mongo';
+import type { Omit } from './global';
 export type { Type } from './class';
 export type U = undefined;
 export type N = null | U;
@@ -18,8 +19,8 @@ export interface JsonArr {
 export type A = {
     [Type]: typeof array;
 };
-export type Arr<T, N extends number = number> = A & {
-    readonly [_ in N]: T;
+export type Arr<T> = A & {
+    readonly [_: number]: T;
 };
 type Obj = {
     [Type]: typeof object;
@@ -31,6 +32,9 @@ export type RORec<K extends keyof never, T = unknown> = {
 export type PRRec<K extends keyof never, T = unknown> = {
     [P in K]?: T;
 };
+export type Dict<T> = {
+    [P: string]: T;
+};
 export type Par<K extends string, V extends Rec<K, jsonItem>> = {
     readonly [k in K]?: V[k] | N;
 };
@@ -48,7 +52,12 @@ export type raw = readonly rawItem[] | RawObj;
 export type StrKey<T> = string & keyof T;
 export type Replace<R, V> = Omit<R, StrKey<V>> & V & O;
 export type ReplaceQ<R extends Q, VV, Q extends O> = Omit<R, StrKey<VV>> & Omit<VV, StrKey<Q>> & Q;
-export type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? {} extends {
+type AnyKeyed = {
+    [x: string]: never;
+    [x: number]: never;
+    [x: symbol]: never;
+};
+export type AsLiteral<T extends keyof any | boolean | N, V = NoUnion<T>> = T extends keyof any ? [Record<string, 1>] extends [never] ? [Record<T, 1>] extends [never] ? never : V : AnyKeyed extends {
     [K in T]: 1;
 } ? never : V : V;
 type NoUnion<T, V = T> = T extends T ? ([V] extends [T] ? T : never) : never;

package/types/mongo.d.ts

@@ -1,24 +1,84 @@
-import 'mongodb';
-import { BSON } from 'mongodb';
+import type { PRRec } from './json';
 export declare const RawStage: unique symbol;
-declare module 'mongodb' {
-    interface Collection<TSchema extends BSON.Document = BSON.Document> {
-        [RawStage]: {
-            (_: 2): TSchema;
-            (_: 1, x: TSchema): TSchema;
-        };
-        s: {
-            db: Db;
-        };
-    }
-    interface Db {
-        s: {
-            client?: MongoClient;
-        };
-        client: MongoClient;
-    }
-    interface Timestamp {
-        toExtendedJSON(): BSON.TimestampExtended;
-    }
-}
-export * from 'mongodb';
+export type Document = object;
+export type Filter<T> = PRRec<keyof T & string, unknown> & Document;
+export type UpdateFilter<T> = {
+    $set?: PRRec<keyof T & string, unknown>;
+} & Document;
+export interface Timestamp {
+    readonly _bsontype: 'Timestamp';
+    readonly high: number;
+    readonly low: number;
+    comp(other: unknown): number;
+}
+export interface UUID {
+    toString(encoding: 'base64'): string;
+}
+export interface Driver {
+    Timestamp: {
+        new (value: bigint): Timestamp;
+        new (value: {
+            t: number;
+            i: number;
+        }): Timestamp;
+    };
+    UUID: new () => UUID;
+}
+export interface Cursor<T> extends AsyncIterable<T> {
+    next(): Promise<T | null>;
+    toArray(): Promise<T[]>;
+    close(): Promise<void>;
+}
+export type IndexSpecification = Document;
+export type CreateIndexesOptions = Document & {
+    name?: string;
+    partialFilterExpression?: Document;
+};
+export type UpdateOptions = {
+    upsert?: boolean;
+};
+export interface Commander {
+    command<T extends object = PRRec<string, unknown>>(command: Document): Promise<T>;
+}
+export interface Client {
+    db(name: string): Db;
+}
+export interface Db extends Commander {
+    readonly s: {
+        readonly client?: Client;
+    };
+    readonly client: Client;
+    readonly namespace: string;
+    admin(): Commander;
+    collection<T = Document>(name: string): Collection<T>;
+    createCollection(name: string): Promise<unknown>;
+    listCollections(filter: Document, options: {
+        nameOnly: true;
+    }): Cursor<{
+        name: string;
+    }>;
+}
+export interface Collection<TSchema = Document> {
+    readonly s: {
+        readonly db: Db;
+    };
+    readonly collectionName: string;
+    readonly namespace: string;
+    readonly dbName: string;
+    [RawStage]: {
+        (_: 2): TSchema;
+        (_: 1, x: TSchema): TSchema;
+    };
+    createIndex(spec: IndexSpecification, options?: CreateIndexesOptions): Promise<string>;
+    findOne(filter: Document): Promise<TSchema | null>;
+    find(filter: Document, options?: Document): Cursor<TSchema>;
+    updateOne(filter: Document, update: Document | readonly Document[], options?: UpdateOptions): Promise<unknown>;
+    updateMany(filter: Document, update: Document | readonly Document[]): Promise<unknown>;
+    deleteOne(filter: Document): Promise<unknown>;
+    deleteMany(filter: Document): Promise<unknown>;
+    drop(): Promise<unknown>;
+}
+export type WatchStream<T = {}> = {
+    close(): Promise<void>;
+    tryNext(): Promise<T | null>;
+};

package/types/view.d.ts

@@ -1,8 +1,7 @@
-import type { Collection, Db } from 'mongodb';
 import type { Del, Expr, Model, Query } from '../lib/types';
 import type { ExactKeys } from '../lib/utils/map-object';
 import type { O, StrKey } from './json';
-import type { RawStage } from './mongo';
+import type { Collection, Db, RawStage } from './mongo';
 interface CommonCollection {
     readonly s: {
         readonly db: Db;

package/test/mongodb.d.ts

@@ -1,9 +0,0 @@
-import { Collection, MongoClient } from 'mongodb';
-import type { AsynIter, Iterator } from '../lib/types';
-import type { ID, doc } from '../types';
-import type { Db, OptionalUnlessRequiredId } from 'mongodb';
-export declare const run: <T, Info>(cont: Iterator<T, Info>) => Promise<never>;
-export declare const iterate: <T>([, next]: AsynIter<T>) => PromiseLike<never>;
-export declare const enablePreAndPostImages: <T extends doc>(coll: Collection<T>) => Promise<import("mongodb").Document>;
-export declare const prepare: (testName?: string) => Promise<MongoClient>;
-export declare const makeCol: <T extends ID>(docs: readonly OptionalUnlessRequiredId<T>[], database: Db, name?: string) => Promise<Collection<T>>;

package/test/uri.d.ts

@@ -1 +0,0 @@
-export declare const uri: string;