@wxn0brp/vql 0.8.4 → 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 };

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/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.9.0",
   "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": "*",