@wxn0brp/vql 0.8.3 → 0.9.0

package/dist/cpu/request.js

@@ -1,9 +1,12 @@
 import { checkRequestPermission } from "../permissions/index.js";
 import { parseSelect } from "./utils.js";
+import { LowAdapter } from "../helpers/lowAdapter.js";
 export async function executeQuery(cpu, query, user) {
     if (!query.db || !cpu.dbInstances[query.db])
         return { err: true, msg: `Invalid query - db "${query.db || "undefined"}" not found`, c: 400 };
     const db = cpu.dbInstances[query.db];
+    if (db instanceof LowAdapter)
+        return await db.resolver(query, user);
     const operation = Object.keys(query.d)[0];
     if (!cpu.config.noCheckPermissions && !await checkRequestPermission(cpu.config, cpu.permValidFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
@@ -51,6 +54,10 @@ export async function executeQuery(cpu, query, user) {
             opts.id_gen = params.id_gen;
         return db.updateOneOrAdd(params.collection, params.search, params.updater, opts);
     }
+    else if (operation === "toggleOne") {
+        const params = query.d[operation];
+        return db.toggleOne(params.collection, params.search, params.data);
+    }
     else if (operation === "removeCollection") {
         const params = query.d[operation];
         return db.removeCollection(params.collection);

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

@@ -0,0 +1 @@
+export declare function parseArgs(input: string): Record<string, any>;

package/dist/cpu/string/args.js

@@ -0,0 +1,102 @@
+export function parseArgs(input) {
+    const result = {};
+    const tokens = [];
+    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) {
+            current += char;
+            escape = false;
+        }
+        else if (char === "\\") {
+            escape = true;
+        }
+        else if (!inQuotes && (char === "{" || char === "[")) {
+            objTree++;
+            current += 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 = "";
+            }
+        }
+        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 = JSON.parse(trimmed);
+                }
+                catch { }
+            }
+        }
+        result[key] = value;
+    }
+    return result;
+}

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

@@ -0,0 +1,2 @@
+import { VQL_Query } from "../../types/vql.js";
+export declare function buildVQL(db: string, op: string, collection: string, query: Record<string, any>): VQL_Query;

package/dist/cpu/string/build.js

@@ -0,0 +1,44 @@
+import { convertSearchObjToSearchArray } from "./utils.js";
+export function buildVQL(db, op, collection, query) {
+    return "relations" in query ?
+        buildRelation(db, collection, query) :
+        buildQuery(db, op, collection, query);
+}
+function buildRelation(db, collection, query) {
+    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,
+        }
+    };
+}
+function buildQuery(db, op, collection, query) {
+    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,
+            }
+        }
+    };
+}

package/dist/cpu/string/index.js

@@ -1,4 +1,6 @@
-import { convertSearchObjToSearchArray, extractMeta } from "./utils.js";
+import { parseArgs } from "./args.js";
+import { buildVQL } from "./build.js";
+import { extractMeta } from "./utils.js";
 const aliases = {
     s: "search",
     f: "fields",
@@ -8,152 +10,6 @@ const aliases = {
     e: "select",
     u: "updater",
 };
-function parseArgs(input) {
-    const result = {};
-    const tokens = [];
-    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) {
-            current += char;
-            escape = false;
-        }
-        else if (char === "\\") {
-            escape = true;
-        }
-        else if (!inQuotes && (char === "{" || char === "[")) {
-            objTree++;
-            current += 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 = "";
-            }
-        }
-        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 = JSON.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);
@@ -167,7 +23,9 @@ export function parseVQLS(query) {
             const key = keys[i];
             if (i < keys.length - 1) {
                 if (!(key in obj)) {
-                    obj[key] = {};
+                    const nextKey = keys[i + 1];
+                    const isArrayIndex = /^\d+$/.test(nextKey);
+                    obj[key] = isArrayIndex ? [] : {};
                 }
                 obj = obj[key];
             }

package/dist/cpu/string/utils.js

@@ -2,13 +2,15 @@ const opPrefix = {
     "-": "remove",
     "+": "add",
     "~": "update",
+    "?": "updateOneOrAdd",
+    "^": "toggleOne"
 };
 const operations = [
     "add",
     "find", "findOne",
     "update", "updateOne",
     "remove", "removeOne",
-    "updateOneOrAdd",
+    "updateOneOrAdd", "toggleOne",
     "ensureCollection", "issetCollection",
 ];
 /**
@@ -55,7 +57,7 @@ export function extractMeta(input) {
     let collection = "";
     let body = "";
     // Determine operation and collection based on special characters
-    if (["!", "-", "+", "~"].some(c => split[0].includes(c)) || // Check if operation is indicated by special character
+    if (["!", "-", "+", "~", "?", "^"].some(c => split[0].includes(c)) || // Check if operation is indicated by special character
         [".", ":", "{"].some(c => split[1].includes(c)) // Check if query body is indicated by special character
     ) {
         let temp = split.shift();
@@ -93,7 +95,7 @@ export function convertSearchObjToSearchArray(obj, parentKeys = []) {
         if (!value) {
             return acc;
         }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+        else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
             return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
         }
         else {

package/dist/helpers/apiAbstract.d.ts

@@ -1,3 +1,4 @@
+import { VQL_Query_CRUD_Keys } from "../types/vql.js";
 import { ValtheraCompatible } from "@wxn0brp/db-core";
 type ResolverFn<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => Promise<TReturn>;
 export interface ValtheraResolverMeta {
@@ -18,47 +19,42 @@ export interface ValtheraResolver {
     find?: ResolverFn<[
         collection: string,
         search: any,
-        context?: any,
         options?: any,
-        findOpts?: any
+        findOpts?: any,
+        context?: any
     ], any[]>;
     findOne?: ResolverFn<[
         collection: string,
         search: any,
-        context?: any,
-        findOpts?: any
+        findOpts?: any,
+        context?: any
     ], any | null>;
     update?: ResolverFn<[collection: string, search: any, updater: any, context?: any], boolean>;
     updateOne?: ResolverFn<[collection: string, search: any, updater: any, context?: any], boolean>;
-    updateOneOrAdd?: ResolverFn<[
-        collection: string,
-        search: any,
-        updater: any,
-        add_arg?: any,
-        context?: any,
-        id_gen?: boolean
-    ], boolean>;
+    updateOneOrAdd?: ResolverFn<[collection: string, search: any, updater: any, opts?: any], boolean>;
+    toggleOne?: ResolverFn<[collection: string, search: any, data?: any, context?: any], boolean>;
     remove?: ResolverFn<[collection: string, search: any, context?: any], boolean>;
     removeOne?: ResolverFn<[collection: string, search: any, context?: any], boolean>;
     removeCollection?: ResolverFn<[collection: string], boolean>;
 }
+export type Operation = Exclude<VQL_Query_CRUD_Keys, "f">;
 export declare function createValtheraAdapter(resolver: ValtheraResolver, extendedFind?: boolean): ValtheraCompatible;
-export type Operation = "add" | "find" | "findOne" | "update" | "updateOne" | "updateOneOrAdd" | "remove" | "removeOne" | "removeCollection";
 export declare class AdapterBuilder {
     private catchCb;
     private handlers;
     private collections;
     constructor(catchCb?: (e: any, op: string, args: any[]) => void);
     register(op: Operation, collection: string, fn: Function): this;
-    add(collection: string, fn: ResolverFn<[data: any, id_gen?: boolean], any>): this;
-    find(collection: string, fn: ResolverFn<[search: any, context?: any, options?: any, findOpts?: any], any[]>): this;
-    findOne(collection: string, fn: ResolverFn<[search: any, context?: any, findOpts?: any], any | null>): this;
-    update(collection: string, fn: ResolverFn<[collection: string, search: any, updater: any], boolean>): this;
-    updateOne(collection: string, fn: ResolverFn<[search: any, updater: any], boolean>): this;
-    updateOneOrAdd(collection: string, fn: ResolverFn<[search: any, updater: any, add_arg?: any, context?: any, id_gen?: boolean], boolean>): this;
-    remove(collection: string, fn: ResolverFn<[search: any], boolean>): this;
-    removeOne(collection: string, fn: ResolverFn<[search: any], boolean>): this;
-    removeCollection(collection: string, fn: ResolverFn<[], boolean>): this;
+    add(collection: string, fn: ValtheraResolver["add"]): this;
+    find(collection: string, fn: ValtheraResolver["find"]): this;
+    findOne(collection: string, fn: ValtheraResolver["findOne"]): this;
+    update(collection: string, fn: ValtheraResolver["update"]): this;
+    updateOne(collection: string, fn: ValtheraResolver["updateOne"]): this;
+    updateOneOrAdd(collection: string, fn: ValtheraResolver["updateOneOrAdd"]): this;
+    toggleOne(collection: string, fn: ValtheraResolver["toggleOne"]): this;
+    remove(collection: string, fn: ValtheraResolver["remove"]): this;
+    removeOne(collection: string, fn: ValtheraResolver["removeOne"]): this;
+    removeCollection(collection: string, fn: ValtheraResolver["removeCollection"]): this;
     getAdapter(extendedFind?: boolean): ValtheraCompatible;
 }
 export {};

package/dist/helpers/apiAbstract.js

@@ -4,7 +4,8 @@ const list = [
     "ensureCollection", "issetCollection", "getCollections", "removeCollection",
     "add",
     "find", "findOne",
-    "update", "updateOne", "updateOneOrAdd",
+    "update", "updateOne",
+    "updateOneOrAdd", "toggleOne",
     "remove", "removeOne"
 ];
 export function createValtheraAdapter(resolver, extendedFind = false) {
@@ -26,8 +27,8 @@ export function createValtheraAdapter(resolver, extendedFind = false) {
             let data = await safe(resolver.find)(col, search, options, findOpts, context);
             if (options?.reverse)
                 data.reverse();
-            if (options?.max !== -1 && data.length > options?.max)
-                data = data.slice(0, options?.max);
+            if (options?.limit !== -1 && data.length > options?.limit)
+                data = data.slice(0, options?.limit);
             data = data.map(d => updateFindObject(d, findOpts || {}));
             return data;
         };
@@ -70,6 +71,9 @@ export class AdapterBuilder {
     updateOneOrAdd(collection, fn) {
         return this.register("updateOneOrAdd", collection, fn);
     }
+    toggleOne(collection, fn) {
+        return this.register("toggleOne", collection, fn);
+    }
     remove(collection, fn) {
         return this.register("remove", collection, fn);
     }
@@ -103,9 +107,8 @@ export class AdapterBuilder {
                 return true;
             },
         }, extendedFind);
-        for (const name of ["add", "find", "findOne", "update", "updateOne", "updateOneOrAdd", "remove", "removeOne", "removeCollection"]) {
+        for (const name of list.slice(4))
             adapter[name] = (...args) => resolve(name, ...args);
-        }
         return adapter;
     }
 }

package/dist/helpers/lowAdapter.d.ts

@@ -0,0 +1,6 @@
+import { VQL_Query_CRUD } from "../types/vql.js";
+export type LowResolver = (query: VQL_Query_CRUD, user: any) => Promise<any> | any;
+export declare class LowAdapter {
+    resolver: LowResolver;
+    constructor(resolver: LowResolver);
+}

package/dist/helpers/lowAdapter.js

@@ -0,0 +1,6 @@
+export class LowAdapter {
+    resolver;
+    constructor(resolver) {
+        this.resolver = resolver;
+    }
+}

package/dist/helpers/sheet.js

@@ -22,6 +22,7 @@ function replaceVariables(obj, variables) {
 export function replaceVars(query, user) {
     query.var = {
         _me: user?.id || user?._id || user,
+        _user: user,
         _now: Date.now(),
         _nowShort: Math.floor(Date.now() / 1000),
         __now: Date.now().toString(),

package/dist/helpers/valid.js

@@ -131,6 +131,15 @@ function validD(query) {
             return emptyErr("'updateOneOrAdd' operation 'id_gen' property must be a boolean.");
         return true;
     }
+    if (key === "toggleOne") {
+        const op = d.toggleOne;
+        if (!isObj(op.search, false))
+            return emptyErr("'toggleOne' operation requires a 'search' object.");
+        if ("data" in op && !isObj(op.data, false))
+            return emptyErr("'toggleOne' operation 'data' property must be an object.");
+        return true;
+    }
+    const n = key;
     return emptyErr(`Unknown or invalid CRUD operation: '${key}'`);
 }
 export function validateVql(query) {

package/dist/permissions/request.js

@@ -34,12 +34,19 @@ export async function extractPaths(config, query) {
             permPaths.paths.push({ filed: extractPathsFromData(qo.search), p: PermCRUD.READ });
             permPaths.paths.push({ filed: extractPathsFromData(qo.updater), p: PermCRUD.UPDATE });
             break;
+        case "toggleOne":
+            permPaths.paths.push({ c: PermCRUD.DELETE });
+            permPaths.paths.push({ c: PermCRUD.CREATE });
+            break;
         case "ensureCollection":
         case "getCollections":
         case "issetCollection":
         case "removeCollection":
             permPaths.paths.push({ c: PermCRUD.COLLECTION });
             break;
+        default:
+            const n = operation;
+            break;
     }
     permPaths.paths = (await Promise.all(permPaths.paths.map(async (path) => {
         if (!path.filed)

package/dist/types/vql.d.ts

@@ -39,6 +39,11 @@ export interface VQL_OP_UpdateOneOrAdd<T = any> {
     add_arg?: Arg<T>;
     id_gen?: boolean;
 }
+export interface VQL_OP_ToggleOne<T = any> {
+    collection: string;
+    search: Search<T>;
+    data?: Arg<T>;
+}
 export interface VQL_OP_CollectionOperation {
     collection: string;
 }
@@ -61,6 +66,8 @@ export type VQL_Query_CRUD_Data<T = any> = {
     removeOne: VQL_OP_Remove<T>;
 } | {
     updateOneOrAdd: VQL_OP_UpdateOneOrAdd<T>;
+} | {
+    toggleOne: VQL_OP_ToggleOne<T>;
 } | {
     removeCollection: VQL_OP_CollectionOperation;
 } | {
@@ -70,6 +77,7 @@ export type VQL_Query_CRUD_Data<T = any> = {
 } | {
     getCollections: {};
 };
+export type VQL_Query_CRUD_Keys = VQL_Query_CRUD_Data extends infer U ? U extends Record<string, unknown> ? keyof U : never : never;
 export interface VQL_Query_CRUD<T = any> {
     db: string;
     d: VQL_Query_CRUD_Data<T>;

package/dist/vql.d.ts

@@ -9,8 +9,14 @@ export interface VContext {
 export type KeysMatching<T, V, C = V> = {
 	[K in keyof T]-?: T[K] extends C ? K : never;
 }[keyof T];
-export type PartialOfType<T, V, C = V> = Partial<Record<KeysMatching<T, V, C>, V>>;
-export type PartialPickMatching<T, V, C = V> = Partial<Pick<T, KeysMatching<T, V, C>>>;
+/** Helper type for nested path values with type filtering */
+export type NestedValue<T, V, C = V> = {
+	[K in keyof T as T[K] extends C ? K : T[K] extends object ? K : never]?: T[K] extends C ? V : T[K] extends object ? NestedValue<T[K], V, C> : never;
+};
+/** Helper type for nested path structure */
+export type DeepPartial<T> = {
+	[K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};
 /** Logical Operators */
 export type LogicalOperators<T = any> = {
 	/**
@@ -29,66 +35,110 @@ export type LogicalOperators<T = any> = {
 	 */
 	$not?: SearchOptions<T>;
 };
-/** Comparison Operators */
+/** Comparison Operators with nested support */
 export type ComparisonOperators<T = any> = {
-	$gt?: PartialOfType<T, number>;
-	$lt?: PartialOfType<T, number>;
-	$gte?: PartialOfType<T, number>;
-	$lte?: PartialOfType<T, number>;
-	$between?: PartialOfType<T, [
+	/** 5 > 4 */
+	$gt?: NestedValue<T, number, number>;
+	/** 5 < 4 */
+	$lt?: NestedValue<T, number, number>;
+	/** 5 >= 4 */
+	$gte?: NestedValue<T, number, number>;
+	/** 5 <= 4 */
+	$lte?: NestedValue<T, number, number>;
+	/** 5 between [min, max] */
+	$between?: NestedValue<T, [
 		number,
 		number
 	], number>;
-	$in?: Partial<Record<keyof T, T[keyof T][]>>;
-	$nin?: Partial<Record<keyof T, T[keyof T][]>>;
+	/** 2 in [1, 2, 3] */
+	$in?: DeepPartial<T> & {
+		[K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
+	};
+	/** 5 not in [1, 2, 3] */
+	$nin?: DeepPartial<T> & {
+		[K in keyof T]?: T[K] extends any[] ? T[K] : T[K][];
+	};
+	/** id > 4 */
+	$idGt?: NestedValue<T, string | number, string | number>;
+	/** id < 4 */
+	$idLt?: NestedValue<T, string | number, string | number>;
+	/** id >= 4 */
+	$idGte?: NestedValue<T, string | number, string | number>;
+	/** id <= 4 */
+	$idLte?: NestedValue<T, string | number, string | number>;
 };
-/** Type and Existence Operators */
+/** Type and Existence Operators with nested support */
 export type TypeAndExistenceOperators<T = any> = {
-	$exists?: PartialOfType<T, boolean, any>;
-	$type?: PartialOfType<T, string>;
+	/** "name" in { name: "John" } */
+	$exists?: NestedValue<T, boolean>;
+	/** "name" == "string" in { name: "John" } */
+	$type?: NestedValue<T, string>;
 };
-/** Array Operators */
+/** Array Operators with nested support */
 export type ArrayOperators<T = any> = {
-	$arrinc?: PartialPickMatching<T, any[]>;
-	$arrincall?: PartialPickMatching<T, any[]>;
-	$size?: PartialOfType<T, number>;
+	/** [1, 2, 3] includes 2 */
+	$arrinc?: DeepPartial<T>;
+	/** [1, 2, 3] array includes all elements e.g. [1, 2] */
+	$arrincall?: DeepPartial<T>;
+	/** [1, 2, 3] has size 3 */
+	$size?: NestedValue<T, number>;
 };
-/** String Operators */
+/** String Operators with nested support */
 export type StringOperators<T = any> = {
-	$regex?: PartialOfType<T, RegExp | string, string>;
-	$startsWith?: PartialOfType<T, string>;
-	$endsWith?: PartialOfType<T, string>;
+	/** "John" matches /oh/ */
+	$regex?: NestedValue<T, RegExp | string, string>;
+	/** "John" starts with "Jo" */
+	$startsWith?: NestedValue<T, string, string>;
+	/** "John" ends with "hn" */
+	$endsWith?: NestedValue<T, string, string>;
 };
-/** Other Operators */
+/** Other Operators with nested support */
 export type OtherOperators<T = any> = {
-	$subset?: Partial<Record<keyof T, T[keyof T]>>;
+	/** { $type: "name" } matches { $type: "name" } literally - Ignore $ operators */
+	$subset?: DeepPartial<T>;
 };
 /** Predefined Search Operators */
 export type PredefinedSearchOperators<T = any> = LogicalOperators<T> & ComparisonOperators<T> & TypeAndExistenceOperators<T> & ArrayOperators<T> & StringOperators<T> & OtherOperators<T>;
 /**
  * SearchOptions can be either a function or an object with predefined operators.
  */
-export type SearchOptions<T = any> = PredefinedSearchOperators<T> & Arg<T>;
+export type SearchOptions<T = any> = PredefinedSearchOperators<T> & DeepPartial<T> & Record<string, any>;
 /** Arrays */
 export type ArrayUpdater<T = any> = {
-	$push?: PartialOfType<T, any>;
-	/** Pushes items into an array and removes duplicates */
-	$pushset?: PartialOfType<T, any>;
-	$pull?: PartialOfType<T, any>;
-	$pullall?: PartialOfType<T, any>;
+	/** [1,2] -> $push 3 -> [1,2,3] */
+	$push?: NestedValue<T, any>;
+	/** [1,2] -> $pushset 2,3 -> [1,2,3] */
+	$pushset?: NestedValue<T, any>;
+	/** [1,2,3] -> $pull 2 -> [1,3] */
+	$pull?: NestedValue<T, any>;
+	/** [1,2,2,3] -> $pullall [2] -> [1,3] */
+	$pullall?: NestedValue<T, any>;
 };
 /** Objects */
 export type ObjectUpdater<T = any> = {
-	$merge?: PartialOfType<T, any[]>;
+	/** { a: 1 } -> $merge { b: 2 } -> { a: 1, b: 2 } */
+	$merge?: NestedValue<T, any>;
+	/** { a: { x: 1 } } -> $deepMerge { a: { y: 2 } } -> { a: { x: 1, y: 2 } } */
+	$deepMerge?: NestedValue<T, any>;
 };
 /** Values */
 export type ValueUpdater<T = any> = {
-	$inc?: PartialOfType<T, number>;
-	$dec?: PartialOfType<T, number>;
-	$unset?: PartialOfType<T, any>;
-	$rename?: PartialOfType<T, any>;
+	/** { count: 1 } -> $inc 2 -> { count: 3 } */
+	$inc?: NestedValue<T, number>;
+	/** { count: 5 } -> $dec 2 -> { count: 3 } */
+	$dec?: NestedValue<T, number>;
+	/** { name: "John" } -> $unset "name" -> {} */
+	$unset?: NestedValue<T, any>;
+	/** { oldName: "value" } -> $rename "oldName" to "newName" -> { newName: "value" } */
+	$rename?: NestedValue<T, any>;
+	/**
+	 * {} -> $set { name: "John" } -> { name: "John" }
+	 *
+	 * Note: same as { name: value }
+	 */
+	$set?: NestedValue<T, any>;
 };
-export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & Arg<T>;
+export type UpdaterArg<T = any> = ArrayUpdater<T> & ObjectUpdater<T> & ValueUpdater<T> & DeepPartial<T> & Record<string, any>;
 export type Arg<T = any> = {
 	[K in keyof T]?: any;
 } & Record<string, any>;
@@ -98,7 +148,7 @@ export type Search<T = any> = SearchOptions<T> | SearchFunc<T>;
 export type Updater<T = any> = UpdaterArg<T> | UpdaterArg<T>[] | UpdaterFunc<T>;
 export interface DbFindOpts<T = any> {
 	reverse?: boolean;
-	max?: number;
+	limit?: number;
 	offset?: number;
 	sortBy?: KeysMatching<T, any>;
 	sortAsc?: boolean;
@@ -119,31 +169,35 @@ declare class CollectionManager<D = Data> {
 	/**
 	 * Find data in a database.
 	 */
-	find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T[]>;
+	find<T = Data>(search?: Search<T & D>, options?: DbFindOpts<T & D>, findOpts?: FindOpts<T & D>, context?: VContext): Promise<T[]>;
 	/**
 	 * Find one data entry in a database.
 	 */
-	findOne<T = Data>(search?: Search<T & Data>, findOpts?: FindOpts<T & Data>, context?: VContext): Promise<T>;
+	findOne<T = Data>(search?: Search<T & D>, findOpts?: FindOpts<T & D>, context?: VContext): Promise<T>;
 	/**
 	 * Update data in a database.
 	 */
-	update<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
+	update<T = Data>(search: Search<T & D>, updater: Updater<T & D>, context?: VContext): Promise<boolean>;
 	/**
 	 * Update one data entry in a database.
 	 */
-	updateOne<T = Data>(search: Search<T & Data>, updater: Updater<T & Data>, context?: VContext): Promise<boolean>;
+	updateOne<T = Data>(search: Search<T & D>, updater: Updater<T & D>, context?: VContext): Promise<boolean>;
 	/**
 	 * Remove data from a database.
 	 */
-	remove<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
+	remove<T = Data>(search: Search<T & D>, context?: VContext): Promise<boolean>;
 	/**
 	 * Remove one data entry from a database.
 	 */
-	removeOne<T = Data>(search: Search<T & Data>, context?: VContext): Promise<boolean>;
+	removeOne<T = Data>(search: Search<T & D>, context?: VContext): Promise<boolean>;
 	/**
 	 * 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, context, id_gen }: UpdateOneOrAdd<T & Data>): Promise<boolean>;
+	updateOneOrAdd<T = Data>(search: Search<T & D>, updater: Updater<T & D>, { add_arg, context, id_gen }: UpdateOneOrAdd<T & D>): Promise<boolean>;
+	/**
+	 * Asynchronously removes one entry in a database or adds a new one if it doesn't exist. Usage e.g. for toggling a flag.
+	 */
+	toggleOne<T = Data>(search: Search<T & D>, data?: Arg<T & D>, context?: VContext): Promise<boolean>;
 }
 export interface ValtheraCompatible {
 	c(collection: string): CollectionManager;
@@ -159,6 +213,7 @@ export interface ValtheraCompatible {
 	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>, opts?: UpdateOneOrAdd<T>): Promise<boolean>;
+	toggleOne<T = Data>(collection: string, search: Search<T>, data?: Arg<T>, context?: VContext): Promise<boolean>;
 }
 export interface UpdateOneOrAdd<T> {
 	add_arg?: Arg<T>;
@@ -231,6 +286,11 @@ export interface VQL_OP_UpdateOneOrAdd<T = any> {
 	add_arg?: Arg<T>;
 	id_gen?: boolean;
 }
+export interface VQL_OP_ToggleOne<T = any> {
+	collection: string;
+	search: Search<T>;
+	data?: Arg<T>;
+}
 export interface VQL_OP_CollectionOperation {
 	collection: string;
 }
@@ -253,6 +313,8 @@ export type VQL_Query_CRUD_Data<T = any> = {
 	removeOne: VQL_OP_Remove<T>;
 } | {
 	updateOneOrAdd: VQL_OP_UpdateOneOrAdd<T>;
+} | {
+	toggleOne: VQL_OP_ToggleOne<T>;
 } | {
 	removeCollection: VQL_OP_CollectionOperation;
 } | {
@@ -262,6 +324,7 @@ export type VQL_Query_CRUD_Data<T = any> = {
 } | {
 	getCollections: {};
 };
+export type VQL_Query_CRUD_Keys = VQL_Query_CRUD_Data extends infer U ? U extends Record<string, unknown> ? keyof U : never : never;
 export interface VQL_Query_CRUD<T = any> {
 	db: string;
 	d: VQL_Query_CRUD_Data<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -27,9 +27,9 @@
     "query-language"
   ],
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.2.5",
-    "@wxn0brp/falcon-frame": ">=0.5.1",
-    "@wxn0brp/gate-warden": ">=0.4.1"
+    "@wxn0brp/db-core": ">=0.3.0",
+    "@wxn0brp/falcon-frame": ">=0.5.3",
+    "@wxn0brp/gate-warden": ">=0.5.0"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/falcon-frame": {
@@ -43,17 +43,18 @@
     }
   },
   "devDependencies": {
+    "@types/bun": "*",
     "@types/node": "*",
-    "@wxn0brp/db": "^0.40.1",
-    "@wxn0brp/db-core": "^0.2.5",
-    "@wxn0brp/falcon-frame": "^0.5.1",
-    "@wxn0brp/gate-warden": "^0.4.1",
-    "esbuild": "^0.25.11",
+    "@wxn0brp/db": "^0.41.0",
+    "@wxn0brp/db-core": "^0.3.0",
+    "@wxn0brp/falcon-frame": "^0.5.3",
+    "@wxn0brp/gate-warden": "^0.5.0",
+    "esbuild": "*",
     "tsc-alias": "*",
     "typescript": "*"
   },
   "dependencies": {
-    "@wxn0brp/lucerna-log": "^0.2.1"
+    "@wxn0brp/lucerna-log": "^0.2.2"
   },
   "exports": {
     ".": {