@wxn0brp/vql 0.6.0 → 0.6.2

package/dist/apiAbstract.d.ts

@@ -43,4 +43,19 @@ export interface ValtheraResolver {
     removeCollection?: ResolverFn<[collection: string], boolean>;
 }
 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 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;
+    getAdapter(extendedFind?: boolean): ValtheraCompatible;
+}
 export {};

package/dist/apiAbstract.js

@@ -22,8 +22,6 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
         remove: (col, search) => safe(resolver.remove)(col, search),
         removeOne: (col, search) => safe(resolver.removeOne)(col, search),
         removeCollection: (col) => safe(resolver.removeCollection)(col),
-        findStream: null,
-        transaction: null,
     };
     adapter.c = (collection) => new CollectionManager(adapter, collection);
     if (extendedFind) {
@@ -45,3 +43,39 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
     }
     return adapter;
 }
+export class AdapterBuilder {
+    handlers = new Map();
+    collections = new Set();
+    register(op, collection, fn) {
+        this.handlers.set(`${op}:${collection}`, fn);
+        this.collections.add(collection);
+        return this;
+    }
+    getAdapter(extendedFind = true) {
+        const resolve = async (op, col, ...args) => {
+            const handler = this.handlers.get(`${op}:${col}`) || this.handlers.get(`${op}:*`) || null;
+            if (!handler)
+                throw new Error(`Unimplemented method: ${op}:${col}`);
+            return handler(...args);
+        };
+        const adapter = createValtheraAdapter({
+            getCollections: async () => Array.from(this.collections),
+            issetCollection: async (col) => this.collections.has(col),
+            ensureCollection: async (col) => {
+                if (!this.collections.has(col))
+                    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);
+        return adapter;
+    }
+}

package/dist/cpu/relation.js

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

package/dist/cpu/string/index.js

@@ -14,6 +14,7 @@ function parseArgs(input) {
     let current = "";
     let inQuotes = false;
     let escape = false;
+    let objTree = 0;
     for (let i = 0; i < input.length; i++) {
         const char = input[i];
         if (escape) {
@@ -23,11 +24,51 @@ function parseArgs(input) {
         else if (char === "\\") {
             escape = true;
         }
-        else if (char === "\"") {
-            inQuotes = !inQuotes;
+        else if (!inQuotes && (char === "{" || char === "[")) {
+            objTree++;
+            current += char;
         }
-        else if (!inQuotes && (char === " " || char === "=")) {
+        else if (!inQuotes && (char === "}" || char === "]")) {
+            objTree--;
+            current += char;
+            if (objTree === 0) {
+                tokens.push(current);
+                current = "";
+            }
+        }
+        else if (!objTree && (char === "'" || char === '"' || char === "`")) {
+            if (inQuotes === char) {
+                inQuotes = false;
+                tokens.push(`"` + current + `"`);
+                current = "";
+            }
+            else if (typeof inQuotes === "boolean") {
+                inQuotes = char;
+            }
+            else {
+                current += char;
+            }
+        }
+        else if (!inQuotes && (char === " " || char === "=" || char === "<" || char === ">")) {
             if (current !== "") {
+                if (char === "<" || char === ">") {
+                    let type = char === ">" ? "gt" : "lt";
+                    if (i < input.length - 1 && input[i + 1] === "=") {
+                        type += "e";
+                        i++;
+                    }
+                    const split = current.split(".");
+                    if (split.length > 1) {
+                        const original = split.shift();
+                        const operation = "$" + type;
+                        split.unshift(operation);
+                        split.unshift(original);
+                        current = split.join(".");
+                    }
+                    else {
+                        current = "$" + type + "." + current;
+                    }
+                }
                 tokens.push(current);
                 current = "";
             }

package/dist/cpu/utils.d.ts

@@ -1,2 +1,3 @@
 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

@@ -11,3 +11,20 @@ export function parseSelect(config, select) {
         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);
+        }
+    }
+    walk(obj);
+    return result;
+}

package/dist/processor.d.ts

@@ -1,6 +1,6 @@
 import { Relation, ValtheraCompatible } from "@wxn0brp/db-core";
 import { VQLConfig, VQLConfigInterface } from "./config.js";
-import { VQLError, VQLUQ } from "./types/vql.js";
+import { VQL_Query, VQLError, VQLUQ } from "./types/vql.js";
 import { PermValidFn } from "./types/perm.js";
 export declare class VQLProcessor {
     dbInstances: Record<string, ValtheraCompatible>;
@@ -9,4 +9,16 @@ export declare class VQLProcessor {
     config: VQLConfig;
     constructor(dbInstances: Record<string, ValtheraCompatible>, config?: VQLConfig | Partial<VQLConfigInterface>, permValidFn?: PermValidFn);
     execute<T = any>(queryRaw: VQLUQ<T>, user?: any): Promise<T | VQLError>;
+    _preProcessQuery(queryRaw: VQLUQ, user: any): {
+        err: VQLError;
+        query?: undefined;
+    } | {
+        query: VQL_Query;
+        err?: undefined;
+    };
+    _parseQuery(queryRaw: VQLUQ): {
+        query?: VQL_Query;
+        err?: VQLError;
+    };
+    _runQuery(query: VQL_Query, user: any): Promise<any>;
 }

package/dist/processor.js

@@ -18,6 +18,31 @@ export class VQLProcessor {
         this.config = config instanceof VQLConfig ? config : new VQLConfig(config);
     }
     async execute(queryRaw, user = { _id: "null-null-null" }) {
+        const result = this._preProcessQuery(queryRaw, user);
+        if ("err" in result)
+            return result.err;
+        return await this._runQuery(result.query, user);
+    }
+    _preProcessQuery(queryRaw, user) {
+        const { query: parsedQuery, err: parseErr } = this._parseQuery(queryRaw);
+        if (parseErr) {
+            return { err: parseErr };
+        }
+        const validateRawResult = validateRaw(parsedQuery);
+        if (validateRawResult !== true) {
+            logger.warn("Raw validation failed:", validateRawResult);
+            return { err: validateRawResult };
+        }
+        const query = replaceVars(parsedQuery, user);
+        logger.debug("Executed sheet (expanded query):", query);
+        const validateVqlResult = validateVql(query);
+        if (validateVqlResult !== true) {
+            logger.warn("VQL validation failed:", validateVqlResult);
+            return { err: validateVqlResult };
+        }
+        return { query };
+    }
+    _parseQuery(queryRaw) {
         if (typeof queryRaw === "string" || "query" in queryRaw) {
             logger.info("Incoming string query");
             const q = typeof queryRaw === "string" ? queryRaw : queryRaw.query;
@@ -29,7 +54,9 @@ export class VQLProcessor {
             }
             catch (e) {
                 logger.error("Error parsing string query: ", { error: e, msg: e.message });
-                return { err: true, c: 400, msg: `String query parsing error: ${e.message}` };
+                return {
+                    err: { err: true, c: 400, msg: `String query parsing error: ${e.message}` }
+                };
             }
             if (vars)
                 queryRaw = { ...queryRaw, var: vars };
@@ -39,18 +66,9 @@ export class VQLProcessor {
             logger.info("Incoming object query");
             logger.debug("Raw query: ", queryRaw);
         }
-        const validateRawResult = validateRaw(queryRaw);
-        if (validateRawResult !== true) {
-            logger.warn("Raw validation failed:", validateRawResult);
-            return validateRawResult;
-        }
-        const query = replaceVars(queryRaw, user);
-        logger.debug("Executed sheet (expanded query):", query);
-        const validateVqlResult = validateVql(query);
-        if (validateVqlResult !== true) {
-            logger.warn("VQL validation failed:", validateVqlResult);
-            return validateVqlResult;
-        }
+        return { query: queryRaw };
+    }
+    async _runQuery(query, user) {
         if ("r" in query) {
             return await executeRelation(this, query, user);
         }

package/dist/types/vql.d.ts

@@ -81,7 +81,7 @@ export interface VQL_Query_Relation {
         relations: RelationTypes.Relation;
         many?: boolean;
         options?: DbFindOpts;
-        select?: RelationTypes.FieldPath[];
+        select?: RelationTypes.FieldPath[] | Record<string, any>;
     };
 }
 export interface VQL_Var {

package/dist/valid.js

@@ -54,8 +54,8 @@ function validR(query) {
         return emptyErr("Relation query 'r.many' must be a boolean.");
     if ("options" in r && !isObj(r.options, false))
         return emptyErr("Relation query 'r.options' must be an object.");
-    if ("select" in r && !Array.isArray(r.select))
-        return emptyErr("Relation query 'r.select' must be an array.");
+    if ("select" in r && typeof r.select !== "object")
+        return emptyErr("Relation query 'r.select' must be an object or an array.");
     return true;
 }
 function validD(query) {

package/dist/vql.d.ts

@@ -268,7 +268,7 @@ export interface VQL_Query_Relation {
 		relations: RelationTypes.Relation;
 		many?: boolean;
 		options?: DbFindOpts;
-		select?: RelationTypes.FieldPath[];
+		select?: RelationTypes.FieldPath[] | Record<string, any>;
 	};
 }
 export interface VQL_Var {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -31,16 +31,16 @@
     }
   },
   "devDependencies": {
-    "@types/node": "^24.1.0",
+    "@types/node": "^24.3.0",
     "@wxn0brp/db": "^0.30.0",
-    "@wxn0brp/falcon-frame": "0.0.20",
+    "@wxn0brp/falcon-frame": "0.0.21",
     "@wxn0brp/gate-warden": "^0.4.0",
-    "esbuild": "^0.25.8",
+    "esbuild": "^0.25.9",
     "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3"
+    "typescript": "^5.9.2"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.1.1"
+    "@wxn0brp/lucerna-log": "^0.2.0"
   },
   "exports": {
     ".": {