@omegup/msync 0.0.4 → 0.0.5

package/types/json.d.ts

@@ -0,0 +1,54 @@
+import type { Timestamp } from 'mongodb';
+import { Type } from './class';
+export { Type } from './class';
+export type U = undefined;
+export type N = null | U;
+export type jsonPrim = number | null | string | boolean | Timestamp | Date;
+export type notObj = jsonPrim | U;
+export type notArr = notObj | O;
+export type jsonItem = unknown;
+export type rawItem = jsonPrim | raw | U;
+export type Undef<I extends N> = I | (I extends never ? I : notObj);
+export declare const object: unique symbol;
+export declare const array: unique symbol;
+export interface JsonArr {
+    [Type]: typeof array;
+    readonly [_: number]: jsonItem | U;
+}
+export type A = {
+    [Type]: typeof array;
+};
+export type Arr<T, N extends number = number> = A & {
+    readonly [_ in N]: T;
+};
+type Obj = {
+    [Type]: typeof object;
+};
+export type O<T = unknown> = Obj & T;
+export type RORec<K extends keyof never, T = unknown> = {
+    readonly [P in K]: T;
+};
+export type Par<K extends string, V extends Rec<K, jsonItem>> = {
+    readonly [k in K]?: V[k] | N;
+};
+export type Rec<K extends string, T = unknown> = O<RORec<K, T>>;
+export type O2 = readonly [O, O];
+export type O3 = readonly [O, O, O];
+export type ID = {
+    readonly _id: string;
+};
+export type doc = O & ID;
+export interface RawObj {
+    readonly [_: string]: rawItem | U;
+}
+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 AsLiteral<T extends keyof any | boolean, V = NoUnion<T>> = T extends keyof any ? {} extends {
+    [K in T]: 1;
+} ? never : V : V;
+type NoUnion<T, V = T> = T extends unknown ? ([V] extends [T] ? T : never) : never;
+export type Literal<K> = string extends K ? never : K;
+export type RemoveSignature<T> = {
+    [K in keyof T as Literal<K>]: T[K];
+};

package/types/mongo.d.ts

@@ -0,0 +1,24 @@
+import 'mongodb';
+import { BSON } from 'mongodb';
+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';

package/types/view.d.ts

@@ -0,0 +1,35 @@
+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';
+interface CommonCollection {
+    readonly s: {
+        readonly db: Db;
+    };
+    collectionName: string;
+    namespace: string;
+    dbName: string;
+    createIndex: Collection['createIndex'];
+}
+export interface ReadonlyCollection<out Out> extends CommonCollection {
+    [RawStage](_: 2): Out;
+}
+export interface WriteonlyCollection<in R> extends CommonCollection {
+    [RawStage]: {
+        (_: 1, x: R): unknown;
+    };
+}
+export interface RWCollection<in R extends O, out Out extends O = R> extends CommonCollection {
+    [RawStage](_: 2): Out;
+    [RawStage](_: 1, x: R): unknown;
+}
+export type OPick<V, K extends StrKey<V>, E extends StrKey<V> = never> = O & Pick<V, K | E>;
+export type OPickD<V extends Model, K extends StrKey<V>> = OPick<V, K, 'deletedAt' | '_id'>;
+export type View<V extends Model, K extends StrKey<V>> = {
+    collection: ReadonlyCollection<V | Del>;
+    projection: ExactKeys<K>;
+    match?: Expr<boolean, OPickD<V, K>>;
+    hardMatch?: Query<V>;
+};
+export {};