@wxn0brp/vql 0.8.4 → 0.10.1

package/dist/cpu/relation.d.ts

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

package/dist/cpu/relation.js

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

package/dist/cpu/request.d.ts

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

package/dist/cpu/request.js

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

package/dist/helpers/apiAbstract.d.ts

@@ -1,5 +1,8 @@
+import { VQL_Query_CRUD_Keys } from "../types/vql.js";
 import { ValtheraCompatible } from "@wxn0brp/db-core";
-type ResolverFn<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => Promise<TReturn>;
+export type ResolverFn<TArgs extends any[] = any[], TReturn = any> = (...args: TArgs) => Promise<TReturn>;
+export type DropFirstFromTuple<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
+export type DropFirst<T> = T extends (...args: infer Args) => infer R ? (...args: DropFirstFromTuple<Args>) => R : never;
 export interface ValtheraResolverMeta {
     type: "valthera" | "api" | "wrapper" | (string & {});
     version: string;
@@ -18,47 +21,51 @@ 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: DropFirst<ValtheraResolver["add"]>): this;
+    add(collection: "*", fn: ValtheraResolver["add"]): this;
+    find(collection: (string & {}), fn: DropFirst<ValtheraResolver["find"]>): this;
+    find(collection: "*", fn: ValtheraResolver["find"]): this;
+    findOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["findOne"]>): this;
+    findOne(collection: "*", fn: ValtheraResolver["findOne"]): this;
+    update(collection: (string & {}), fn: DropFirst<ValtheraResolver["update"]>): this;
+    update(collection: "*", fn: ValtheraResolver["update"]): this;
+    updateOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["updateOne"]>): this;
+    updateOne(collection: "*", fn: ValtheraResolver["updateOne"]): this;
+    updateOneOrAdd(collection: (string & {}), fn: DropFirst<ValtheraResolver["updateOneOrAdd"]>): this;
+    updateOneOrAdd(collection: "*", fn: ValtheraResolver["updateOneOrAdd"]): this;
+    toggleOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["toggleOne"]>): this;
+    toggleOne(collection: "*", fn: ValtheraResolver["toggleOne"]): this;
+    remove(collection: (string & {}), fn: DropFirst<ValtheraResolver["remove"]>): this;
+    remove(collection: "*", fn: ValtheraResolver["remove"]): this;
+    removeOne(collection: (string & {}), fn: DropFirst<ValtheraResolver["removeOne"]>): this;
+    removeOne(collection: "*", fn: ValtheraResolver["removeOne"]): this;
+    removeCollection(collection: (string & {}), fn: DropFirst<ValtheraResolver["removeCollection"]>): this;
+    removeCollection(collection: "*", fn: ValtheraResolver["removeCollection"]): this;
     getAdapter(extendedFind?: boolean): ValtheraCompatible;
 }
-export {};

package/dist/helpers/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/gw.js

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

package/dist/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/permissions/relation.js

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

package/dist/permissions/request.js

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

package/dist/permissions/resolver.d.ts

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

package/dist/permissions/resolver.js

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

package/dist/processor.d.ts

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

package/dist/processor.js

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

package/dist/types/perm.d.ts

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

package/dist/types/resolver.d.ts

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

package/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,73 +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][]>>;
-	$idGt?: PartialOfType<T, string | number>;
-	$idLt?: PartialOfType<T, string | number>;
-	$idGte?: PartialOfType<T, string | number>;
-	$idLte?: PartialOfType<T, string | number>;
+	/** 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>;
-	$deepMerge?: 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>;
-	/** same as { name: value } */
-	$set?: 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>;
@@ -105,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;
@@ -126,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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.8.4",
+  "version": "0.10.1",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -27,7 +27,7 @@
     "query-language"
   ],
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.2.11",
+    "@wxn0brp/db-core": ">=0.3.0",
     "@wxn0brp/falcon-frame": ">=0.5.3",
     "@wxn0brp/gate-warden": ">=0.5.0"
   },
@@ -45,8 +45,8 @@
   "devDependencies": {
     "@types/bun": "*",
     "@types/node": "*",
-    "@wxn0brp/db": "^0.40.3",
-    "@wxn0brp/db-core": "^0.2.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": "*",