@wxn0brp/vql 0.9.0 → 0.10.1

package/dist/cpu/relation.d.ts

@@ -1,3 +1,4 @@
+import { VQLConfig } from "../helpers/config.js";
 import { VQLProcessor } from "../processor.js";
 import { VQL_Query_Relation } from "../types/vql.js";
-export declare function executeRelation(cpu: VQLProcessor, query: VQL_Query_Relation, user: any): Promise<any>;
+export declare function executeRelation(cpu: VQLProcessor, query: VQL_Query_Relation, user: any, cfg: VQLConfig): Promise<any>;

package/dist/cpu/relation.js

@@ -17,15 +17,15 @@ function checkDBsExist(cpu, req) {
     }
     return { err: false };
 }
-export async function executeRelation(cpu, query, user) {
+export async function executeRelation(cpu, query, user, cfg) {
     const checkDb = checkDBsExist(cpu, query.r);
     if (checkDb.err)
         return checkDb;
-    if (!cpu.config.noCheckPermissions && !await checkRelationPermission(cpu.config, cpu.permValidFn, user, query)) {
+    if (!cfg.noCheckPermissions && !await checkRelationPermission(cfg, cpu.permValidFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     const req = query.r;
-    standardizeRelationRequest(cpu.config, req);
+    standardizeRelationRequest(cfg, req);
     const { path, search, relations, select } = req;
     if (req.many) {
         return await cpu.relation.find(path, search, relations, select, req.options);

package/dist/cpu/request.d.ts

@@ -1,3 +1,4 @@
+import { VQLConfig } from "../helpers/config.js";
 import { VQLProcessor } from "../processor.js";
 import { VQL_Query_CRUD } from "../types/vql.js";
-export declare function executeQuery(cpu: VQLProcessor, query: VQL_Query_CRUD, user: any): Promise<any>;
+export declare function executeQuery(cpu: VQLProcessor, query: VQL_Query_CRUD, user: any, cfg: VQLConfig): Promise<any>;

package/dist/cpu/request.js

@@ -1,26 +1,26 @@
+import { LowAdapter } from "../helpers/lowAdapter.js";
 import { checkRequestPermission } from "../permissions/index.js";
 import { parseSelect } from "./utils.js";
-import { LowAdapter } from "../helpers/lowAdapter.js";
-export async function executeQuery(cpu, query, user) {
+export async function executeQuery(cpu, query, user, cfg) {
     if (!query.db || !cpu.dbInstances[query.db])
         return { err: true, msg: `Invalid query - db "${query.db || "undefined"}" not found`, c: 400 };
     const db = cpu.dbInstances[query.db];
     if (db instanceof LowAdapter)
         return await db.resolver(query, user);
     const operation = Object.keys(query.d)[0];
-    if (!cpu.config.noCheckPermissions && !await checkRequestPermission(cpu.config, cpu.permValidFn, user, query)) {
+    if (!cfg.noCheckPermissions && !await checkRequestPermission(cfg, cpu.permValidFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     if (operation === "find") {
         const params = query.d[operation];
-        const select = parseSelect(cpu.config, params.fields || params.select || {});
+        const select = parseSelect(cfg, params.fields || params.select || {});
         if (select && typeof select === "object" && Object.keys(select).length !== 0)
             params.searchOpts = { ...params.searchOpts, select };
         return db.find(params.collection, params.search, params.options || {}, params.searchOpts);
     }
     else if (operation === "findOne" || operation === "f") {
         const params = query.d[operation];
-        const select = parseSelect(cpu.config, params.fields || params.select || {});
+        const select = parseSelect(cfg, params.fields || params.select || {});
         if (select && typeof select === "object" && Object.keys(select).length !== 0)
             params.searchOpts = { ...params.searchOpts, select };
         return db.findOne(params.collection, params.search, params.searchOpts);

package/dist/helpers/apiAbstract.d.ts

@@ -1,6 +1,8 @@
 import { VQL_Query_CRUD_Keys } from "../types/vql.js";
 import { ValtheraCompatible } from "@wxn0brp/db-core";
-type ResolverFn<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => Promise<TReturn>;
+export type ResolverFn<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => Promise<TReturn>;
+export type DropFirstFromTuple<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
+export type DropFirst<T> = T extends (...args: infer Args) => infer R ? (...args: DropFirstFromTuple<Args>) => R : never;
 export interface ValtheraResolverMeta {
     type: "valthera" | "api" | "wrapper" | (string & {});
     version: string;
@@ -45,16 +47,25 @@ export declare class AdapterBuilder {
     private collections;
     constructor(catchCb?: (e: any, op: string, args: any[]) => void);
     register(op: Operation, collection: string, fn: Function): this;
-    add(collection: string, fn: ValtheraResolver["add"]): this;
-    find(collection: string, fn: ValtheraResolver["find"]): this;
-    findOne(collection: string, fn: ValtheraResolver["findOne"]): this;
-    update(collection: string, fn: ValtheraResolver["update"]): this;
-    updateOne(collection: string, fn: ValtheraResolver["updateOne"]): this;
-    updateOneOrAdd(collection: string, fn: ValtheraResolver["updateOneOrAdd"]): this;
-    toggleOne(collection: string, fn: ValtheraResolver["toggleOne"]): this;
-    remove(collection: string, fn: ValtheraResolver["remove"]): this;
-    removeOne(collection: string, fn: ValtheraResolver["removeOne"]): this;
-    removeCollection(collection: string, fn: ValtheraResolver["removeCollection"]): this;
+    add(collection: (string & {}), fn: DropFirst<ValtheraResolver["add"]>): this;
+    add(collection: "*", fn: ValtheraResolver["add"]): this;
+    find(collection: (string & {}), fn: DropFirst<ValtheraResolver["find"]>): this;
+    find(collection: "*", fn: ValtheraResolver["find"]): this;
+    findOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["findOne"]>): this;
+    findOne(collection: "*", fn: ValtheraResolver["findOne"]): this;
+    update(collection: (string & {}), fn: DropFirst<ValtheraResolver["update"]>): this;
+    update(collection: "*", fn: ValtheraResolver["update"]): this;
+    updateOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["updateOne"]>): this;
+    updateOne(collection: "*", fn: ValtheraResolver["updateOne"]): this;
+    updateOneOrAdd(collection: (string & {}), fn: DropFirst<ValtheraResolver["updateOneOrAdd"]>): this;
+    updateOneOrAdd(collection: "*", fn: ValtheraResolver["updateOneOrAdd"]): this;
+    toggleOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["toggleOne"]>): this;
+    toggleOne(collection: "*", fn: ValtheraResolver["toggleOne"]): this;
+    remove(collection: (string & {}), fn: DropFirst<ValtheraResolver["remove"]>): this;
+    remove(collection: "*", fn: ValtheraResolver["remove"]): this;
+    removeOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["removeOne"]>): this;
+    removeOne(collection: "*", fn: ValtheraResolver["removeOne"]): this;
+    removeCollection(collection: (string & {}), fn: DropFirst<ValtheraResolver["removeCollection"]>): this;
+    removeCollection(collection: "*", fn: ValtheraResolver["removeCollection"]): this;
     getAdapter(extendedFind?: boolean): ValtheraCompatible;
 }
-export {};

package/dist/helpers/gw.js

@@ -1,5 +1,6 @@
 export function createGwValidFn(gw) {
     return async (args) => {
-        return gw.hasAccess(args.user.id, args.field, args.p);
+        const res = await gw.hasAccess(args.user._id, args.field, args.p);
+        return { granted: res.granted, via: `gate-warden`, reason: res.via };
     };
 }

package/dist/permissions/relation.js

@@ -18,7 +18,7 @@ export async function checkRelationPermission(config, permValidFn, user, query)
             return true;
         }
         // If the result is "entity-404", check the next fallback level
-        if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
+        if (!config.strictACL && result.reason === "entity-404" && fallbackLevels.length > 0) {
             const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
             return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2), fallbackLevels.slice(0, -2));
         }

package/dist/permissions/request.js

@@ -106,7 +106,7 @@ export async function checkRequestPermission(config, permValidFn, user, query) {
             return true;
         }
         // If the result is "entity-404", check the next fallback level
-        if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
+        if (!config.strictACL && result.reason === "entity-404" && fallbackLevels.length > 0) {
             const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
             return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2), requiredPerm, fallbackLevels.slice(0, -2));
         }

package/dist/permissions/resolver.d.ts

@@ -1,9 +1,9 @@
-import { PathMatcher, PermissionResolver } from "../types/resolver.js";
+import { PathMatcher, PermissionResolver, ValidEngineOpts } from "../types/resolver.js";
 import { PermValidFn } from "../types/perm.js";
 import { GateWarden } from "@wxn0brp/gate-warden";
 export declare class PermissionResolverEngine {
     private resolvers;
-    addResolver(matcher: PathMatcher, resolver: PermissionResolver): void;
+    addResolver(matcher: PathMatcher, resolver: PermissionResolver, opts?: ValidEngineOpts | ValidEngineOpts["stringMode"]): void;
     create(): PermValidFn;
     createWithGw(gw: GateWarden): PermValidFn;
 }

package/dist/permissions/resolver.js

@@ -1,15 +1,25 @@
 export class PermissionResolverEngine {
     resolvers = [];
-    addResolver(matcher, resolver) {
-        this.resolvers.push({ matcher, resolver });
+    addResolver(matcher, resolver, opts = {}) {
+        if (typeof opts === "string")
+            opts = { stringMode: opts };
+        this.resolvers.push({ matcher, resolver, opts });
     }
     create() {
         return async (args) => {
             const originalPath = args.path.join("/");
-            for (const { matcher, resolver } of this.resolvers) {
+            for (const { matcher, resolver, opts } of this.resolvers) {
                 let isMatch = false;
                 if (typeof matcher === "string") {
-                    isMatch = originalPath === matcher;
+                    const { stringMode } = opts;
+                    if (stringMode === "endsWith")
+                        isMatch = originalPath.endsWith(matcher);
+                    else if (stringMode === "startsWith")
+                        isMatch = originalPath.startsWith(matcher);
+                    else if (stringMode === "includes")
+                        isMatch = originalPath.includes(matcher);
+                    else
+                        isMatch = originalPath === matcher;
                 }
                 else if (matcher instanceof RegExp) {
                     isMatch = matcher.test(originalPath);
@@ -17,18 +27,18 @@ export class PermissionResolverEngine {
                 else if (typeof matcher === "function") {
                     isMatch = await matcher(originalPath, args.path);
                 }
-                if (isMatch) {
-                    try {
-                        const resolverGranted = await resolver(args);
-                        return { granted: resolverGranted, via: `resolver` };
-                    }
-                    catch (error) {
-                        console.error(`[Resolver Engine] Error in custom resolver for path ${originalPath}:`, error);
-                        return { granted: false, via: `resolver-error` };
-                    }
+                if (!isMatch)
+                    continue;
+                try {
+                    const resolverGranted = await resolver(args);
+                    return { granted: resolverGranted, via: `resolver`, reason: "resolver" };
+                }
+                catch (error) {
+                    console.error(`[Resolver Engine] Error in custom resolver for path ${originalPath}:`, error);
+                    return { granted: false, via: `resolver`, reason: "resolver-error" };
                 }
             }
-            return { granted: false, via: `no-resolver-match` };
+            return { granted: false, via: `resolver`, reason: "no-resolver-match" };
         };
     }
     createWithGw(gw) {
@@ -37,10 +47,10 @@ export class PermissionResolverEngine {
             const resolverResult = await resolver(args);
             if (resolverResult.granted)
                 return resolverResult;
-            if (!resolverResult.granted && resolverResult.via !== `no-resolver-match`)
+            if (resolverResult.reason !== `no-resolver-match`)
                 return resolverResult;
             const gwResult = await gw.hasAccess(args.user.id, args.field, args.p);
-            return { granted: gwResult.granted, via: `gate-warden` };
+            return { granted: gwResult.granted, via: `gate-warden`, reason: gwResult.via };
         };
     }
 }

package/dist/processor.d.ts

@@ -8,7 +8,7 @@ export declare class VQLProcessor {
     relation: Relation;
     config: VQLConfig;
     constructor(dbInstances: Record<string, ValtheraCompatible>, config?: VQLConfig | Partial<VQLConfigInterface>, permValidFn?: PermValidFn);
-    execute<T = any>(queryRaw: VQLUQ<T>, user?: any): Promise<T | VQLError>;
+    execute<T = any>(queryRaw: VQLUQ<T>, user?: any, cfg?: VQLConfig): Promise<T | VQLError>;
     _preProcessQuery(queryRaw: VQLUQ, user: any): {
         err: VQLError;
         query?: undefined;
@@ -20,5 +20,5 @@ export declare class VQLProcessor {
         query?: VQL_Query;
         err?: VQLError;
     };
-    _runQuery(query: VQL_Query, user: any): Promise<any>;
+    _runQuery(query: VQL_Query, user: any, cfg?: VQLConfig): Promise<any>;
 }

package/dist/processor.js

@@ -11,17 +11,17 @@ export class VQLProcessor {
     permValidFn;
     relation;
     config;
-    constructor(dbInstances, config = new VQLConfig(), permValidFn = async () => ({ granted: true, via: "" })) {
+    constructor(dbInstances, config = new VQLConfig(), permValidFn = async () => ({ granted: true, via: "resolver", reason: "no-resolver-match" })) {
         this.dbInstances = dbInstances;
         this.permValidFn = permValidFn;
         this.relation = new Relation(dbInstances);
         this.config = config instanceof VQLConfig ? config : new VQLConfig(config);
     }
-    async execute(queryRaw, user = { _id: "null-null-null" }) {
+    async execute(queryRaw, user = { _id: "null-null-null" }, cfg = this.config) {
         const result = this._preProcessQuery(queryRaw, user);
         if ("err" in result)
             return result.err;
-        return await this._runQuery(result.query, user);
+        return await this._runQuery(result.query, user, cfg);
     }
     _preProcessQuery(queryRaw, user) {
         const { query: parsedQuery, err: parseErr } = this._parseQuery(queryRaw);
@@ -68,12 +68,12 @@ export class VQLProcessor {
         }
         return { query: queryRaw };
     }
-    async _runQuery(query, user) {
+    async _runQuery(query, user, cfg = this.config) {
         if ("r" in query) {
-            return await executeRelation(this, query, user);
+            return await executeRelation(this, query, user, cfg);
         }
         else if ("d" in query) {
-            return await executeQuery(this, query, user);
+            return await executeQuery(this, query, user, cfg);
         }
         else {
             return { err: true, msg: "Invalid query", c: 400 };

package/dist/types/perm.d.ts

@@ -1,3 +1,4 @@
+import { AccessResult } from "@wxn0brp/gate-warden";
 export declare enum PermCRUD {
     CREATE = 1,
     READ = 2,
@@ -7,7 +8,8 @@ export declare enum PermCRUD {
 }
 export interface ValidFnResult {
     granted: boolean;
-    via?: string;
+    via?: "resolver" | "gate-warden";
+    reason?: AccessResult["via"] | "resolver" | "no-resolver-match" | "resolver-error";
 }
 export interface PermValidFnArgs {
     /** sha256/json */

package/dist/types/resolver.d.ts

@@ -7,8 +7,12 @@ export type PermissionResolver = (args: PermValidFnArgs) => Promise<boolean>;
 export interface ResolverEntry {
     matcher: PathMatcher;
     resolver: PermissionResolver;
+    opts: ValidEngineOpts;
 }
 export interface ResolverValidFnResult {
     granted: boolean;
     via: string;
 }
+export interface ValidEngineOpts {
+    stringMode?: "equal" | "startsWith" | "endsWith" | "includes";
+}

package/package.json

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