@wxn0brp/vql 0.5.1 → 0.6.0-alpha.0

package/README.md

@@ -20,18 +20,14 @@ Here is an example of how to use the `VQLProcessor` to execute a query:
 ```typescript
 import VQLProcessor from "@wxn0brp/vql";
 import { Valthera } from "@wxn0brp/db";
-import { GateWarden } from "@wxn0brp/gate-warden";
 
 // Initialize database instances
 const dbInstances = {
     myDatabase: new Valthera("path/to/database"),
 };
 
-// Initialize Gate Warden
-const gw = new GateWarden("path/to/gate-warden/database");
-
 // Create a VQLProcessor instance
-const processor = new VQLProcessor(dbInstances, gw);
+const processor = new VQLProcessor(dbInstances);
 
 // Define a query (VQLR)
 const query = {
@@ -53,31 +49,11 @@ s.$gt.age = 18
 f.name = 1
 f.age = 1
 `
-// Or (use backticks like json)
-const VQLB = `
-myDatabase users
-{
-    collection: "users",
-    search: { $gt: { age: 18 } },
-    fields: { name: 1, age: 1 },
-}
-`
-// Or (use markup like yaml)
-const VQLM = `
-myDatabase users
-collection: users
-search:
-  $gt:
-    age: 18
-fields:
-  name: 1
-  age: 1
-`
 
 // Execute the query
 (async () => {
     try {
-        const result = await processor.execute(query, { id: "user123" });
+        const result = await processor.execute(query);
         console.log("Query Result:", result);
     } catch (error) {
         console.error("Error executing query:", error);
@@ -89,7 +65,6 @@ fields:
 
 - [Base/Map](./docs/lang/base.md)
 - [VQLS](./docs/lang/VQLS.md)
-- [VQLM/B](./docs/lang/VQLM.md)
 - [VQLR](./docs/lang/VQLR.md)
 
 ## License

package/dist/config.d.ts

@@ -3,13 +3,11 @@ export interface VQLConfigInterface {
     strictSelect: boolean;
     strictACL: boolean;
     noCheckPermissions: boolean;
-    formatAjv: boolean;
 }
 export declare class VQLConfig implements VQLConfigInterface {
     hidePath: boolean;
     strictSelect: boolean;
     strictACL: boolean;
     noCheckPermissions: boolean;
-    formatAjv: boolean;
     constructor(config?: Partial<VQLConfigInterface>);
 }

package/dist/config.js

@@ -1,9 +1,8 @@
 export class VQLConfig {
-    hidePath = true;
-    strictSelect = true;
-    strictACL = true;
-    noCheckPermissions = false;
-    formatAjv = true;
+    hidePath = false;
+    strictSelect = false;
+    strictACL = false;
+    noCheckPermissions = true;
     constructor(config) {
         if (config) {
             Object.assign(this, config);

package/dist/cpu/relation.js

@@ -21,7 +21,7 @@ export async function executeRelation(cpu, query, user) {
     const checkDb = checkDBsExist(cpu, query.r);
     if (checkDb.err)
         return checkDb;
-    if (!cpu.config.noCheckPermissions && !await checkRelationPermission(cpu.config, cpu.gw, user, query)) {
+    if (!cpu.config.noCheckPermissions && !await checkRelationPermission(cpu.config, cpu.validFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     const req = query.r;

package/dist/cpu/request.js

@@ -5,7 +5,7 @@ export async function executeQuery(cpu, query, user) {
         return { err: true, msg: `Invalid query - db "${query.db || "undefined"}" not found`, c: 400 };
     const db = cpu.dbInstances[query.db];
     const operation = Object.keys(query.d)[0];
-    if (!cpu.config.noCheckPermissions && !await checkRequestPermission(cpu.config, cpu.gw, user, query)) {
+    if (!cpu.config.noCheckPermissions && !await checkRequestPermission(cpu.config, cpu.validFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     if (operation === "find") {

package/dist/cpu/string/index.d.ts

@@ -1,8 +1,2 @@
 import { VQL } from "../../types/vql.js";
-export type VQLParserMode = "VQLS" | "VQLM" | "VQLB" | "VQLR";
-export declare function guessParser(query: string): {
-    mode: VQLParserMode;
-    query: string;
-};
-declare function parseStringQuery(query: string): VQL;
-export { parseStringQuery };
+export declare function parseVQLS(query: string): VQL;

package/dist/cpu/string/index.js

@@ -1,56 +1,153 @@
-import logger from "../../logger.js";
-import { parseVQLB } from "./json5.js";
-import { parseVQLS } from "./simple.js";
-import { parseVQLM } from "./yaml.js";
-function get3rdAnd4thWord(query) {
-    let words = [];
-    let word = "";
-    let i = 0;
-    while (i < query.length && words.length < 4) {
-        const c = query[i++];
-        if (" \t\n\r".includes(c)) {
-            if (word)
-                words.push(word);
-            word = "";
+import { convertSearchObjToSearchArray, extractMeta } from "./utils.js";
+const aliases = {
+    s: "search",
+    f: "fields",
+    o: "options",
+    r: "relations",
+    d: "data",
+    e: "select",
+    u: "updater",
+};
+function parseArgs(input) {
+    const result = {};
+    const tokens = [];
+    let current = "";
+    let inQuotes = false;
+    let escape = false;
+    for (let i = 0; i < input.length; i++) {
+        const char = input[i];
+        if (escape) {
+            current += char;
+            escape = false;
+        }
+        else if (char === "\\") {
+            escape = true;
+        }
+        else if (char === "\"") {
+            inQuotes = !inQuotes;
+        }
+        else if (!inQuotes && (char === " " || char === "=")) {
+            if (current !== "") {
+                tokens.push(current);
+                current = "";
+            }
         }
         else {
-            word += c;
+            current += char;
+        }
+    }
+    if (current !== "") {
+        tokens.push(current);
+    }
+    for (let i = 0; i < tokens.length; i += 2) {
+        const key = tokens[i];
+        let value = tokens[i + 1] ?? true;
+        if (typeof value === "string") {
+            const trimmed = value.trim();
+            if (trimmed === "") {
+                value = true;
+            }
+            else if (/^".*"$/.test(trimmed)) {
+                value = trimmed.slice(1, -1);
+            }
+            else if (trimmed.toLowerCase() === "true") {
+                value = true;
+            }
+            else if (trimmed.toLowerCase() === "false") {
+                value = false;
+            }
+            else if (!isNaN(Number(trimmed))) {
+                value = Number(trimmed);
+            }
+            else if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
+                try {
+                    value = JSON.parse(trimmed);
+                }
+                catch { }
+            }
         }
+        result[key] = value;
     }
-    if (word && words.length < 4)
-        words.push(word);
-    return words[2] + (words[3] ? " " + words[3] : "");
+    return result;
 }
-export function guessParser(query) {
-    query = query.trimStart();
-    if (query[0] === "#") {
+function buildVQL(db, op, collection, query) {
+    const hasRelations = "relations" in query;
+    if (hasRelations) {
+        const relations = {};
+        for (const key in query.relations) {
+            const value = query.relations[key];
+            relations[key] = {
+                path: [value.db || db, value.c || key],
+                ...value
+            };
+            delete relations[key].db;
+            delete relations[key].c;
+        }
+        if ("select" in query) {
+            query.select = convertSearchObjToSearchArray(query.select);
+        }
         return {
-            mode: "VQL" + query[1].toUpperCase(),
-            query: query.slice(2)
+            r: {
+                path: [db, collection],
+                ...query,
+                relations,
+            }
+        };
+    }
+    else {
+        if (query.fields && !query.select) {
+            query.select = query.fields;
+            delete query.fields;
+        }
+        if ("select" in query) {
+            query.select = [...new Set(convertSearchObjToSearchArray(query.select).map(k => k[0]).flat())];
+        }
+        return {
+            db,
+            d: {
+                [op]: {
+                    collection,
+                    ...query,
+                }
+            }
         };
     }
-    const _34word = get3rdAnd4thWord(query);
-    let mode = "VQLS";
-    if (_34word.includes("{"))
-        mode = "VQLB";
-    else if (_34word.includes(":"))
-        mode = "VQLM";
-    return {
-        mode,
-        query
-    };
 }
-function parseStringQuery(query) {
-    const { mode, query: queryRaw } = guessParser(query);
-    logger.debug("Query mode: " + mode);
-    if (mode === "VQLB") {
-        return parseVQLB(queryRaw);
+export function parseVQLS(query) {
+    const { db, op, collection, body } = extractMeta(query);
+    const parsed = parseArgs(body);
+    for (const keysRaw of Object.keys(parsed)) {
+        const keys = keysRaw.split(".");
+        if (keys.length === 1) {
+            continue;
+        }
+        let obj = parsed;
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (i < keys.length - 1) {
+                if (!(key in obj)) {
+                    obj[key] = {};
+                }
+                obj = obj[key];
+            }
+            else {
+                obj[key] = parsed[keysRaw];
+                delete parsed[keysRaw];
+            }
+        }
+    }
+    for (const key in aliases) {
+        if (key in parsed) {
+            parsed[aliases[key]] = parsed[key];
+            delete parsed[key];
+        }
     }
-    else if (mode === "VQLM") {
-        return parseVQLM(queryRaw);
+    if ((op === "find" || op === "findOne") && !("search" in parsed)) {
+        parsed.search = {};
     }
-    else {
-        return parseVQLS(queryRaw);
+    if ((op === "update" || op === "remove") && !("updater" in parsed) && ("data" in parsed)) {
+        parsed.updater = parsed.data;
+        delete parsed.data;
     }
+    return buildVQL(db, op, collection, parsed);
 }
-export { parseStringQuery };

package/dist/cpu/string/utils.d.ts

@@ -15,3 +15,4 @@ export declare function extractMeta(input: string): {
     collection: string;
     body: string;
 };
+export declare function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys?: string[]): string[][];

package/dist/cpu/string/utils.js

@@ -87,3 +87,17 @@ function extendedCollectionToData(collection) {
     }
     return { op, collection: collectionName };
 }
+export function convertSearchObjToSearchArray(obj, parentKeys = []) {
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        const currentPath = [...parentKeys, key];
+        if (!value) {
+            return acc;
+        }
+        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
+        }
+        else {
+            return [...acc, currentPath];
+        }
+    }, []);
+}

package/dist/falconFrame.js

@@ -1,4 +1,4 @@
-import { parseStringQuery } 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 || (() => ({}));
@@ -18,7 +18,7 @@ export function FF_VQL(app, processor, options = {}) {
     if (options.dev) {
         app.get(path + "-query", (req, res) => {
             try {
-                return res.json(parseStringQuery(req.query?.query || ""));
+                return res.json(parseVQLS(req.query?.query || ""));
             }
             catch (e) {
                 res.status(500);

package/dist/gw.d.ts

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

package/dist/gw.js

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

package/dist/permissions/relation.d.ts

@@ -1,4 +1,4 @@
-import { GateWarden } from "@wxn0brp/gate-warden";
+import { ValidFn } from "../types/perm.js";
 import { RelationQuery } from "../types/vql.js";
 import { VQLConfig } from "../config.js";
-export declare function checkRelationPermission(config: VQLConfig, gw: GateWarden<any>, user: any, query: RelationQuery): Promise<boolean>;
+export declare function checkRelationPermission(config: VQLConfig, validFn: ValidFn, user: any, query: RelationQuery): Promise<boolean>;

package/dist/permissions/relation.js

@@ -1,11 +1,12 @@
 import { PermCRUD } from "../types/perm.js";
 import { extractPathsFromData, hashKey } from "./utils.js";
-export async function checkRelationPermission(config, gw, user, query) {
+export async function checkRelationPermission(config, validFn, user, query) {
     const { path, search, relations, select } = query.r;
     // Helper function to recursively check permissions with fallback mechanism
     const checkPermissionRecursively = async (entityId, fallbackLevels = []) => {
         // Check if the user has access to the current entity
-        const result = await gw.hasAccess(user.id, entityId, PermCRUD.READ);
+        // const result = await gw.hasAccess(user.id, entityId, PermCRUD.READ);
+        const result = await validFn(entityId, PermCRUD.READ, user);
         if (result.granted) {
             return true;
         }
@@ -42,7 +43,7 @@ export async function checkRelationPermission(config, gw, user, query) {
     if (relations) {
         for (const relationKey in relations) {
             const r = relations[relationKey];
-            if (!await checkRelationPermission(config, gw, user, { r })) {
+            if (!await checkRelationPermission(config, validFn, user, { r })) {
                 return false;
             }
         }

package/dist/permissions/request.d.ts

@@ -1,5 +1,4 @@
-import { GateWarden } from "@wxn0brp/gate-warden";
-import { PermCRUD } from "../types/perm.js";
+import { PermCRUD, ValidFn } from "../types/perm.js";
 import { VQLRequest } from "../types/vql.js";
 import { VQLConfig } from "../config.js";
 export declare function extractPaths(config: VQLConfig, query: VQLRequest): {
@@ -16,4 +15,4 @@ export declare function processFieldPath(pathObj: {
     path: string[];
     key: string;
 }): string[];
-export declare function checkRequestPermission(config: VQLConfig, gw: GateWarden<any>, user: any, query: VQLRequest): Promise<boolean>;
+export declare function checkRequestPermission(config: VQLConfig, validFn: ValidFn, user: any, query: VQLRequest): Promise<boolean>;

package/dist/permissions/request.js

@@ -79,14 +79,15 @@ export function processFieldPath(pathObj) {
     }
     return processedPath;
 }
-export async function checkRequestPermission(config, gw, user, query) {
+export async function checkRequestPermission(config, validFn, user, query) {
     if (!query)
         return false;
     const permPaths = extractPaths(config, query);
     // Helper function to recursively check permissions
     const checkPermissionRecursively = async (entityId, requiredPerm, fallbackLevels = []) => {
         // Check if the user has access to the current entity
-        const result = await gw.hasAccess(user.id, entityId, requiredPerm);
+        // const result = await gw.hasAccess(user.id, entityId, requiredPerm);
+        const result = await validFn(entityId, requiredPerm, user);
         if (result.granted) {
             return true;
         }

package/dist/processor.d.ts

@@ -1,13 +1,13 @@
 import { Relation, ValtheraCompatible } from "@wxn0brp/db-core";
-import { GateWarden } from "@wxn0brp/gate-warden";
-import { VQLConfig } from "./config.js";
+import { VQLConfig, VQLConfigInterface } from "./config.js";
 import { VQL, VQLError, VqlQueryRaw } from "./types/vql.js";
-export declare class VQLProcessor<GW = any> {
+import { ValidFn } from "./types/perm.js";
+export declare class VQLProcessor {
     dbInstances: Record<string, ValtheraCompatible>;
-    gw: GateWarden<GW>;
-    config: VQLConfig;
+    validFn: ValidFn;
     relation: Relation;
     preDefinedSheets: Map<string, VQL>;
-    constructor(dbInstances: Record<string, ValtheraCompatible>, gw?: GateWarden<GW>, config?: VQLConfig);
-    execute<T = any>(queryRaw: VqlQueryRaw<T>, user: any): Promise<T | VQLError>;
+    config: VQLConfig;
+    constructor(dbInstances: Record<string, ValtheraCompatible>, config?: VQLConfig | Partial<VQLConfigInterface>, validFn?: ValidFn);
+    execute<T = any>(queryRaw: VqlQueryRaw<T>, user?: any): Promise<T | VQLError>;
 }

package/dist/processor.js

@@ -2,23 +2,23 @@ import { Relation } from "@wxn0brp/db-core";
 import { VQLConfig } from "./config.js";
 import { executeRelation } from "./cpu/relation.js";
 import { executeQuery } from "./cpu/request.js";
-import { parseStringQuery } from "./cpu/string/index.js";
 import logger from "./logger.js";
 import { executeSheetAndReplaceVars } from "./sheet/index.js";
 import { validateRaw, validateVql } from "./valid.js";
+import { parseVQLS } from "./cpu/string/index.js";
 export class VQLProcessor {
     dbInstances;
-    gw;
-    config;
+    validFn;
     relation;
     preDefinedSheets = new Map();
-    constructor(dbInstances, gw = null, config = new VQLConfig()) {
+    config;
+    constructor(dbInstances, config = new VQLConfig(), validFn = async () => ({ granted: true, via: "" })) {
         this.dbInstances = dbInstances;
-        this.gw = gw;
-        this.config = config;
+        this.validFn = validFn;
         this.relation = new Relation(dbInstances);
+        this.config = config instanceof VQLConfig ? config : new VQLConfig(config);
     }
-    async execute(queryRaw, user) {
+    async execute(queryRaw, user = {}) {
         if (typeof queryRaw === "string" || "query" in queryRaw) {
             logger.info("Incoming string query");
             const q = typeof queryRaw === "string" ? queryRaw : queryRaw.query;
@@ -26,7 +26,7 @@ export class VQLProcessor {
             const ref = typeof queryRaw === "string" ? null : queryRaw.ref;
             logger.debug(q);
             try {
-                queryRaw = parseStringQuery(q);
+                queryRaw = parseVQLS(q);
                 logger.debug("transformed query: ", queryRaw);
             }
             catch (e) {
@@ -43,14 +43,14 @@ export class VQLProcessor {
             logger.info("Incoming object query");
             logger.debug("Raw query: ", queryRaw);
         }
-        const validateRawResult = validateRaw(this.config, queryRaw);
+        const validateRawResult = validateRaw(queryRaw);
         if (validateRawResult !== true) {
             logger.warn("Raw validation failed:", validateRawResult);
             return validateRawResult;
         }
         const query = executeSheetAndReplaceVars(queryRaw, this.preDefinedSheets, user);
         logger.debug("Executed sheet (expanded query):", query);
-        const validateVqlResult = validateVql(this.config, query);
+        const validateVqlResult = validateVql(query);
         if (validateVqlResult !== true) {
             logger.warn("VQL validation failed:", validateVqlResult);
             return validateVqlResult;

package/dist/types/perm.d.ts

@@ -5,3 +5,8 @@ export declare enum PermCRUD {
     DELETE = 8,
     COLLECTION = 16
 }
+export interface ValidFnResult {
+    granted: boolean;
+    via?: string;
+}
+export type ValidFn = (path: string, perm: number, user: any) => Promise<ValidFnResult>;

package/dist/valid.d.ts

@@ -1,6 +1,3 @@
-import Ajv from "ajv";
-import { VQLConfig } from "./config.js";
 import { VQL, VQLError, VQLR } from "./types/vql.js";
-export declare const ajv: Ajv;
-export declare function validateRaw(config: VQLConfig, query: VQLR): true | VQLError;
-export declare function validateVql(config: VQLConfig, query: VQL): true | VQLError;
+export declare function validateRaw(query: VQLR): true | VQLError;
+export declare function validateVql(query: VQL): true | VQLError;

package/dist/valid.js

@@ -1,38 +1,60 @@
-import Ajv from "ajv";
-import ajvFormat from "ajv-formats";
-import { readFileSync } from "fs";
-import { buildAjvErrorTree } from "./ajv.js";
-import { deepMerge } from "./merge.js";
-const filePath = import.meta.dirname + "/schema.json";
-const schema = JSON.parse(readFileSync(filePath, "utf-8"));
-export const ajv = new Ajv({
-    allowUnionTypes: true,
-    strict: false
-});
-ajvFormat(ajv);
-const validVQLR = ajv.compile(schema);
-const modSchema = schema;
-modSchema.anyOf = [
-    {
-        "$ref": "#/definitions/VQL"
-    }
-];
-const validVQL = ajv.compile(modSchema);
-export function validateRaw(config, query) {
-    if (!validVQLR(query)) {
-        let why = validVQLR.errors;
-        why = config.formatAjv ? buildAjvErrorTree(why) : why;
-        why = deepMerge(why, query);
-        return { err: true, msg: "Invalid query raw", c: 400, why };
-    }
+function emptyErr() {
+    return {
+        err: true,
+        msg: "Bad query",
+        c: 400
+    };
+}
+function isObj(obj, one = true) {
+    return typeof obj === "object" && obj !== null && !Array.isArray(obj) && (!one || Object.keys(obj).length !== 0);
+}
+export function validateRaw(query) {
+    if (("r" in query && isObj(query.r)) ||
+        ("db" in query && typeof query.db === "string" && isObj(query.d)) ||
+        ("ref" in query && isObj(query.ref)))
+        return true;
+    return emptyErr();
+}
+function validR(query) {
+    const { r } = query;
+    if (!("path" in r) || !Array.isArray(r.path) || r.path.length !== 2)
+        return emptyErr();
+    if (!isObj(r.search, false))
+        return emptyErr();
     return true;
 }
-export function validateVql(config, query) {
-    if (!validVQL(query)) {
-        let why = validVQL.errors;
-        why = config.formatAjv ? buildAjvErrorTree(why) : why;
-        why = deepMerge(why, query);
-        return { err: true, msg: "Invalid query", c: 400, why };
+function validD(query) {
+    const { d } = query;
+    const key = Object.keys(d)[0];
+    if (key === "getCollection")
+        return true;
+    const value = d[key];
+    if (typeof value.collection !== "string" || value.collection.trim() === "")
+        return emptyErr();
+    if (key === "issetCollection" || key === "ensureCollection")
+        return true;
+    if (key === "add") {
+        if (!isObj(value.data, false))
+            return emptyErr();
+        else
+            return true;
+    }
+    if ("search" in value && !isObj(value.search))
+        return emptyErr();
+    if (key === "find" || key === "findOne" || key === "remove" || key === "removeOne")
+        return true;
+    if (key === "update" || key === "updateOne" || key === "updateOneOrAdd") {
+        if (!isObj(value.updater, false))
+            return emptyErr();
+        else
+            return true;
     }
     return true;
 }
+export function validateVql(query) {
+    if ("r" in query && isObj(query.r))
+        return validR(query);
+    if ("d" in query && isObj(query.d))
+        return validD(query);
+    return emptyErr();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.5.1",
+  "version": "0.6.0-alpha.0",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -15,8 +15,9 @@
     "dist"
   ],
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.1.2",
-    "@wxn0brp/falcon-frame": ">=0.0.20"
+    "@wxn0brp/db-core": ">=0.1.4",
+    "@wxn0brp/falcon-frame": ">=0.0.20",
+    "@wxn0brp/gate-warden": ">=0.4.0"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/falcon-frame": {
@@ -24,26 +25,23 @@
     },
     "@wxn0brp/db-core": {
       "optional": false
+    },
+    "@wxn0brp/gate-warden": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@types/node": "^24.1.0",
     "@wxn0brp/db": "^0.30.0",
     "@wxn0brp/falcon-frame": "0.0.20",
+    "@wxn0brp/gate-warden": "^0.4.0",
     "dotenv": "^17.2.0",
     "esbuild": "^0.25.8",
-    "source-map-support": "^0.5.21",
     "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3",
-    "typescript-json-schema": "^0.65.1"
+    "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@wxn0brp/gate-warden": ">=0.4.0",
-    "@wxn0brp/lucerna-log": "^0.1.1",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
-    "js-yaml": "^4.1.0",
-    "json5": "^2.2.3"
+    "@wxn0brp/lucerna-log": "^0.1.1"
   },
   "exports": {
     ".": {

package/dist/ajv.d.ts

@@ -1,2 +0,0 @@
-import { ErrorObject } from "ajv";
-export declare function buildAjvErrorTree(errors: ErrorObject[]): Record<string, any>;

package/dist/ajv.js

@@ -1,80 +0,0 @@
-function parseInstancePath(path) {
-    if (!path)
-        return [];
-    const unescaped = path.slice(1).replace(/~0/g, "~").replace(/~1/g, "/");
-    return unescaped.split("/").filter(seg => seg !== "");
-}
-function formatSingleError(error) {
-    const { keyword, params, message } = error;
-    switch (keyword) {
-        case "type":
-            return `expected type: ${params.type}`;
-        case "required":
-            return `missing required property: ${params.missingProperty}`;
-        case "additionalProperties":
-            return `unexpected property: ${params.additionalProperty}`;
-        case "enum":
-            const allowedValues = params.allowedValues.join(", ");
-            return `value not in: [${allowedValues}]`;
-        case "minLength":
-            return `too short (min ${params.limit} characters)`;
-        case "maxLength":
-            return `too long (max ${params.limit} characters)`;
-        case "minimum":
-            return `value < ${params.limit}`;
-        case "maximum":
-            return `value > ${params.limit}`;
-        case "pattern":
-            return `does not match pattern`;
-        case "anyOf":
-            return `value does not satisfy any of the variants`;
-        case "oneOf":
-            return `value satisfies multiple variants`;
-        case "allOf":
-            return `value does not satisfy all conditions`;
-        default:
-            return message || `validation error: ${keyword}`;
-    }
-}
-// Recursively remove error types and leave only messages
-function finalizeNode(node) {
-    if (node.__errors) {
-        node.__errors = node.__errors.map((e) => e.message);
-    }
-    for (const key in node) {
-        if (key !== "__errors" && typeof node[key] === "object") {
-            finalizeNode(node[key]);
-        }
-    }
-}
-export function buildAjvErrorTree(errors) {
-    const errorTree = {};
-    for (const error of errors) {
-        const segments = parseInstancePath(error.instancePath);
-        let currentNode = errorTree;
-        for (const segment of segments) {
-            if (!(segment in currentNode)) {
-                currentNode[segment] = {};
-            }
-            currentNode = currentNode[segment];
-        }
-        const formattedMessage = formatSingleError(error);
-        const isComposite = ["anyOf", "oneOf", "allOf"].includes(error.keyword);
-        if (!currentNode.__errors) {
-            currentNode.__errors = [];
-        }
-        if (isComposite) {
-            // Replace all previous errors with only this general one
-            currentNode.__errors = [{ keyword: error.keyword, message: formattedMessage }];
-        }
-        else {
-            // Check if there is already a general error
-            const hasComposite = currentNode.__errors.some((e) => ["anyOf", "oneOf", "allOf"].includes(e.keyword));
-            if (!hasComposite) {
-                currentNode.__errors.push({ keyword: error.keyword, message: formattedMessage });
-            }
-        }
-    }
-    finalizeNode(errorTree);
-    return errorTree;
-}

package/dist/cpu/string/json5.d.ts

@@ -1,2 +0,0 @@
-import { VQL } from "../../types/vql.js";
-export declare function parseVQLB(query: string): VQL;

package/dist/cpu/string/json5.js

@@ -1,8 +0,0 @@
-import JSON5 from "json5";
-import { extractMeta } from "./utils.js";
-import { processVQL_MB } from "./middle.js";
-export function parseVQLB(query) {
-    const { db, op, collection, body } = extractMeta(query);
-    const parsed = JSON5.parse(body);
-    return processVQL_MB(db, op, collection, parsed);
-}

package/dist/cpu/string/middle.d.ts

@@ -1,3 +0,0 @@
-import { VQL } from "../../types/vql.js";
-export declare function processVQL_MB(db: string, op: string, collection: string, parsed: Record<string, any>): VQL;
-export declare function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys?: string[]): string[][];

package/dist/cpu/string/middle.js

@@ -1,41 +0,0 @@
-export function processVQL_MB(db, op, collection, parsed) {
-    return "relations" in parsed ?
-        processRelation_MB(db, collection, parsed) :
-        processQuery_MB(db, op, collection, parsed);
-}
-export function convertSearchObjToSearchArray(obj, parentKeys = []) {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        const currentPath = [...parentKeys, key];
-        if (!value) {
-            return acc;
-        }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
-        }
-        else {
-            return [...acc, currentPath];
-        }
-    }, []);
-}
-function processRelation_MB(db, collection, parsed) {
-    if ("select" in parsed && typeof parsed.select === "object" && !Array.isArray(parsed.select)) {
-        parsed.select = convertSearchObjToSearchArray(parsed.select);
-    }
-    return {
-        r: {
-            path: [parsed.db || db, parsed.c || collection],
-            ...parsed
-        }
-    };
-}
-function processQuery_MB(db, op, collection, parsed) {
-    return {
-        db,
-        d: {
-            [op]: {
-                collection,
-                ...parsed
-            }
-        }
-    };
-}

package/dist/cpu/string/simple.d.ts

@@ -1,2 +0,0 @@
-import { VQL } from "../../types/vql.js";
-export declare function parseVQLS(query: string): VQL;

package/dist/cpu/string/simple.js

@@ -1,155 +0,0 @@
-import { extractMeta } from "./utils.js";
-import JSON5 from "json5";
-import { convertSearchObjToSearchArray } from "./middle.js";
-const aliases = {
-    s: "search",
-    f: "fields",
-    o: "options",
-    r: "relations",
-    d: "data",
-    e: "select",
-    u: "updater",
-};
-function parseArgs(input) {
-    const result = {};
-    const tokens = [];
-    let current = "";
-    let inQuotes = false;
-    let escape = false;
-    for (let i = 0; i < input.length; i++) {
-        const char = input[i];
-        if (escape) {
-            current += char;
-            escape = false;
-        }
-        else if (char === "\\") {
-            escape = true;
-        }
-        else if (char === "\"") {
-            inQuotes = !inQuotes;
-        }
-        else if (!inQuotes && (char === " " || char === "=")) {
-            if (current !== "") {
-                tokens.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current !== "") {
-        tokens.push(current);
-    }
-    for (let i = 0; i < tokens.length; i += 2) {
-        const key = tokens[i];
-        let value = tokens[i + 1] ?? true;
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed === "") {
-                value = true;
-            }
-            else if (/^".*"$/.test(trimmed)) {
-                value = trimmed.slice(1, -1);
-            }
-            else if (trimmed.toLowerCase() === "true") {
-                value = true;
-            }
-            else if (trimmed.toLowerCase() === "false") {
-                value = false;
-            }
-            else if (!isNaN(Number(trimmed))) {
-                value = Number(trimmed);
-            }
-            else if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-                try {
-                    value = JSON5.parse(trimmed);
-                }
-                catch { }
-            }
-        }
-        result[key] = value;
-    }
-    return result;
-}
-function buildVQL(db, op, collection, query) {
-    const hasRelations = "relations" in query;
-    if (hasRelations) {
-        const relations = {};
-        for (const key in query.relations) {
-            const value = query.relations[key];
-            relations[key] = {
-                path: [value.db || db, value.c || key],
-                ...value
-            };
-            delete relations[key].db;
-            delete relations[key].c;
-        }
-        if ("select" in query) {
-            query.select = convertSearchObjToSearchArray(query.select);
-        }
-        return {
-            r: {
-                path: [db, collection],
-                ...query,
-                relations,
-            }
-        };
-    }
-    else {
-        if (query.fields && !query.select) {
-            query.select = query.fields;
-            delete query.fields;
-        }
-        if ("select" in query) {
-            query.select = [...new Set(convertSearchObjToSearchArray(query.select).map(k => k[0]).flat())];
-        }
-        return {
-            db,
-            d: {
-                [op]: {
-                    collection,
-                    ...query,
-                }
-            }
-        };
-    }
-}
-export function parseVQLS(query) {
-    const { db, op, collection, body } = extractMeta(query);
-    const parsed = parseArgs(body);
-    for (const keysRaw of Object.keys(parsed)) {
-        const keys = keysRaw.split(".");
-        if (keys.length === 1) {
-            continue;
-        }
-        let obj = parsed;
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            if (i < keys.length - 1) {
-                if (!(key in obj)) {
-                    obj[key] = {};
-                }
-                obj = obj[key];
-            }
-            else {
-                obj[key] = parsed[keysRaw];
-                delete parsed[keysRaw];
-            }
-        }
-    }
-    for (const key in aliases) {
-        if (key in parsed) {
-            parsed[aliases[key]] = parsed[key];
-            delete parsed[key];
-        }
-    }
-    if ((op === "find" || op === "findOne") && !("search" in parsed)) {
-        parsed.search = {};
-    }
-    if ((op === "update" || op === "remove") && !("updater" in parsed) && ("data" in parsed)) {
-        parsed.updater = parsed.data;
-        delete parsed.data;
-    }
-    return buildVQL(db, op, collection, parsed);
-}

package/dist/cpu/string/yaml.d.ts

@@ -1,2 +0,0 @@
-import { VQL } from "../../types/vql.js";
-export declare function parseVQLM(query: string): VQL;

package/dist/cpu/string/yaml.js

@@ -1,19 +0,0 @@
-import { processVQL_MB } from "./middle.js";
-import { extractMeta } from "./utils.js";
-import yaml from "js-yaml";
-export function parseVQLM(query) {
-    const { db, op, collection } = extractMeta(query);
-    let lineEndIndex = 0;
-    let foundNonWhitespace = false;
-    for (let i = 0; i < query.length; i++) {
-        if (!foundNonWhitespace && query[i] !== " " && query[i] !== "\t" && query[i] !== "\r" && query[i] !== "\n")
-            foundNonWhitespace = true;
-        if (foundNonWhitespace && query[i] === "\n") {
-            lineEndIndex = i;
-            break;
-        }
-    }
-    const body = query.slice(lineEndIndex + 1);
-    const parsed = yaml.load(body);
-    return processVQL_MB(db, op, collection, parsed);
-}

package/dist/schema.json

@@ -1 +0,0 @@
-{"anyOf":[{"$ref":"#/definitions/VQLRefRequired"},{"allOf":[{"$ref":"#/definitions/VQLRequest"},{"$ref":"#/definitions/VQLRef"}]},{"allOf":[{"$ref":"#/definitions/RelationQuery"},{"$ref":"#/definitions/VQLRef"}]},{"allOf":[{"$ref":"#/definitions/DeepPartial<VQLRequest&VQLRef>"},{"$ref":"#/definitions/VQLRef"},{"$ref":"#/definitions/Required<Pick<VQLRef,\"ref\">>"}]},{"allOf":[{"$ref":"#/definitions/DeepPartial<RelationQuery&VQLRef>"},{"$ref":"#/definitions/VQLRef"},{"$ref":"#/definitions/Required<Pick<VQLRef,\"ref\">>"}]}],"definitions":{"VQLRefRequired":{"allOf":[{"$ref":"#/definitions/VQLRef"},{"$ref":"#/definitions/Required<Pick<VQLRef,\"ref\">>"}]},"VQLRef":{"type":"object","properties":{"ref":{"type":"string"},"var":{"type":"object","additionalProperties":{}}}},"Required<Pick<VQLRef,\"ref\">>":{"type":"object","properties":{"ref":{"type":"string"}},"required":["ref"]},"VQLRequest":{"type":"object","properties":{"db":{"type":"string"},"d":{"$ref":"#/definitions/VQLQueryData"}},"required":["d","db"]},"VQLQueryData":{"anyOf":[{"type":"object","properties":{"find":{"$ref":"#/definitions/VQLFind"}},"required":["find"]},{"type":"object","properties":{"findOne":{"$ref":"#/definitions/VQLFindOne"}},"required":["findOne"]},{"type":"object","properties":{"f":{"$ref":"#/definitions/VQLFindOne"}},"required":["f"]},{"type":"object","properties":{"add":{"$ref":"#/definitions/VQLAdd"}},"required":["add"]},{"type":"object","properties":{"update":{"$ref":"#/definitions/VQLUpdate"}},"required":["update"]},{"type":"object","properties":{"updateOne":{"$ref":"#/definitions/VQLUpdateOne"}},"required":["updateOne"]},{"type":"object","properties":{"remove":{"$ref":"#/definitions/VQLRemove"}},"required":["remove"]},{"type":"object","properties":{"removeOne":{"$ref":"#/definitions/VQLRemoveOne"}},"required":["removeOne"]},{"type":"object","properties":{"updateOneOrAdd":{"$ref":"#/definitions/VQLUpdateOneOrAdd"}},"required":["updateOneOrAdd"]},{"type":"object","properties":{"removeCollection":{"$ref":"#/definitions/VQLCollectionOperation"}},"required":["removeCollection"]},{"type":"object","properties":{"ensureCollection":{"$ref":"#/definitions/VQLCollectionOperation"}},"required":["ensureCollection"]},{"type":"object","properties":{"issetCollection":{"$ref":"#/definitions/VQLCollectionOperation"}},"required":["issetCollection"]},{"type":"object","properties":{"getCollections":{"type":"object","properties":{}}},"required":["getCollections"]}]},"VQLFind":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"},"limit":{"type":"number"},"fields":{"$ref":"#/definitions/VQLFields"},"select":{"$ref":"#/definitions/VQLFields"},"relations":{"$ref":"#/definitions/VQLRelations"},"options":{"$ref":"#/definitions/DbFindOpts"},"searchOpts":{"$ref":"#/definitions/FindOpts"}},"required":["collection"]},"Search<any>":{"anyOf":[{"$ref":"#/definitions/SearchOptions","description":"SearchOptions can be either a function or an object with predefined operators."},{"type":"object"}]},"SearchOptions":{"description":"SearchOptions can be either a function or an object with predefined operators.","allOf":[{"description":"Logical Operators","type":"object","properties":{"$and":{"description":"Recursively applies multiple conditions, all of which must evaluate to true.\nCan include other operators such as $gt, $exists, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/SearchOptions"}},"$or":{"description":"Recursively applies multiple conditions, at least one of which must evaluate to true.\nCan include other operators such as $lt, $type, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/SearchOptions"}},"$not":{"$ref":"#/definitions/SearchOptions","description":"Negates a single condition.\nCan include any other operator as its value."}}},{"description":"Comparison Operators","type":"object","properties":{"$gt":{"$ref":"#/definitions/Record<string,number>"},"$lt":{"$ref":"#/definitions/Record<string,number>"},"$gte":{"$ref":"#/definitions/Record<string,number>"},"$lte":{"$ref":"#/definitions/Record<string,number>"},"$in":{"$ref":"#/definitions/Record<string,any[]>"},"$nin":{"$ref":"#/definitions/Record<string,any[]>"},"$between":{"$ref":"#/definitions/Record<string,[number,number]>"}}},{"description":"Type and Existence Operators","type":"object","properties":{"$exists":{"$ref":"#/definitions/Record<string,boolean>"},"$type":{"$ref":"#/definitions/Record<string,string>"}}},{"description":"Array Operators","type":"object","properties":{"$arrinc":{"$ref":"#/definitions/Record<string,any[]>"},"$arrincall":{"$ref":"#/definitions/Record<string,any[]>"},"$size":{"$ref":"#/definitions/Record<string,number>"}}},{"description":"String Operators","type":"object","properties":{"$regex":{"$ref":"#/definitions/Record<string,RegExp>"},"$startsWith":{"$ref":"#/definitions/Record<string,string>"},"$endsWith":{"$ref":"#/definitions/Record<string,string>"}}},{"description":"Other Operators","type":"object","properties":{"$subset":{"$ref":"#/definitions/Record<string,any>"}}},{"$ref":"#/definitions/Arg"}]},"Record<string,number>":{"type":"object"},"Record<string,any[]>":{"type":"object"},"Record<string,[number,number]>":{"type":"object"},"Record<string,boolean>":{"type":"object"},"Record<string,string>":{"type":"object"},"Record<string,RegExp>":{"type":"object"},"Record<string,any>":{"type":"object"},"Arg":{"type":"object","additionalProperties":{},"properties":{"_id":{"type":"string"}}},"VQLFields":{"anyOf":[{"type":"array","items":{"type":"string"}},{"$ref":"#/definitions/Record<string,number|boolean>"}]},"Record<string,number|boolean>":{"type":"object"},"VQLRelations":{"type":"object"},"DbFindOpts":{"type":"object","properties":{"reverse":{"type":"boolean"},"max":{"type":"number"},"offset":{"type":"number"},"sortBy":{"type":"string"},"sortAsc":{"type":"boolean"}}},"FindOpts":{"type":"object","properties":{"select":{"type":"array","items":{"type":"string"}},"exclude":{"type":"array","items":{"type":"string"}},"transform":{"$ref":"#/definitions/Function"}}},"Function":{"type":"object","properties":{"prototype":{},"length":{"type":"number"},"arguments":{},"caller":{"$ref":"#/definitions/Function"},"name":{"type":"string"}},"required":["arguments","caller","length","name","prototype"]},"VQLFindOne":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"},"fields":{"$ref":"#/definitions/VQLFields"},"select":{"$ref":"#/definitions/VQLFields"},"relations":{"$ref":"#/definitions/VQLRelations"},"searchOpts":{"$ref":"#/definitions/FindOpts"}},"required":["collection","search"]},"VQLAdd":{"type":"object","properties":{"collection":{"type":"string"},"data":{"$ref":"#/definitions/Arg"},"id_gen":{"type":"boolean"}},"required":["collection","data"]},"VQLUpdate":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"},"updater":{"$ref":"#/definitions/UpdaterArg"}},"required":["collection","search","updater"]},"UpdaterArg":{"allOf":[{"description":"Arrays","type":"object","properties":{"$push":{},"$pushset":{"description":"Pushes items into an array and removes duplicates"},"$pull":{},"$pullall":{}}},{"description":"Objects","type":"object","properties":{"$merge":{}}},{"description":"Values","type":"object","properties":{"$set":{},"$inc":{},"$dec":{},"$unset":{},"$rename":{}}},{"type":"object","additionalProperties":{}}]},"VQLUpdateOne":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"},"updater":{"$ref":"#/definitions/UpdaterArg"}},"required":["collection","search","updater"]},"VQLRemove":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"}},"required":["collection","search"]},"VQLRemoveOne":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"}},"required":["collection","search"]},"VQLUpdateOneOrAdd":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/Search<any>"},"updater":{"$ref":"#/definitions/UpdaterArg"},"add_arg":{"$ref":"#/definitions/Arg"},"id_gen":{"type":"boolean"}},"required":["collection","search","updater"]},"VQLCollectionOperation":{"type":"object","properties":{"collection":{"type":"string"}},"required":["collection"]},"RelationQuery":{"type":"object","properties":{"r":{"type":"object","properties":{"path":{"type":"array","items":[{"type":"string"},{"type":"string"}],"minItems":2,"maxItems":2},"search":{"$ref":"#/definitions/Search<any>"},"relations":{"$ref":"#/definitions/RelationTypes.Relation"},"many":{"type":"boolean"},"options":{"$ref":"#/definitions/DbFindOpts"},"select":{"type":"array","items":{"type":"array","items":{"type":"string"}}}},"required":["path","relations","search"]}},"required":["r"]},"RelationTypes.Relation":{"type":"object","additionalProperties":{"$ref":"#/definitions/RelationTypes.RelationConfig"}},"RelationTypes.RelationConfig":{"type":"object","properties":{"path":{"type":"array","items":[{"type":"string"},{"type":"string"}],"minItems":2,"maxItems":2},"pk":{"type":"string"},"fk":{"type":"string"},"as":{"type":"string"},"select":{"type":"array","items":{"type":"string"}},"findOpts":{"$ref":"#/definitions/DbFindOpts"},"type":{"enum":["1","11","1n","nm"],"type":"string"},"relations":{"$ref":"#/definitions/RelationTypes.Relation"},"through":{"type":"object","properties":{"table":{"type":"string"},"db":{"type":"string"},"pk":{"type":"string"},"fk":{"type":"string"}},"required":["fk","pk","table"]}},"required":["path"]},"DeepPartial<VQLRequest&VQLRef>":{"type":"object","properties":{"db":{"type":"string"},"d":{"$ref":"#/definitions/DeepPartial<VQLQueryData>"},"ref":{"type":"string"},"var":{"$ref":"#/definitions/DeepPartial<{[k:string]:any;}>"}}},"DeepPartial<VQLQueryData>":{"anyOf":[{"$ref":"#/definitions/DeepPartial<{find:VQLFind;}>"},{"$ref":"#/definitions/DeepPartial<{findOne:VQLFindOne;}>"},{"$ref":"#/definitions/DeepPartial<{f:VQLFindOne;}>"},{"$ref":"#/definitions/DeepPartial<{add:VQLAdd;}>"},{"$ref":"#/definitions/DeepPartial<{update:VQLUpdate;}>"},{"$ref":"#/definitions/DeepPartial<{updateOne:VQLUpdateOne;}>"},{"$ref":"#/definitions/DeepPartial<{remove:VQLRemove;}>"},{"$ref":"#/definitions/DeepPartial<{removeOne:VQLRemoveOne;}>"},{"$ref":"#/definitions/DeepPartial<{updateOneOrAdd:VQLUpdateOneOrAdd;}>"},{"$ref":"#/definitions/DeepPartial<{removeCollection:VQLCollectionOperation;}>"},{"$ref":"#/definitions/DeepPartial<{ensureCollection:VQLCollectionOperation;}>"},{"$ref":"#/definitions/DeepPartial<{issetCollection:VQLCollectionOperation;}>"},{"$ref":"#/definitions/DeepPartial<{getCollections:{};}>"}]},"DeepPartial<{find:VQLFind;}>":{"type":"object","properties":{"find":{"$ref":"#/definitions/DeepPartial<VQLFind>"}}},"DeepPartial<VQLFind>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"limit":{"type":"number"},"fields":{"$ref":"#/definitions/DeepPartial<VQLFields>"},"select":{"$ref":"#/definitions/DeepPartial<VQLFields>"},"relations":{"$ref":"#/definitions/DeepPartial<VQLRelations>"},"options":{"$ref":"#/definitions/DeepPartial<DbFindOpts>"},"searchOpts":{"$ref":"#/definitions/DeepPartial<FindOpts>"}}},"DeepPartial<Search<any>>":{"anyOf":[{"$ref":"#/definitions/DeepPartial<SearchOptions>"},{"$ref":"#/definitions/DeepPartial<SearchFunc<any>>"}]},"DeepPartial<SearchOptions>":{"type":"object","properties":{"$and":{"description":"Recursively applies multiple conditions, all of which must evaluate to true.\nCan include other operators such as $gt, $exists, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1"}},"$or":{"description":"Recursively applies multiple conditions, at least one of which must evaluate to true.\nCan include other operators such as $lt, $type, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1"}},"$not":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1","description":"Negates a single condition.\nCan include any other operator as its value."},"$gt":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$lt":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$gte":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$lte":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$in":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$nin":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$between":{"$ref":"#/definitions/DeepPartial<Record<string,[number,number]>>"},"$exists":{"$ref":"#/definitions/DeepPartial<Record<string,boolean>>"},"$type":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$arrinc":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$arrincall":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$size":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$regex":{"$ref":"#/definitions/DeepPartial<Record<string,RegExp>>"},"$startsWith":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$endsWith":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$subset":{"$ref":"#/definitions/DeepPartial<Record<string,any>>"},"_id":{"type":"string"}}},"DeepPartial<SearchOptions>_1":{"type":"object","properties":{"$and":{"description":"Recursively applies multiple conditions, all of which must evaluate to true.\nCan include other operators such as $gt, $exists, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1"}},"$or":{"description":"Recursively applies multiple conditions, at least one of which must evaluate to true.\nCan include other operators such as $lt, $type, or nested $and/$or conditions.","type":"array","items":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1"}},"$not":{"$ref":"#/definitions/DeepPartial<SearchOptions>_1","description":"Negates a single condition.\nCan include any other operator as its value."},"$gt":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$lt":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$gte":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$lte":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$in":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$nin":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$between":{"$ref":"#/definitions/DeepPartial<Record<string,[number,number]>>"},"$exists":{"$ref":"#/definitions/DeepPartial<Record<string,boolean>>"},"$type":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$arrinc":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$arrincall":{"$ref":"#/definitions/DeepPartial<Record<string,any[]>>"},"$size":{"$ref":"#/definitions/DeepPartial<Record<string,number>>"},"$regex":{"$ref":"#/definitions/DeepPartial<Record<string,RegExp>>"},"$startsWith":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$endsWith":{"$ref":"#/definitions/DeepPartial<Record<string,string>>"},"$subset":{"$ref":"#/definitions/DeepPartial<Record<string,any>>"},"_id":{"type":"string"}}},"DeepPartial<Record<string,number>>":{"type":"object"},"DeepPartial<Record<string,any[]>>":{"type":"object"},"DeepPartial<Record<string,[number,number]>>":{"type":"object"},"DeepPartial<Record<string,boolean>>":{"type":"object"},"DeepPartial<Record<string,string>>":{"type":"object"},"DeepPartial<Record<string,RegExp>>":{"type":"object"},"DeepPartial<Record<string,any>>":{"type":"object"},"DeepPartial<SearchFunc<any>>":{"type":"object"},"DeepPartial<VQLFields>":{"anyOf":[{"type":"array","items":{"type":"string"}},{"$ref":"#/definitions/DeepPartial<Record<string,number|boolean>>"}]},"DeepPartial<Record<string,number|boolean>>":{"type":"object"},"DeepPartial<VQLRelations>":{"type":"object"},"DeepPartial<DbFindOpts>":{"type":"object","properties":{"reverse":{"type":"boolean"},"max":{"type":"number"},"offset":{"type":"number"},"sortBy":{"type":"string"},"sortAsc":{"type":"boolean"}}},"DeepPartial<FindOpts>":{"type":"object","properties":{"select":{"type":"array","items":{"type":"string"}},"exclude":{"type":"array","items":{"type":"string"}},"transform":{"$ref":"#/definitions/DeepPartial<Function>"}}},"DeepPartial<Function>":{"type":"object","properties":{"apply":{"$ref":"#/definitions/DeepPartial<(this:Function,thisArg:any,argArray?:any)=>any>"},"call":{"$ref":"#/definitions/DeepPartial<(this:Function,thisArg:any,...argArray:any[])=>any>"},"bind":{"$ref":"#/definitions/DeepPartial<(this:Function,thisArg:any,...argArray:any[])=>any>_1"},"toString":{"$ref":"#/definitions/DeepPartial<()=>string>"},"prototype":{},"length":{"type":"number"},"arguments":{},"caller":{"$ref":"#/definitions/DeepPartial<Function>"},"name":{"type":"string"},"__@hasInstance@73":{"$ref":"#/definitions/DeepPartial<(value:any)=>boolean>"}}},"DeepPartial<(this:Function,thisArg:any,argArray?:any)=>any>":{"type":"object"},"DeepPartial<(this:Function,thisArg:any,...argArray:any[])=>any>":{"type":"object"},"DeepPartial<(this:Function,thisArg:any,...argArray:any[])=>any>_1":{"type":"object"},"DeepPartial<()=>string>":{"type":"object"},"DeepPartial<(value:any)=>boolean>":{"type":"object"},"DeepPartial<{findOne:VQLFindOne;}>":{"type":"object","properties":{"findOne":{"$ref":"#/definitions/DeepPartial<VQLFindOne>"}}},"DeepPartial<VQLFindOne>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"fields":{"$ref":"#/definitions/DeepPartial<VQLFields>"},"select":{"$ref":"#/definitions/DeepPartial<VQLFields>"},"relations":{"$ref":"#/definitions/DeepPartial<VQLRelations>"},"searchOpts":{"$ref":"#/definitions/DeepPartial<FindOpts>"}}},"DeepPartial<{f:VQLFindOne;}>":{"type":"object","properties":{"f":{"$ref":"#/definitions/DeepPartial<VQLFindOne>"}}},"DeepPartial<{add:VQLAdd;}>":{"type":"object","properties":{"add":{"$ref":"#/definitions/DeepPartial<VQLAdd>"}}},"DeepPartial<VQLAdd>":{"type":"object","properties":{"collection":{"type":"string"},"data":{"$ref":"#/definitions/DeepPartial<Arg>"},"id_gen":{"type":"boolean"}}},"DeepPartial<Arg>":{"type":"object","properties":{"_id":{"type":"string"}}},"DeepPartial<{update:VQLUpdate;}>":{"type":"object","properties":{"update":{"$ref":"#/definitions/DeepPartial<VQLUpdate>"}}},"DeepPartial<VQLUpdate>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"updater":{"$ref":"#/definitions/DeepPartial<UpdaterArg>"}}},"DeepPartial<UpdaterArg>":{"type":"object","properties":{"$push":{},"$pushset":{"description":"Pushes items into an array and removes duplicates"},"$pull":{},"$pullall":{},"$merge":{},"$set":{},"$inc":{},"$dec":{},"$unset":{},"$rename":{}}},"DeepPartial<{updateOne:VQLUpdateOne;}>":{"type":"object","properties":{"updateOne":{"$ref":"#/definitions/DeepPartial<VQLUpdateOne>"}}},"DeepPartial<VQLUpdateOne>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"updater":{"$ref":"#/definitions/DeepPartial<UpdaterArg>"}}},"DeepPartial<{remove:VQLRemove;}>":{"type":"object","properties":{"remove":{"$ref":"#/definitions/DeepPartial<VQLRemove>"}}},"DeepPartial<VQLRemove>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"}}},"DeepPartial<{removeOne:VQLRemoveOne;}>":{"type":"object","properties":{"removeOne":{"$ref":"#/definitions/DeepPartial<VQLRemoveOne>"}}},"DeepPartial<VQLRemoveOne>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"}}},"DeepPartial<{updateOneOrAdd:VQLUpdateOneOrAdd;}>":{"type":"object","properties":{"updateOneOrAdd":{"$ref":"#/definitions/DeepPartial<VQLUpdateOneOrAdd>"}}},"DeepPartial<VQLUpdateOneOrAdd>":{"type":"object","properties":{"collection":{"type":"string"},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"updater":{"$ref":"#/definitions/DeepPartial<UpdaterArg>"},"add_arg":{"$ref":"#/definitions/DeepPartial<Arg>"},"id_gen":{"type":"boolean"}}},"DeepPartial<{removeCollection:VQLCollectionOperation;}>":{"type":"object","properties":{"removeCollection":{"$ref":"#/definitions/DeepPartial<VQLCollectionOperation>"}}},"DeepPartial<VQLCollectionOperation>":{"type":"object","properties":{"collection":{"type":"string"}}},"DeepPartial<{ensureCollection:VQLCollectionOperation;}>":{"type":"object","properties":{"ensureCollection":{"$ref":"#/definitions/DeepPartial<VQLCollectionOperation>"}}},"DeepPartial<{issetCollection:VQLCollectionOperation;}>":{"type":"object","properties":{"issetCollection":{"$ref":"#/definitions/DeepPartial<VQLCollectionOperation>"}}},"DeepPartial<{getCollections:{};}>":{"type":"object","properties":{"getCollections":{"$ref":"#/definitions/DeepPartial<{}>"}}},"DeepPartial<{}>":{"type":"object"},"DeepPartial<{[k:string]:any;}>":{"type":"object"},"DeepPartial<RelationQuery&VQLRef>":{"type":"object","properties":{"r":{"$ref":"#/definitions/DeepPartial<{path:RelationTypes.Path;search:Search<any>;relations:RelationTypes.Relation;many?:boolean;options?:DbFindOpts;select?:RelationTypes.FieldPath[];}>"},"ref":{"type":"string"},"var":{"$ref":"#/definitions/DeepPartial<{[k:string]:any;}>"}}},"DeepPartial<{path:RelationTypes.Path;search:Search<any>;relations:RelationTypes.Relation;many?:boolean;options?:DbFindOpts;select?:RelationTypes.FieldPath[];}>":{"type":"object","properties":{"path":{"type":"array","items":[{"type":"string"},{"type":"string"}],"minItems":0,"maxItems":2},"search":{"$ref":"#/definitions/DeepPartial<Search<any>>"},"relations":{"$ref":"#/definitions/DeepPartial<RelationTypes.Relation>"},"many":{"type":"boolean"},"options":{"$ref":"#/definitions/DeepPartial<DbFindOpts>"},"select":{"type":"array","items":{"type":"array","items":{"type":"string"}}}}},"DeepPartial<RelationTypes.Relation>":{"type":"object"}},"$schema":"http://json-schema.org/draft-07/schema#"}