@wxn0brp/vql 0.6.2 → 0.6.4

package/dist/apiAbstract.d.ts

@@ -45,17 +45,20 @@ export interface ValtheraResolver {
 export declare function createValtheraAdapter(resolver: ValtheraResolver, extendedFind?: boolean): ValtheraCompatible;
 export type Operation = "add" | "find" | "findOne" | "update" | "updateOne" | "updateOneOrAdd" | "remove" | "removeOne" | "removeCollection";
 export declare class AdapterBuilder {
+    private catchCb;
     private handlers;
     private collections;
-    register(op: "add", collection: string, fn: ResolverFn<[collection: string, data: any, id_gen?: boolean], any>): any;
-    register(op: "find", collection: string, fn: ResolverFn<[collection: string, search: any, context?: any, options?: any, findOpts?: any], any[]>): any;
-    register(op: "findOne", collection: string, fn: ResolverFn<[collection: string, search: any, context?: any, findOpts?: any], any | null>): any;
-    register(op: "update", collection: string, fn: ResolverFn<[collection: string, search: any, updater: any], boolean>): any;
-    register(op: "updateOne", collection: string, fn: ResolverFn<[collection: string, search: any, updater: any], boolean>): any;
-    register(op: "updateOneOrAdd", collection: string, fn: ResolverFn<[collection: string, search: any, updater: any, add_arg?: any, context?: any, id_gen?: boolean], boolean>): any;
-    register(op: "remove", collection: string, fn: ResolverFn<[collection: string, search: any], boolean>): any;
-    register(op: "removeOne", collection: string, fn: ResolverFn<[collection: string, search: any], boolean>): any;
-    register(op: "removeCollection", collection: string, fn: ResolverFn<[collection: string], boolean>): any;
+    constructor(catchCb?: (e: any, op: string, args: any[]) => void);
+    register(op: Operation, collection: string, fn: Function): this;
+    add(collection: string, fn: ResolverFn<[data: any, id_gen?: boolean], any>): this;
+    find(collection: string, fn: ResolverFn<[search: any, context?: any, options?: any, findOpts?: any], any[]>): this;
+    findOne(collection: string, fn: ResolverFn<[search: any, context?: any, findOpts?: any], any | null>): this;
+    update(collection: string, fn: ResolverFn<[collection: string, search: any, updater: any], boolean>): this;
+    updateOne(collection: string, fn: ResolverFn<[search: any, updater: any], boolean>): this;
+    updateOneOrAdd(collection: string, fn: ResolverFn<[search: any, updater: any, add_arg?: any, context?: any, id_gen?: boolean], boolean>): this;
+    remove(collection: string, fn: ResolverFn<[search: any], boolean>): this;
+    removeOne(collection: string, fn: ResolverFn<[search: any], boolean>): this;
+    removeCollection(collection: string, fn: ResolverFn<[], boolean>): this;
     getAdapter(extendedFind?: boolean): ValtheraCompatible;
 }
 export {};

package/dist/apiAbstract.js

@@ -1,5 +1,12 @@
 import CollectionManager from "@wxn0brp/db-core/helpers/CollectionManager";
 import updateFindObject from "@wxn0brp/db-core/utils/updateFindObject";
+const list = [
+    "ensureCollection", "issetCollection", "getCollections", "removeCollection",
+    "add",
+    "find", "findOne",
+    "update", "updateOne", "updateOneOrAdd",
+    "remove", "removeOne"
+];
 export function createValtheraAdapter(resolver, extendedFind = false) {
     const safe = (fn) => {
         if (!fn)
@@ -9,21 +16,11 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
     const adapter = {
         // @ts-ignore
         meta: resolver.meta ?? { type: "api", version: "0.0.1" },
-        c: null,
-        getCollections: () => safe(resolver.getCollections)(),
-        issetCollection: (c) => safe(resolver.issetCollection)(c),
-        ensureCollection: (c) => safe(resolver.ensureCollection)(c),
-        add: (col, data, id_gen) => safe(resolver.add)(col, data, id_gen),
-        find: (col, search, context, options, findOpts) => safe(resolver.find)(col, search, context, options, findOpts),
-        findOne: (col, search, context, findOpts) => safe(resolver.findOne)(col, search, context, findOpts),
-        update: (col, search, up) => safe(resolver.update)(col, search, up),
-        updateOne: (col, search, up) => safe(resolver.updateOne)(col, search, up),
-        updateOneOrAdd: (col, search, up, add_data, ctx, id_gen) => safe(resolver.updateOneOrAdd)(col, search, up, add_data, ctx, id_gen),
-        remove: (col, search) => safe(resolver.remove)(col, search),
-        removeOne: (col, search) => safe(resolver.removeOne)(col, search),
-        removeCollection: (col) => safe(resolver.removeCollection)(col),
     };
     adapter.c = (collection) => new CollectionManager(adapter, collection);
+    for (const name of list) {
+        adapter[name] = (...args) => safe(resolver[name])(...args);
+    }
     if (extendedFind) {
         adapter.find = async (col, search, context, options, findOpts) => {
             let data = await safe(resolver.find)(col, search, context, options, findOpts);
@@ -44,19 +41,58 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
     return adapter;
 }
 export class AdapterBuilder {
+    catchCb;
     handlers = new Map();
     collections = new Set();
+    constructor(catchCb = (e) => { console.log(e); }) {
+        this.catchCb = catchCb;
+    }
     register(op, collection, fn) {
         this.handlers.set(`${op}:${collection}`, fn);
         this.collections.add(collection);
         return this;
     }
+    add(collection, fn) {
+        return this.register("add", collection, fn);
+    }
+    find(collection, fn) {
+        return this.register("find", collection, fn);
+    }
+    findOne(collection, fn) {
+        return this.register("findOne", collection, fn);
+    }
+    update(collection, fn) {
+        return this.register("update", collection, fn);
+    }
+    updateOne(collection, fn) {
+        return this.register("updateOne", collection, fn);
+    }
+    updateOneOrAdd(collection, fn) {
+        return this.register("updateOneOrAdd", collection, fn);
+    }
+    remove(collection, fn) {
+        return this.register("remove", collection, fn);
+    }
+    removeOne(collection, fn) {
+        return this.register("removeOne", collection, fn);
+    }
+    removeCollection(collection, fn) {
+        return this.register("removeCollection", collection, fn);
+    }
     getAdapter(extendedFind = true) {
-        const resolve = async (op, col, ...args) => {
+        const resolve = async (op, ...args) => {
+            const col = args.shift();
             const handler = this.handlers.get(`${op}:${col}`) || this.handlers.get(`${op}:*`) || null;
             if (!handler)
                 throw new Error(`Unimplemented method: ${op}:${col}`);
-            return handler(...args);
+            if (col === "*")
+                args.unshift(col);
+            try {
+                return await handler(...args);
+            }
+            catch (e) {
+                this.catchCb(e, op, args);
+            }
         };
         const adapter = createValtheraAdapter({
             getCollections: async () => Array.from(this.collections),
@@ -66,16 +102,10 @@ export class AdapterBuilder {
                     this.collections.add(col);
                 return true;
             },
-            add: (col, data, id_gen) => resolve("add", col, data, id_gen),
-            find: (col, search, context, options, findOpts) => resolve("find", col, search, context, options, findOpts),
-            findOne: (col, search, context, findOpts) => resolve("findOne", col, search, context, findOpts),
-            update: (col, search, up) => resolve("update", col, search, up),
-            updateOne: (col, search, up) => resolve("updateOne", col, search, up),
-            updateOneOrAdd: (col, search, up, add_data, ctx, id_gen) => resolve("updateOneOrAdd", col, search, up, add_data, ctx, id_gen),
-            remove: (col, search) => resolve("remove", col, search),
-            removeOne: (col, search) => resolve("removeOne", col, search),
-            removeCollection: (col) => resolve("removeCollection", col),
         }, extendedFind);
+        for (const name of ["add", "find", "findOne", "update", "updateOne", "updateOneOrAdd", "remove", "removeOne", "removeCollection"]) {
+            adapter[name] = (...args) => resolve(name, ...args);
+        }
         return adapter;
     }
 }

package/dist/cpu/relation.js

@@ -1,8 +1,7 @@
 import { checkRelationPermission } from "../permissions/index.js";
-import { parseObjectSelect, parseSelect } from "./utils.js";
+import { parseSelect } from "./utils.js";
 function standardizeRelationRequest(config, req) {
-    const select = parseObjectSelect(req.select) || [];
-    req.select = parseSelect(config, select);
+    req.select = parseSelect(config, req.select);
 }
 function checkDBsExist(cpu, req) {
     const db = req.path[0];

package/dist/cpu/utils.d.ts

@@ -1,3 +1,2 @@
 import { VQLConfig } from "../config.js";
 export declare function parseSelect(config: VQLConfig, select: object | object[]): any[];
-export declare function parseObjectSelect(obj: object): any[];

package/dist/cpu/utils.js

@@ -4,27 +4,13 @@ export function parseSelect(config, select) {
             return undefined;
         return select;
     }
-    else {
+    else if (typeof select === "object") {
         const keys = Object.keys(select);
         if (!config.strictSelect && keys.length === 0)
             return undefined;
         return keys.filter(k => !!select[k]);
     }
-}
-export function parseObjectSelect(obj) {
-    if (Array.isArray(obj))
-        return obj;
-    let result = [];
-    function walk(o, path = []) {
-        if (o !== null && typeof o === "object") {
-            for (const k of Object.keys(o)) {
-                walk(o[k], [...path, k]);
-            }
-        }
-        else {
-            result.push(path);
-        }
+    else {
+        return config.strictSelect ? [] : undefined;
     }
-    walk(obj);
-    return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",