@wxn0brp/vql 0.6.4 → 0.8.2

package/README.md

@@ -1,17 +1,23 @@
 # VQL (Valthera Query Language)
 
-VQL is a query language and processing framework designed for managing and interacting with databases using ValtheraDB. It provides a robust permission system, query execution, and a GUI for managing ACL rules and database structures.
+VQL (Valthera Query Language) is a comprehensive framework for interacting with ValtheraDB. It combines a flexible query language, a powerful permission management system, and a suite of tools to build secure and efficient data-driven applications.
 
 [![npm version](https://img.shields.io/npm/v/@wxn0brp/vql)](https://www.npmjs.com/package/@wxn0brp/vql)
 [![License](https://img.shields.io/npm/l/@wxn0brp/vql)](./LICENSE)
 [![Downloads](https://img.shields.io/npm/dm/@wxn0brp/vql)](https://www.npmjs.com/package/@wxn0brp/vql)
+![CI](https://img.shields.io/github/actions/workflow/status/wxn0brP/VQL/build.yml?branch=master)
+![bundle size](https://img.shields.io/bundlephobia/minzip/@wxn0brp/vql)
 
-## Features
+## Key Features
 
-- **Query Execution**: Supports CRUD operations and advanced query capabilities.
-- **Permission Management**: Fine-grained access control using Gate Warden.
-- **GUI**: A web-based interface for managing ACL rules and database structures.
-- **Extensibility**: Easily extendable with pre-defined sheets and custom configurations.
+- **Dual Query Syntax**: Choose between VQLR (a JSON-based object query language for programmatic use) and VQLS (a human-readable string-based language for simpler queries and scripts).
+- **Multi-Database Support**: Process queries across multiple ValtheraDB instances seamlessly.
+- **Cross-Platform**: Run VQL in both Node.js and modern web browsers.
+- **Extensible by Design**: Customize and extend functionality with sheets and custom configurations.
+- **Advanced Relation Queries**: Natively handle complex relationships not just between collections, but also across entire databases.
+- **Permission System**: Built-in, granular access control powered by Gate Warden. It's disabled by default and can be enabled when needed to enforce complex security rules.
+- **Falcon Frame Integration**: Integrates with Falcon Frame for extended capabilities.
+- **Variable Support**: Use predefined or custom variables in your queries, allowing for more dynamic and reusable logic.
 
 ## Example Usage
 
@@ -35,7 +41,7 @@ const query = {
     d: {
         find: {
             collection: "users",
-            search: { age: { $gt: 18 } },
+            search: { $gt: { age: 18 } },
             fields: { name: 1, age: 1 },
         },
     },
@@ -61,6 +67,10 @@ f.age = 1
 })();
 ```
 
+## Development Tools
+
+For an enhanced development and debugging experience, you can use [VQL-dev](https://github.com/wxn0brP/VQL-dev), a dedicated tool for debugging VQL queries.
+
 ## Documentation
 
 - [Base/Map](./docs/lang/base.md)

package/dist/cpu/request.js

@@ -13,14 +13,14 @@ export async function executeQuery(cpu, query, user) {
         const select = parseSelect(cpu.config, 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);
+        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 || {});
         if (select && typeof select === "object" && Object.keys(select).length !== 0)
             params.searchOpts = { ...params.searchOpts, select };
-        return db.findOne(params.collection, params.search, {}, params.searchOpts);
+        return db.findOne(params.collection, params.search, params.searchOpts);
     }
     else if (operation === "add") {
         const params = query.d[operation];
@@ -44,7 +44,12 @@ export async function executeQuery(cpu, query, user) {
     }
     else if (operation === "updateOneOrAdd") {
         const params = query.d[operation];
-        return db.updateOneOrAdd(params.collection, params.search, params.updater, params.add_arg || {}, {}, params.id_gen ?? true);
+        const opts = {};
+        if (params.add_arg)
+            opts.add_arg = params.add_arg;
+        if (params.id_gen)
+            opts.id_gen = params.id_gen;
+        return db.updateOneOrAdd(params.collection, params.search, params.updater, opts);
     }
     else if (operation === "removeCollection") {
         const params = query.d[operation];

package/dist/cpu/utils.d.ts

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

package/dist/{apiAbstract.js → helpers/apiAbstract.js}

@@ -22,8 +22,8 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
         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);
+        adapter.find = async (col, search, options, findOpts, context) => {
+            let data = await safe(resolver.find)(col, search, options, findOpts, context);
             if (options?.reverse)
                 data.reverse();
             if (options?.max !== -1 && data.length > options?.max)

package/dist/{falconFrame.d.ts → helpers/falconFrame.d.ts}

@@ -1,4 +1,4 @@
-import { type VQLProcessor } from "./processor.js";
+import { type VQLProcessor } from "../processor.js";
 import type { FalconFrame, FFRequest } from "@wxn0brp/falcon-frame";
 type ContextFn = (req: FFRequest) => Promise<any> | any;
 interface FF_VQL_Options {

package/dist/{falconFrame.js → helpers/falconFrame.js}

@@ -1,4 +1,4 @@
-import { parseVQLS } from "./cpu/string/index.js";
+import { parseVQLS } from "../cpu/string/index.js";
 export function FF_VQL(app, processor, options = {}) {
     const path = options.path || "/VQL";
     const getContext = options.getUser || (() => ({}));

package/dist/{gw.d.ts → helpers/gw.d.ts}

@@ -1,3 +1,3 @@
 import { GateWarden } from "@wxn0brp/gate-warden";
-import { PermValidFn } from "./types/perm.js";
+import { PermValidFn } from "../types/perm.js";
 export declare function createGwValidFn(gw: GateWarden): PermValidFn;

package/dist/helpers/gw.js

@@ -0,0 +1,5 @@
+export function createGwValidFn(gw) {
+    return async (args) => {
+        return gw.hasAccess(args.user.id, args.field, args.p);
+    };
+}

package/dist/{merge.js → helpers/merge.js}

@@ -1,10 +1,10 @@
 export function deepMerge(target, source) {
-    if (typeof target !== 'object' || target === null) {
+    if (typeof target !== "object" || target === null) {
         target = {};
     }
     for (const key in source) {
         if (source.hasOwnProperty(key)) {
-            if (typeof source[key] === 'object' && source[key] !== null && !Array.isArray(source[key])) {
+            if (typeof source[key] === "object" && source[key] !== null && !Array.isArray(source[key])) {
                 if (!target[key]) {
                     target[key] = {};
                 }

package/dist/{sheet.d.ts → helpers/sheet.d.ts}

@@ -1,2 +1,2 @@
-import { VQL_Query } from "./types/vql.js";
+import { VQL_Query } from "../types/vql.js";
 export declare function replaceVars(query: VQL_Query, user: any): VQL_Query;

package/dist/{valid.d.ts → helpers/valid.d.ts}

@@ -1,3 +1,3 @@
-import { VQL_Query, VQLError } from "./types/vql.js";
+import { VQL_Query, VQLError } from "../types/vql.js";
 export declare function validateRaw(query: VQL_Query): true | VQLError;
 export declare function validateVql(query: VQL_Query): true | VQLError;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 import { VQLProcessor } from "./processor.js";
-import { VQLConfig } from "./config.js";
-import { createValtheraAdapter } from "./apiAbstract.js";
+import { VQLConfig } from "./helpers/config.js";
+import { createValtheraAdapter } from "./helpers/apiAbstract.js";
 import logger from "./logger.js";
 import { LogLevel } from "@wxn0brp/lucerna-log";
-import { FF_VQL } from "./falconFrame.js";
-import { createGwValidFn } from "./gw.js";
+import { FF_VQL } from "./helpers/falconFrame.js";
+import { createGwValidFn } from "./helpers/gw.js";
 export default VQLProcessor;
 export { VQLProcessor, createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL, createGwValidFn };

package/dist/index.js

@@ -1,9 +1,9 @@
 import { VQLProcessor } from "./processor.js";
-import { VQLConfig } from "./config.js";
-import { createValtheraAdapter } from "./apiAbstract.js";
+import { VQLConfig } from "./helpers/config.js";
+import { createValtheraAdapter } from "./helpers/apiAbstract.js";
 import logger from "./logger.js";
 import { LogLevel } from "@wxn0brp/lucerna-log";
-import { FF_VQL } from "./falconFrame.js";
-import { createGwValidFn } from "./gw.js";
+import { FF_VQL } from "./helpers/falconFrame.js";
+import { createGwValidFn } from "./helpers/gw.js";
 export default VQLProcessor;
 export { VQLProcessor, createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL, createGwValidFn };

package/dist/permissions/relation.d.ts

@@ -1,4 +1,4 @@
 import { PermValidFn } from "../types/perm.js";
 import { VQL_Query_Relation } from "../types/vql.js";
-import { VQLConfig } from "../config.js";
+import { VQLConfig } from "../helpers/config.js";
 export declare function checkRelationPermission(config: VQLConfig, permValidFn: PermValidFn, user: any, query: VQL_Query_Relation): Promise<boolean>;

package/dist/permissions/relation.js

@@ -3,30 +3,35 @@ import { extractPathsFromData, hashKey } from "./utils.js";
 export async function checkRelationPermission(config, permValidFn, user, query) {
     const { path, search, relations, select } = query.r;
     // Helper function to recursively check permissions with fallback mechanism
-    const checkPermissionRecursively = async (entityId, fallbackLevels = []) => {
+    const checkPermissionRecursively = async (entityId, originalPath, fallbackLevels = []) => {
         // Check if the user has access to the current entity
         // const result = await gw.hasAccess(user.id, entityId, PermCRUD.READ);
-        const result = await permValidFn(entityId, PermCRUD.READ, user);
+        const result = await permValidFn({
+            field: entityId,
+            path: originalPath,
+            p: PermCRUD.READ,
+            user
+        });
         if (result.granted) {
             return true;
         }
         // If the result is "entity-404", check the next fallback level
         if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
             const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
-            return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2));
+            return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2), fallbackLevels.slice(0, -2));
         }
         // If no fallback levels are left or the result is not "entity-404", deny access
         return false;
     };
     // Check permission for the relation field in the parent collection
-    if (!await checkPermissionRecursively(await hashKey(config, path), path)) {
+    if (!await checkPermissionRecursively(await hashKey(config, path), path, path)) {
         return false;
     }
     // Check permissions for search fields
     const searchPaths = extractPathsFromData(search || {});
     for (const searchPath of searchPaths) {
         const key = [...path, ...searchPath.path, searchPath.key];
-        if (!await checkPermissionRecursively(await hashKey(config, key), key)) {
+        if (!await checkPermissionRecursively(await hashKey(config, key), key, key)) {
             return false;
         }
     }
@@ -34,7 +39,7 @@ export async function checkRelationPermission(config, permValidFn, user, query)
     if (select) {
         for (const fieldPath of select) {
             const key = [...path, fieldPath];
-            if (!await checkPermissionRecursively(await hashKey(config, key), key)) {
+            if (!await checkPermissionRecursively(await hashKey(config, key), key, key)) {
                 return false;
             }
         }

package/dist/permissions/request.d.ts

@@ -1,4 +1,4 @@
-import { VQLConfig } from "../config.js";
+import { VQLConfig } from "../helpers/config.js";
 import { PermCRUD, PermValidFn } from "../types/perm.js";
 import { VQL_Query_CRUD } from "../types/vql.js";
 export declare function extractPaths(config: VQLConfig, query: VQL_Query_CRUD): Promise<{

package/dist/permissions/request.js

@@ -41,14 +41,15 @@ export async function extractPaths(config, query) {
             permPaths.paths.push({ c: PermCRUD.COLLECTION });
             break;
     }
-    permPaths.paths = permPaths.paths.map(path => {
+    permPaths.paths = (await Promise.all(permPaths.paths.map(async (path) => {
         if (!path.filed)
             return path;
-        return path.filed.map(filed => {
+        return await Promise.all(path.filed.map(async (filed) => {
             const processedPath = [query.db, collection, ...processFieldPath(filed)];
-            return { filed: hashKey(config, processedPath), path: processedPath, p: path.p };
-        });
-    }).flat();
+            const hashedKey = await hashKey(config, processedPath);
+            return { filed: hashedKey, path: processedPath, p: path.p };
+        }));
+    }))).flat();
     return permPaths;
 }
 export function processFieldPath(pathObj) {
@@ -84,17 +85,22 @@ export async function checkRequestPermission(config, permValidFn, user, query) {
         return false;
     const permPaths = await extractPaths(config, query);
     // Helper function to recursively check permissions
-    const checkPermissionRecursively = async (entityId, requiredPerm, fallbackLevels = []) => {
+    const checkPermissionRecursively = async (entityId, originalPath, requiredPerm, fallbackLevels = []) => {
         // Check if the user has access to the current entity
         // const result = await gw.hasAccess(user.id, entityId, requiredPerm);
-        const result = await permValidFn(entityId, requiredPerm, user);
+        const result = await permValidFn({
+            field: entityId,
+            path: originalPath,
+            p: requiredPerm,
+            user
+        });
         if (result.granted) {
             return true;
         }
         // If the result is "entity-404", check the next fallback level
         if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
             const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
-            return checkPermissionRecursively(nextFallbackEntityId, requiredPerm, fallbackLevels.slice(0, -2));
+            return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2), requiredPerm, fallbackLevels.slice(0, -2));
         }
         // If no fallback levels are left or the result is not "entity-404", deny access
         return false;
@@ -105,10 +111,12 @@ export async function checkRequestPermission(config, permValidFn, user, query) {
         let entityId;
         let requiredPerm;
         let fallbackLevels = [];
+        let originalPath = [];
         if ("c" in path) {
             // Collection-level permission: hash the combination of db and collection
             entityId = await hashKey(config, [query.db, permPaths.c]);
             requiredPerm = path.c;
+            originalPath = [query.db, permPaths.c];
             // Fallback to database level if needed
             fallbackLevels = [query.db];
         }
@@ -116,11 +124,12 @@ export async function checkRequestPermission(config, permValidFn, user, query) {
             // Field-level permission: use the hashed field path
             entityId = path.filed;
             requiredPerm = path.p;
+            originalPath = path.path;
             // Fallback to collection and then database level if needed
             fallbackLevels = path.path;
         }
         // Check permissions recursively
-        const result = await checkPermissionRecursively(entityId, requiredPerm, fallbackLevels);
+        const result = await checkPermissionRecursively(entityId, originalPath, requiredPerm, fallbackLevels);
         results.push(result);
     }
     // All permissions must be granted

package/dist/permissions/resolver.d.ts

@@ -0,0 +1,9 @@
+import { PathMatcher, PermissionResolver } 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;
+    create(): PermValidFn;
+    createWithGw(gw: GateWarden): PermValidFn;
+}

package/dist/permissions/resolver.js

@@ -0,0 +1,46 @@
+export class PermissionResolverEngine {
+    resolvers = [];
+    addResolver(matcher, resolver) {
+        this.resolvers.push({ matcher, resolver });
+    }
+    create() {
+        return async (args) => {
+            const originalPath = args.path.join("/");
+            for (const { matcher, resolver } of this.resolvers) {
+                let isMatch = false;
+                if (typeof matcher === "string") {
+                    isMatch = originalPath === matcher;
+                }
+                else if (matcher instanceof RegExp) {
+                    isMatch = matcher.test(originalPath);
+                }
+                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` };
+                    }
+                }
+            }
+            return { granted: false, via: `no-resolver-match` };
+        };
+    }
+    createWithGw(gw) {
+        const resolver = this.create();
+        return async (args) => {
+            const resolverResult = await resolver(args);
+            if (resolverResult.granted)
+                return resolverResult;
+            if (!resolverResult.granted && resolverResult.via !== `no-resolver-match`)
+                return resolverResult;
+            const gwResult = await gw.hasAccess(args.user.id, args.field, args.p);
+            return { granted: gwResult.granted, via: `gate-warden` };
+        };
+    }
+}

package/dist/permissions/utils.d.ts

@@ -1,4 +1,4 @@
-import { VQLConfig } from "../config.js";
+import { VQLConfig } from "../helpers/config.js";
 export declare function getHash(json: string): Promise<string>;
 export declare function hashKey(config: VQLConfig, path: any): Promise<string>;
 export declare function extractPathsFromData(data: any, stack?: string[]): {

package/dist/processor.d.ts

@@ -1,5 +1,5 @@
 import { Relation, ValtheraCompatible } from "@wxn0brp/db-core";
-import { VQLConfig, VQLConfigInterface } from "./config.js";
+import { VQLConfig, VQLConfigInterface } from "./helpers/config.js";
 import { VQL_Query, VQLError, VQLUQ } from "./types/vql.js";
 import { PermValidFn } from "./types/perm.js";
 export declare class VQLProcessor {

package/dist/processor.js

@@ -1,10 +1,10 @@
 import { Relation } from "@wxn0brp/db-core";
-import { VQLConfig } from "./config.js";
+import { VQLConfig } from "./helpers/config.js";
 import { executeRelation } from "./cpu/relation.js";
 import { executeQuery } from "./cpu/request.js";
 import logger from "./logger.js";
-import { replaceVars } from "./sheet.js";
-import { validateRaw, validateVql } from "./valid.js";
+import { replaceVars } from "./helpers/sheet.js";
+import { validateRaw, validateVql } from "./helpers/valid.js";
 import { parseVQLS } from "./cpu/string/index.js";
 export class VQLProcessor {
     dbInstances;

package/dist/types/perm.d.ts

@@ -9,4 +9,13 @@ export interface ValidFnResult {
     granted: boolean;
     via?: string;
 }
-export type PermValidFn = (path: string, perm: number, user: any) => Promise<ValidFnResult>;
+export interface PermValidFnArgs {
+    /** sha256/json */
+    field: string;
+    /** original path */
+    path: string[];
+    /** permission */
+    p: number;
+    user: any;
+}
+export type PermValidFn = (args: PermValidFnArgs) => Promise<ValidFnResult>;

package/dist/types/resolver.d.ts

@@ -0,0 +1,14 @@
+import { PermValidFnArgs } from "./perm.js";
+export interface GWUser {
+    _id: string;
+}
+export type PathMatcher = string | RegExp | ((path: string, pathSegments: string[]) => Promise<boolean>);
+export type PermissionResolver = (args: PermValidFnArgs) => Promise<boolean>;
+export interface ResolverEntry {
+    matcher: PathMatcher;
+    resolver: PermissionResolver;
+}
+export interface ResolverValidFnResult {
+    granted: boolean;
+    via: string;
+}

package/dist/types/resolver.js

@@ -0,0 +1 @@
+export {};

package/dist/vql.d.ts

@@ -55,7 +55,7 @@ export type ArrayOperators<T = any> = {
 };
 /** String Operators */
 export type StringOperators<T = any> = {
-	$regex?: PartialOfType<T, RegExp, string>;
+	$regex?: PartialOfType<T, RegExp | string, string>;
 	$startsWith?: PartialOfType<T, string>;
 	$endsWith?: PartialOfType<T, string>;
 };
@@ -119,11 +119,11 @@ declare class CollectionManager<D = Data> {
 	/**
 	 * Find data in a database.
 	 */
-	find<T = Data>(search?: Search<T & D>, context?: VContext, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>): Promise<T[]>;
+	find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T[]>;
 	/**
 	 * Find one data entry in a database.
 	 */
-	findOne<T = Data>(search?: Search<T & Data>, context?: VContext, findOpts?: FindOpts<T & Data>): Promise<T>;
+	findOne<T = Data>(search?: Search<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T>;
 	/**
 	 * Update data in a database.
 	 */
@@ -143,7 +143,7 @@ declare class CollectionManager<D = Data> {
 	/**
 	 * Asynchronously updates one entry in a database or adds a new one if it doesn't exist.
 	 */
-	updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, add_arg?: Arg<T & Data>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+	updateOneOrAdd<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & Data>): Promise<boolean>;
 }
 export interface ValtheraCompatible {
 	c(collection: string): CollectionManager;
@@ -151,14 +151,19 @@ export interface ValtheraCompatible {
 	ensureCollection(collection: string): Promise<boolean>;
 	issetCollection(collection: string): 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>;
+	find<T = Data>(collection: string, search?: Search<T>, options?: DbFindOpts<T>, findOpts?: FindOpts<T>, context?: VContext): Promise<T[]>;
+	findOne<T = Data>(collection: string, search?: Search<T>, findOpts?: FindOpts<T>, context?: VContext): 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<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, add_arg?: Arg<T>, context?: VContext, id_gen?: boolean): Promise<boolean>;
+	updateOneOrAdd<T = Data>(collection: string, search: Search<T>, updater: Updater<T>, opts?: UpdateOneOrAdd<T>): Promise<boolean>;
+}
+export interface UpdateOneOrAdd<T> {
+	add_arg?: Arg<T>;
+	id_gen?: boolean;
+	context?: VContext;
 }
 declare namespace RelationTypes {
 	type Path = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.6.4",
+  "version": "0.8.2",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -14,10 +14,22 @@
   "files": [
     "dist"
   ],
+  "keywords": [
+    "vql",
+    "valthera",
+    "database",
+    "orm",
+    "api",
+    "crud",
+    "nosql",
+    "query",
+    "db",
+    "query-language"
+  ],
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.1.4",
-    "@wxn0brp/falcon-frame": ">=0.0.20",
-    "@wxn0brp/gate-warden": ">=0.4.0"
+    "@wxn0brp/db-core": ">=0.2.3",
+    "@wxn0brp/falcon-frame": ">=0.4.0",
+    "@wxn0brp/gate-warden": ">=0.4.1"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/falcon-frame": {
@@ -31,16 +43,17 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^24.3.0",
-    "@wxn0brp/db": "^0.30.0",
-    "@wxn0brp/falcon-frame": "0.0.21",
-    "@wxn0brp/gate-warden": "^0.4.0",
-    "esbuild": "^0.25.9",
-    "tsc-alias": "^1.8.10",
-    "typescript": "^5.9.2"
+    "@types/node": "*",
+    "@wxn0brp/db": "^0.40.1",
+    "@wxn0brp/db-core": "^0.2.3",
+    "@wxn0brp/falcon-frame": "0.4.0",
+    "@wxn0brp/gate-warden": "^0.4.1",
+    "esbuild": "^0.25.10",
+    "tsc-alias": "*",
+    "typescript": "*"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.2.0"
+    "@wxn0brp/lucerna-log": "^0.2.1"
   },
   "exports": {
     ".": {
@@ -54,4 +67,4 @@
       "default": "./dist/*.js"
     }
   }
-}
+}

package/dist/gw.js

@@ -1,5 +0,0 @@
-export function createGwValidFn(gw) {
-    return async (path, perm, user) => {
-        return gw.hasAccess(user.id, path, perm);
-    };
-}