@wxn0brp/vql-client 0.0.11 → 0.0.12

package/dist/index.d.ts

@@ -11,6 +11,6 @@ export declare function initVQLClient(config: {
     hooks?: VQLHooks;
     defaultFetchUrl?: string;
 }): void;
-export declare function fetchVQL<T = any>(query: VqlQueryRaw, hookContext?: any): Promise<T>;
+export declare function fetchVQL<T = any>(query: VqlQueryRaw<T>, hookContext?: any): Promise<T>;
 export declare function resetVQLClient(): void;
 export declare function defaultFetchTransport(query: VqlQueryRaw): Promise<any>;

package/dist/vql.d.ts

@@ -1,112 +1,112 @@
 export interface Data {
     [key: string]: any;
 }
-export interface Context {
+export interface VContext {
     [key: string]: any;
 }
-export type Id = string;
-export type LogicalOperators = {
-    $and?: Array<SearchOptions>;
-    $or?: Array<SearchOptions>;
-    $not?: SearchOptions;
+export type KeysMatching<T, V, C = V> = {
+    [K in keyof T]-?: T[K] extends C ? K : never;
+}[keyof T];
+export type PartialOfType<T, V, C = V> = Partial<Record<KeysMatching<T, V, C>, V>>;
+export type PartialPickMatching<T, V, C = V> = Partial<Pick<T, KeysMatching<T, V, C>>>;
+export type LogicalOperators<T = any> = {
+    $and?: Array<SearchOptions<T>>;
+    $or?: Array<SearchOptions<T>>;
+    $not?: SearchOptions<T>;
 };
-export type ComparisonOperators = {
-    $gt?: Record<string, number>;
-    $lt?: Record<string, number>;
-    $gte?: Record<string, number>;
-    $lte?: Record<string, number>;
-    $in?: Record<string, any[]>;
-    $nin?: Record<string, any[]>;
-    $between?: Record<string, [
+export type ComparisonOperators<T = any> = {
+    $gt?: PartialOfType<T, number>;
+    $lt?: PartialOfType<T, number>;
+    $gte?: PartialOfType<T, number>;
+    $lte?: PartialOfType<T, number>;
+    $between?: PartialOfType<T, [
         number,
         number
-    ]>;
+    ], number>;
+    $in?: Partial<Record<keyof T, T[keyof T][]>>;
+    $nin?: Partial<Record<keyof T, T[keyof T][]>>;
 };
-export type TypeAndExistenceOperators = {
-    $exists?: Record<string, boolean>;
-    $type?: Record<string, string>;
+export type TypeAndExistenceOperators<T = any> = {
+    $exists?: PartialOfType<T, boolean, any>;
+    $type?: PartialOfType<T, string>;
 };
-export type ArrayOperators = {
-    $arrinc?: Record<string, any[]>;
-    $arrincall?: Record<string, any[]>;
-    $size?: Record<string, number>;
+export type ArrayOperators<T = any> = {
+    $arrinc?: PartialPickMatching<T, any[]>;
+    $arrincall?: PartialPickMatching<T, any[]>;
+    $size?: PartialOfType<T, number>;
 };
-export type StringOperators = {
-    $regex?: Record<string, RegExp>;
-    $startsWith?: Record<string, string>;
-    $endsWith?: Record<string, string>;
+export type StringOperators<T = any> = {
+    $regex?: PartialOfType<T, RegExp, string>;
+    $startsWith?: PartialOfType<T, string>;
+    $endsWith?: PartialOfType<T, string>;
 };
-export type OtherOperators = {
-    $subset?: Record<string, any>;
+export type OtherOperators<T = any> = {
+    $subset?: Partial<Record<keyof T, T[keyof T]>>;
 };
-export type PredefinedSearchOperators = LogicalOperators & ComparisonOperators & TypeAndExistenceOperators & ArrayOperators & StringOperators & OtherOperators;
-export type SearchOptions = PredefinedSearchOperators & Arg;
-export type ArrayUpdater = {
-    $push?: any;
-    $pushset?: any;
-    $pull?: any;
-    $pullall?: any;
+export type PredefinedSearchOperators<T = any> = LogicalOperators<T> & ComparisonOperators<T> & TypeAndExistenceOperators<T> & ArrayOperators<T> & StringOperators<T> & OtherOperators<T>;
+export type SearchOptions<T = any> = PredefinedSearchOperators<T> & Arg<T>;
+export type ArrayUpdater<T = any> = {
+    $push?: PartialOfType<T, any>;
+    $pushset?: PartialOfType<T, any>;
+    $pull?: PartialOfType<T, any>;
+    $pullall?: PartialOfType<T, any>;
 };
-export type ObjectUpdater = {
-    $merge?: any;
+export type ObjectUpdater<T = any> = {
+    $merge?: PartialOfType<T, any[]>;
 };
-export type ValueUpdater = {
-    $set?: any;
-    $inc?: any;
-    $dec?: any;
-    $unset?: any;
-    $rename?: any;
+export type ValueUpdater<T = any> = {
+    $inc?: PartialOfType<T, number>;
+    $dec?: PartialOfType<T, number>;
+    $unset?: PartialOfType<T, any>;
+    $rename?: PartialOfType<T, any>;
 };
-export type UpdaterArg = ArrayUpdater & ObjectUpdater & ValueUpdater & {
-    [key: string]: any;
-};
-export interface Arg {
-    _id?: Id;
-    [key: string]: any;
-}
-export type SearchFunc<T = any> = (data: T, context: Context) => boolean;
-export type UpdaterFunc<T = any> = (data: T, context: Context) => boolean;
-export type Search<T = any> = SearchOptions | SearchFunc<T>;
-export type Updater<T = any> = UpdaterArg | UpdaterArg[] | UpdaterFunc<T>;
-export interface DbFindOpts {
+export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & Arg<T>;
+export type Arg<T = any> = {
+    [K in keyof T]?: any;
+} & Record<string, any>;
+export type SearchFunc<T = any> = (data: T, context: VContext) => boolean;
+export type UpdaterFunc<T = any> = (data: T, context: VContext) => boolean;
+export type Search<T = any> = SearchOptions<T> | SearchFunc<T>;
+export type Updater<T = any> = UpdaterArg<T> | UpdaterArg<T>[] | UpdaterFunc<T>;
+export interface DbFindOpts<T = any> {
     reverse?: boolean;
     max?: number;
     offset?: number;
-    sortBy?: string;
+    sortBy?: KeysMatching<T, any>;
     sortAsc?: boolean;
 }
-export interface FindOpts {
-    select?: string[];
-    exclude?: string[];
+export interface FindOpts<T = any> {
+    select?: KeysMatching<T, any>[];
+    exclude?: KeysMatching<T, any>[];
     transform?: Function;
 }
+declare class CollectionManager {
+    private db;
+    private collection;
+    constructor(db: ValtheraCompatible, collection: string);
+    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
+    find<T = Data>(search: Search, context?: VContext, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
+    findOne<T = Data>(search: Search, context?: VContext, findOpts?: FindOpts): Promise<T>;
+    update(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    updateOne(search: Search, updater: Updater, context?: VContext): Promise<boolean>;
+    remove(search: Search, context?: VContext): Promise<boolean>;
+    removeOne(search: Search, context?: VContext): Promise<boolean>;
+    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: VContext, id_gen?: boolean): Promise<boolean>;
+}
 export interface ValtheraCompatible {
     c(collection: string): CollectionManager;
     getCollections(): Promise<string[]>;
     checkCollection(collection: string): Promise<boolean>;
     issetCollection(collection: string): Promise<boolean>;
-    add<T = Data>(collection: string, data: Arg, id_gen?: boolean): Promise<T>;
-    find<T = Data>(collection: string, search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
-    findOne<T = Data>(collection: string, search: Search, context?: Context, findOpts?: FindOpts): Promise<T | null>;
-    update(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    updateOne(collection: string, search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    remove(collection: string, search: Search, context?: Context): Promise<boolean>;
-    removeOne(collection: string, search: Search, context?: Context): Promise<boolean>;
+    add<T = Data>(collection: string, data: Arg<T>, id_gen?: boolean): Promise<T>;
+    find<T = Data>(collection: string, search: Search<T>, context?: VContext, options?: DbFindOpts<T>, findOpts?: FindOpts<T>): Promise<T[]>;
+    findOne<T = Data>(collection: string, search: Search<T>, context?: VContext, findOpts?: FindOpts<T>): Promise<T | null>;
+    update<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
+    updateOne<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, context?: VContext): Promise<boolean>;
+    remove<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
+    removeOne<T = Data>(collection: string, search: Search<T>, context?: VContext): Promise<boolean>;
     removeCollection(collection: string): Promise<boolean>;
-    updateOneOrAdd(collection: string, search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
-}
-declare class CollectionManager {
-    private db;
-    private collection;
-    constructor(db: ValtheraCompatible, collection: string);
-    add<T = Data>(data: Arg, id_gen?: boolean): Promise<T>;
-    find<T = Data>(search: Search, context?: Context, options?: DbFindOpts, findOpts?: FindOpts): Promise<T[]>;
-    findOne<T = Data>(search: Search, context?: Context, findOpts?: FindOpts): Promise<T>;
-    update(search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    updateOne(search: Search, updater: Updater, context?: Context): Promise<boolean>;
-    remove(search: Search, context?: Context): Promise<boolean>;
-    removeOne(search: Search, context?: Context): Promise<boolean>;
-    updateOneOrAdd(search: Search, updater: Updater, add_arg?: Arg, context?: Context, id_gen?: boolean): Promise<boolean>;
+    updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
 }
 declare namespace RelationTypes {
     type Path = [
@@ -137,39 +137,39 @@ declare namespace RelationTypes {
         };
     }
 }
-export type VQLQuery = {
-    find: VQLFind;
-    findOne: VQLFindOne;
-    f: VQLFindOne;
-    add: VQLAdd;
-    update: VQLUpdate;
-    updateOne: VQLUpdateOne;
-    remove: VQLRemove;
-    removeOne: VQLRemoveOne;
-    updateOneOrAdd: VQLUpdateOneOrAdd;
+export interface VQLQuery<T = any> {
+    find: VQLFind<T>;
+    findOne: VQLFindOne<T>;
+    f: VQLFindOne<T>;
+    add: VQLAdd<T>;
+    update: VQLUpdate<T>;
+    updateOne: VQLUpdateOne<T>;
+    remove: VQLRemove<T>;
+    removeOne: VQLRemoveOne<T>;
+    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
     removeCollection: VQLCollectionOperation;
     checkCollection: VQLCollectionOperation;
     issetCollection: VQLCollectionOperation;
     getCollections: {};
-};
-export type VQLQueryData = {
-    find: VQLFind;
+}
+export type VQLQueryData<T = any> = {
+    find: VQLFind<T>;
 } | {
-    findOne: VQLFindOne;
+    findOne: VQLFindOne<T>;
 } | {
-    f: VQLFindOne;
+    f: VQLFindOne<T>;
 } | {
-    add: VQLAdd;
+    add: VQLAdd<T>;
 } | {
-    update: VQLUpdate;
+    update: VQLUpdate<T>;
 } | {
-    updateOne: VQLUpdateOne;
+    updateOne: VQLUpdateOne<T>;
 } | {
-    remove: VQLRemove;
+    remove: VQLRemove<T>;
 } | {
-    removeOne: VQLRemoveOne;
+    removeOne: VQLRemoveOne<T>;
 } | {
-    updateOneOrAdd: VQLUpdateOneOrAdd;
+    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 } | {
     removeCollection: VQLCollectionOperation;
 } | {
@@ -179,56 +179,56 @@ export type VQLQueryData = {
 } | {
     getCollections: {};
 };
-export interface VQLRequest {
+export interface VQLRequest<T = any> {
     db: string;
-    d: VQLQueryData;
+    d: VQLQueryData<T>;
 }
-export interface VQLFind {
+export interface VQLFind<T = any> {
     collection: string;
-    search?: Search;
+    search?: Search<T>;
     limit?: number;
     fields?: VQLFields;
     select?: VQLFields;
     relations?: VQLRelations;
-    options?: DbFindOpts;
-    searchOpts?: FindOpts;
+    options?: DbFindOpts<T>;
+    searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne {
+export interface VQLFindOne<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
     fields?: VQLFields;
     select?: VQLFields;
     relations?: VQLRelations;
-    searchOpts?: FindOpts;
+    searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd {
+export interface VQLAdd<T = any> {
     collection: string;
-    data: Arg;
+    data: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLUpdate {
+export interface VQLUpdate<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne {
+export interface VQLUpdateOne<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
 }
-export interface VQLRemove {
+export interface VQLRemove<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
 }
-export interface VQLRemoveOne {
+export interface VQLRemoveOne<T = any> {
     collection: string;
-    search: Search;
+    search: Search<T>;
 }
-export interface VQLUpdateOneOrAdd {
+export interface VQLUpdateOneOrAdd<T = any> {
     collection: string;
-    search: Search;
-    updater: UpdaterArg;
-    add_arg?: Arg;
+    search: Search<T>;
+    updater: UpdaterArg<T>;
+    add_arg?: Arg<T>;
     id_gen?: boolean;
 }
 export interface VQLCollectionOperation {
@@ -256,15 +256,15 @@ export type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
 export type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
 };
-export type VQL = (VQLRequest | RelationQuery) & VQLRef;
-export type VQLR = VQL | (DeepPartial<VQL> & VQLRefRequired) | VQLRefRequired;
+export type VQL<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
+export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
 export interface VQLError {
     err: true;
     msg: string;
     c: number;
     why?: string;
 }
-export type VqlQueryRaw = VQLR | string | {
+export type VqlQueryRaw<T = any> = VQLR<T> | string | {
     query: string;
 } & VQLRef;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql-client",
-  "version": "0.0.11",
+  "version": "0.0.12",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "wxn0brP",