@wxn0brp/vql 0.6.0-alpha.1 → 0.6.0

package/dist/cpu/relation.d.ts

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

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.validFn, user, query)) {
+    if (!cpu.config.noCheckPermissions && !await checkRelationPermission(cpu.config, cpu.permValidFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     const req = query.r;

package/dist/cpu/request.d.ts

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

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.validFn, user, query)) {
+    if (!cpu.config.noCheckPermissions && !await checkRequestPermission(cpu.config, cpu.permValidFn, user, query)) {
         return { err: true, msg: "Permission denied", c: 403 };
     }
     if (operation === "find") {

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

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

package/dist/gw.d.ts

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

package/dist/permissions/relation.d.ts

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

package/dist/permissions/relation.js

@@ -1,12 +1,12 @@
 import { PermCRUD } from "../types/perm.js";
 import { extractPathsFromData, hashKey } from "./utils.js";
-export async function checkRelationPermission(config, validFn, user, query) {
+export async function checkRelationPermission(config, permValidFn, 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 validFn(entityId, PermCRUD.READ, user);
+        const result = await permValidFn(entityId, PermCRUD.READ, user);
         if (result.granted) {
             return true;
         }
@@ -43,7 +43,7 @@ export async function checkRelationPermission(config, validFn, user, query) {
     if (relations) {
         for (const relationKey in relations) {
             const r = relations[relationKey];
-            if (!await checkRelationPermission(config, validFn, user, { r })) {
+            if (!await checkRelationPermission(config, permValidFn, user, { r })) {
                 return false;
             }
         }

package/dist/permissions/request.d.ts

@@ -1,7 +1,7 @@
-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): Promise<{
+import { PermCRUD, PermValidFn } from "../types/perm.js";
+import { VQL_Query_CRUD } from "../types/vql.js";
+export declare function extractPaths(config: VQLConfig, query: VQL_Query_CRUD): Promise<{
     db: string;
     c: string;
     paths: {
@@ -15,4 +15,4 @@ export declare function processFieldPath(pathObj: {
     path: string[];
     key: string;
 }): string[];
-export declare function checkRequestPermission(config: VQLConfig, validFn: ValidFn, user: any, query: VQLRequest): Promise<boolean>;
+export declare function checkRequestPermission(config: VQLConfig, permValidFn: PermValidFn, user: any, query: VQL_Query_CRUD): Promise<boolean>;

package/dist/permissions/request.js

@@ -79,7 +79,7 @@ export function processFieldPath(pathObj) {
     }
     return processedPath;
 }
-export async function checkRequestPermission(config, validFn, user, query) {
+export async function checkRequestPermission(config, permValidFn, user, query) {
     if (!query)
         return false;
     const permPaths = await extractPaths(config, query);
@@ -87,7 +87,7 @@ export async function checkRequestPermission(config, validFn, user, query) {
     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 validFn(entityId, requiredPerm, user);
+        const result = await permValidFn(entityId, requiredPerm, user);
         if (result.granted) {
             return true;
         }

package/dist/processor.d.ts

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

package/dist/processor.js

@@ -8,12 +8,12 @@ import { validateRaw, validateVql } from "./valid.js";
 import { parseVQLS } from "./cpu/string/index.js";
 export class VQLProcessor {
     dbInstances;
-    validFn;
+    permValidFn;
     relation;
     config;
-    constructor(dbInstances, config = new VQLConfig(), validFn = async () => ({ granted: true, via: "" })) {
+    constructor(dbInstances, config = new VQLConfig(), permValidFn = async () => ({ granted: true, via: "" })) {
         this.dbInstances = dbInstances;
-        this.validFn = validFn;
+        this.permValidFn = permValidFn;
         this.relation = new Relation(dbInstances);
         this.config = config instanceof VQLConfig ? config : new VQLConfig(config);
     }
@@ -22,7 +22,6 @@ export class VQLProcessor {
             logger.info("Incoming string query");
             const q = typeof queryRaw === "string" ? queryRaw : queryRaw.query;
             const vars = typeof queryRaw === "string" ? null : queryRaw.var;
-            const ref = typeof queryRaw === "string" ? null : queryRaw.ref;
             logger.debug(q);
             try {
                 queryRaw = parseVQLS(q);
@@ -30,12 +29,10 @@ export class VQLProcessor {
             }
             catch (e) {
                 logger.error("Error parsing string query: ", { error: e, msg: e.message });
-                return { err: true, msg: "Invalid query", c: 400, why: `String query parsing error: ${e.message}` };
+                return { err: true, c: 400, msg: `String query parsing error: ${e.message}` };
             }
             if (vars)
                 queryRaw = { ...queryRaw, var: vars };
-            if (ref)
-                queryRaw = { ...queryRaw, ref };
             logger.debug("Final string query: ", queryRaw);
         }
         else {

package/dist/sheet.d.ts

@@ -1,2 +1,2 @@
-import { VQL, VQLR } from "./types/vql.js";
-export declare function replaceVars(query: VQLR, user: any): VQL;
+import { VQL_Query } from "./types/vql.js";
+export declare function replaceVars(query: VQL_Query, user: any): VQL_Query;

package/dist/types/perm.d.ts

@@ -9,4 +9,4 @@ export interface ValidFnResult {
     granted: boolean;
     via?: string;
 }
-export type ValidFn = (path: string, perm: number, user: any) => Promise<ValidFnResult>;
+export type PermValidFn = (path: string, perm: number, user: any) => Promise<ValidFnResult>;

package/dist/types/vql.d.ts

@@ -2,97 +2,79 @@ import { RelationTypes } from "@wxn0brp/db";
 import { Search, Arg } from "@wxn0brp/db-core/types/arg";
 import { DbFindOpts, FindOpts } from "@wxn0brp/db-core/types/options";
 import { UpdaterArg } from "@wxn0brp/db-core/types/updater";
-export interface VQLQuery<T = any> {
-    find: VQLFind<T>;
-    findOne: VQLFindOne<T>;
-    f: VQLFindOne<T>;
-    add: VQLAdd<T>;
-    update: VQLUpdate<T>;
-    updateOne: VQLUpdate<T>;
-    remove: VQLRemove<T>;
-    removeOne: VQLRemove<T>;
-    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-    removeCollection: VQLCollectionOperation;
-    ensureCollection: VQLCollectionOperation;
-    issetCollection: VQLCollectionOperation;
-    getCollections: {};
-}
-export type VQLQueryData<T = any> = {
-    find: VQLFind<T>;
-} | {
-    findOne: VQLFindOne<T>;
-} | {
-    f: VQLFindOne<T>;
-} | {
-    add: VQLAdd<T>;
-} | {
-    update: VQLUpdate<T>;
-} | {
-    updateOne: VQLUpdate<T>;
-} | {
-    remove: VQLRemove<T>;
-} | {
-    removeOne: VQLRemove<T>;
-} | {
-    updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-} | {
-    removeCollection: VQLCollectionOperation;
-} | {
-    ensureCollection: VQLCollectionOperation;
-} | {
-    issetCollection: VQLCollectionOperation;
-} | {
-    getCollections: {};
-};
-export interface VQLRequest<T = any> {
-    db: string;
-    d: VQLQueryData<T>;
-}
-export interface VQLFind<T = any> {
+export interface VQL_OP_Find<T = any> {
     collection: string;
     search?: Search<T>;
     limit?: number;
-    fields?: VQLFields;
-    select?: VQLFields;
-    relations?: VQLRelations;
+    fields?: VQL_Fields;
+    select?: VQL_Fields;
     options?: DbFindOpts<T>;
     searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne<T = any> {
+export interface VQL_OP_FindOne<T = any> {
     collection: string;
     search: Search<T>;
-    fields?: VQLFields;
-    select?: VQLFields;
-    relations?: VQLRelations;
+    fields?: VQL_Fields;
+    select?: VQL_Fields;
     searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd<T = any> {
+export interface VQL_OP_Add<T = any> {
     collection: string;
     data: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLUpdate<T = any> {
+export interface VQL_OP_Update<T = any> {
     collection: string;
     search: Search<T>;
     updater: UpdaterArg<T>;
 }
-export interface VQLRemove<T = any> {
+export interface VQL_OP_Remove<T = any> {
     collection: string;
     search: Search<T>;
 }
-export interface VQLUpdateOneOrAdd<T = any> {
+export interface VQL_OP_UpdateOneOrAdd<T = any> {
     collection: string;
     search: Search<T>;
     updater: UpdaterArg<T>;
     add_arg?: Arg<T>;
     id_gen?: boolean;
 }
-export interface VQLCollectionOperation {
+export interface VQL_OP_CollectionOperation {
     collection: string;
 }
-export type VQLFields = Record<string, boolean | number> | string[];
-export type VQLRelations = Record<string, VQLFind | VQLFindOne>;
-export interface RelationQuery {
+export type VQL_Fields = Record<string, boolean | number> | string[];
+export type VQL_Query_CRUD_Data<T = any> = {
+    find: VQL_OP_Find<T>;
+} | {
+    findOne: VQL_OP_FindOne<T>;
+} | {
+    f: VQL_OP_FindOne<T>;
+} | {
+    add: VQL_OP_Add<T>;
+} | {
+    update: VQL_OP_Update<T>;
+} | {
+    updateOne: VQL_OP_Update<T>;
+} | {
+    remove: VQL_OP_Remove<T>;
+} | {
+    removeOne: VQL_OP_Remove<T>;
+} | {
+    updateOneOrAdd: VQL_OP_UpdateOneOrAdd<T>;
+} | {
+    removeCollection: VQL_OP_CollectionOperation;
+} | {
+    ensureCollection: VQL_OP_CollectionOperation;
+} | {
+    issetCollection: VQL_OP_CollectionOperation;
+} | {
+    getCollections: {};
+};
+export interface VQL_Query_CRUD<T = any> {
+    db: string;
+    d: VQL_Query_CRUD_Data<T>;
+}
+export interface VQL_Query_Relation {
     r: {
         path: RelationTypes.Path;
         search: Search;
@@ -102,25 +84,19 @@ export interface RelationQuery {
         select?: RelationTypes.FieldPath[];
     };
 }
-export interface VQLRef {
-    ref?: string;
+export interface VQL_Var {
     var?: {
         [k: string]: any;
     };
 }
-type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
-type DeepPartial<T> = {
-    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-export type VQL<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
-export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
+/** VQL Query */
+export type VQL_Query<T = any> = (VQL_Query_CRUD<T> | VQL_Query_Relation) & VQL_Var;
+/** VQL Universal Query */
+export type VQLUQ<T = any> = VQL_Query<T> | string | {
+    query: string;
+} & VQL_Var;
 export interface VQLError {
     err: true;
     msg: string;
     c: number;
-    why?: string;
 }
-export type VqlQueryRaw<T = any> = VQLR<T> | string | {
-    query: string;
-} & VQLRef;
-export {};

package/dist/valid.d.ts

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

package/dist/valid.js

@@ -1,7 +1,7 @@
-function emptyErr() {
+function emptyErr(msg = "Bad query") {
     return {
         err: true,
-        msg: "Bad query",
+        msg,
         c: 400
     };
 }
@@ -10,51 +10,133 @@ function isObj(obj, one = true) {
 }
 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)))
+        ("db" in query && typeof query.db === "string" && isObj(query.d)))
         return true;
-    return emptyErr();
+    return emptyErr("Invalid VQL query structure. Must contain 'r' or 'db' and 'd'.");
+}
+function validateRelations(relations) {
+    if (!isObj(relations, false))
+        return emptyErr("The 'relations' property must be an object.");
+    for (const key in relations) {
+        const relation = relations[key];
+        if (!isObj(relation))
+            return emptyErr(`Relation '${key}' must be an object.`);
+        if (!("path" in relation) || !Array.isArray(relation.path) || relation.path.length !== 2)
+            return emptyErr(`Relation '${key}' must have a 'path' property with an array of two strings.`);
+        if ("search" in relation && !isObj(relation.search, false))
+            return emptyErr(`Relation '${key}' has an invalid 'search' property; it must be an object.`);
+        if ("many" in relation && typeof relation.many !== "boolean")
+            return emptyErr(`Relation '${key}' has an invalid 'many' property; it must be a boolean.`);
+        if ("options" in relation && !isObj(relation.options, false))
+            return emptyErr(`Relation '${key}' has an invalid 'options' property; it must be an object.`);
+        if ("select" in relation && !Array.isArray(relation.select))
+            return emptyErr(`Relation '${key}' has an invalid 'select' property; it must be an array.`);
+        if ("relations" in relation) {
+            const nestedResult = validateRelations(relation.relations);
+            if (nestedResult !== true)
+                return nestedResult;
+        }
+    }
+    return true;
 }
 function validR(query) {
     const { r } = query;
     if (!("path" in r) || !Array.isArray(r.path) || r.path.length !== 2)
-        return emptyErr();
+        return emptyErr("Relation query 'r' must have a 'path' property with an array of two strings.");
     if (!isObj(r.search, false))
-        return emptyErr();
+        return emptyErr("Relation query 'r.search' must be an object.");
+    if (!isObj(r.relations, false))
+        return emptyErr("Relation query 'r' must have a 'relations' object.");
+    const relationsValidation = validateRelations(r.relations);
+    if (relationsValidation !== true)
+        return relationsValidation;
+    if ("many" in r && typeof r.many !== "boolean")
+        return emptyErr("Relation query 'r.many' must be a boolean.");
+    if ("options" in r && !isObj(r.options, false))
+        return emptyErr("Relation query 'r.options' must be an object.");
+    if ("select" in r && !Array.isArray(r.select))
+        return emptyErr("Relation query 'r.select' must be an array.");
     return true;
 }
 function validD(query) {
     const { d } = query;
     const key = Object.keys(d)[0];
-    if (key === "getCollection")
+    const value = d[key]; // Cast for common property
+    if (key === "getCollections")
         return true;
-    const value = d[key];
     if (typeof value.collection !== "string" || value.collection.trim() === "")
-        return emptyErr();
-    if (key === "issetCollection" || key === "ensureCollection" || key === "removeCollection")
+        return emptyErr(`CRUD operation '${key}' must specify a non-empty 'collection' string.`);
+    if (key === "issetCollection" || key === "ensureCollection" || key === "removeCollection") {
         return true;
+    }
     if (key === "add") {
-        if (!isObj(value.data))
-            return emptyErr();
-        else
-            return true;
+        const op = d.add;
+        if (!isObj(op.data))
+            return emptyErr("'add' operation requires a 'data' object.");
+        if ("id_gen" in op && typeof op.id_gen !== "boolean")
+            return emptyErr("'add' operation 'id_gen' property must be a boolean.");
+        return true;
     }
-    if ("search" in value && !isObj(value.search, false))
-        return emptyErr();
-    if (key === "find" || key === "findOne" || key === "f" || key === "remove" || key === "removeOne")
+    if (key === "find") {
+        const op = d.find;
+        if ("search" in op && !isObj(op.search, false))
+            return emptyErr("'find' operation 'search' property must be an object.");
+        if ("limit" in op && typeof op.limit !== "number")
+            return emptyErr("'find' operation 'limit' property must be a number.");
+        if ("fields" in op && !isObj(op.fields, false) && !Array.isArray(op.fields))
+            return emptyErr("'find' operation 'fields' property must be an object or an array.");
+        if ("select" in op && !isObj(op.select, false) && !Array.isArray(op.select))
+            return emptyErr("'find' operation 'select' property must be an object or an array.");
+        if ("options" in op && !isObj(op.options, false))
+            return emptyErr("'find' operation 'options' property must be an object.");
+        if ("searchOpts" in op && !isObj(op.searchOpts, false))
+            return emptyErr("'find' operation 'searchOpts' property must be an object.");
         return true;
-    if (key === "update" || key === "updateOne" || key === "updateOneOrAdd") {
-        if (!isObj(value.updater, false))
-            return emptyErr();
-        else
-            return true;
     }
-    return true;
+    if (key === "findOne" || key === "f") {
+        const op = d.findOne || d.f;
+        if (!isObj(op.search, false))
+            return emptyErr(`'${key}' operation requires a 'search' object.`);
+        if ("fields" in op && !isObj(op.fields, false) && !Array.isArray(op.fields))
+            return emptyErr(`'${key}' operation 'fields' property must be an object or an array.`);
+        if ("select" in op && !isObj(op.select, false) && !Array.isArray(op.select))
+            return emptyErr(`'${key}' operation 'select' property must be an object or an array.`);
+        if ("searchOpts" in op && !isObj(op.searchOpts, false))
+            return emptyErr(`'${key}' operation 'searchOpts' property must be an object.`);
+        return true;
+    }
+    if (key === "remove" || key === "removeOne") {
+        const op = d.remove || d.removeOne;
+        if (!isObj(op.search, false))
+            return emptyErr(`'${key}' operation requires a 'search' object.`);
+        return true;
+    }
+    if (key === "update" || key === "updateOne") {
+        const op = d.update || d.updateOne;
+        if (!isObj(op.search, false))
+            return emptyErr(`'${key}' operation requires a 'search' object.`);
+        if (!isObj(op.updater, false))
+            return emptyErr(`'${key}' operation requires an 'updater' object.`);
+        return true;
+    }
+    if (key === "updateOneOrAdd") {
+        const op = d.updateOneOrAdd;
+        if (!isObj(op.search, false))
+            return emptyErr("'updateOneOrAdd' operation requires a 'search' object.");
+        if (!isObj(op.updater, false))
+            return emptyErr("'updateOneOrAdd' operation requires an 'updater' object.");
+        if ("add_arg" in op && !isObj(op.add_arg, false))
+            return emptyErr("'updateOneOrAdd' operation 'add_arg' property must be an object.");
+        if ("id_gen" in op && typeof op.id_gen !== "boolean")
+            return emptyErr("'updateOneOrAdd' operation 'id_gen' property must be a boolean.");
+        return true;
+    }
+    return emptyErr(`Unknown or invalid CRUD operation: '${key}'`);
 }
 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();
+    return emptyErr("Query must contain a valid 'r' (relation) or 'd' (database) property.");
 }

package/dist/vql.d.ts

@@ -189,97 +189,79 @@ declare namespace RelationTypes {
 		};
 	}
 }
-export interface VQLQuery<T = any> {
-	find: VQLFind<T>;
-	findOne: VQLFindOne<T>;
-	f: VQLFindOne<T>;
-	add: VQLAdd<T>;
-	update: VQLUpdate<T>;
-	updateOne: VQLUpdate<T>;
-	remove: VQLRemove<T>;
-	removeOne: VQLRemove<T>;
-	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-	removeCollection: VQLCollectionOperation;
-	ensureCollection: VQLCollectionOperation;
-	issetCollection: VQLCollectionOperation;
-	getCollections: {};
-}
-export type VQLQueryData<T = any> = {
-	find: VQLFind<T>;
-} | {
-	findOne: VQLFindOne<T>;
-} | {
-	f: VQLFindOne<T>;
-} | {
-	add: VQLAdd<T>;
-} | {
-	update: VQLUpdate<T>;
-} | {
-	updateOne: VQLUpdate<T>;
-} | {
-	remove: VQLRemove<T>;
-} | {
-	removeOne: VQLRemove<T>;
-} | {
-	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
-} | {
-	removeCollection: VQLCollectionOperation;
-} | {
-	ensureCollection: VQLCollectionOperation;
-} | {
-	issetCollection: VQLCollectionOperation;
-} | {
-	getCollections: {};
-};
-export interface VQLRequest<T = any> {
-	db: string;
-	d: VQLQueryData<T>;
-}
-export interface VQLFind<T = any> {
+export interface VQL_OP_Find<T = any> {
 	collection: string;
 	search?: Search<T>;
 	limit?: number;
-	fields?: VQLFields;
-	select?: VQLFields;
-	relations?: VQLRelations;
+	fields?: VQL_Fields;
+	select?: VQL_Fields;
 	options?: DbFindOpts<T>;
 	searchOpts?: FindOpts<T>;
 }
-export interface VQLFindOne<T = any> {
+export interface VQL_OP_FindOne<T = any> {
 	collection: string;
 	search: Search<T>;
-	fields?: VQLFields;
-	select?: VQLFields;
-	relations?: VQLRelations;
+	fields?: VQL_Fields;
+	select?: VQL_Fields;
 	searchOpts?: FindOpts<T>;
 }
-export interface VQLAdd<T = any> {
+export interface VQL_OP_Add<T = any> {
 	collection: string;
 	data: Arg<T>;
 	id_gen?: boolean;
 }
-export interface VQLUpdate<T = any> {
+export interface VQL_OP_Update<T = any> {
 	collection: string;
 	search: Search<T>;
 	updater: UpdaterArg<T>;
 }
-export interface VQLRemove<T = any> {
+export interface VQL_OP_Remove<T = any> {
 	collection: string;
 	search: Search<T>;
 }
-export interface VQLUpdateOneOrAdd<T = any> {
+export interface VQL_OP_UpdateOneOrAdd<T = any> {
 	collection: string;
 	search: Search<T>;
 	updater: UpdaterArg<T>;
 	add_arg?: Arg<T>;
 	id_gen?: boolean;
 }
-export interface VQLCollectionOperation {
+export interface VQL_OP_CollectionOperation {
 	collection: string;
 }
-export type VQLFields = Record<string, boolean | number> | string[];
-export type VQLRelations = Record<string, VQLFind | VQLFindOne>;
-export interface RelationQuery {
+export type VQL_Fields = Record<string, boolean | number> | string[];
+export type VQL_Query_CRUD_Data<T = any> = {
+	find: VQL_OP_Find<T>;
+} | {
+	findOne: VQL_OP_FindOne<T>;
+} | {
+	f: VQL_OP_FindOne<T>;
+} | {
+	add: VQL_OP_Add<T>;
+} | {
+	update: VQL_OP_Update<T>;
+} | {
+	updateOne: VQL_OP_Update<T>;
+} | {
+	remove: VQL_OP_Remove<T>;
+} | {
+	removeOne: VQL_OP_Remove<T>;
+} | {
+	updateOneOrAdd: VQL_OP_UpdateOneOrAdd<T>;
+} | {
+	removeCollection: VQL_OP_CollectionOperation;
+} | {
+	ensureCollection: VQL_OP_CollectionOperation;
+} | {
+	issetCollection: VQL_OP_CollectionOperation;
+} | {
+	getCollections: {};
+};
+export interface VQL_Query_CRUD<T = any> {
+	db: string;
+	d: VQL_Query_CRUD_Data<T>;
+}
+export interface VQL_Query_Relation {
 	r: {
 		path: RelationTypes.Path;
 		search: Search;
@@ -289,26 +271,21 @@ export interface RelationQuery {
 		select?: RelationTypes.FieldPath[];
 	};
 }
-export interface VQLRef {
-	ref?: string;
+export interface VQL_Var {
 	var?: {
 		[k: string]: any;
 	};
 }
-export type VQLRefRequired = VQLRef & Required<Pick<VQLRef, "ref">>;
-export type DeepPartial<T> = {
-	[P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
-};
-export type VQL<T = any> = (VQLRequest<T> | RelationQuery) & VQLRef;
-export type VQLR<T = any> = VQL<T> | (DeepPartial<VQL<T>> & VQLRefRequired) | VQLRefRequired;
+/** VQL Query */
+export type VQL_Query<T = any> = (VQL_Query_CRUD<T> | VQL_Query_Relation) & VQL_Var;
+/** VQL Universal Query */
+export type VQLUQ<T = any> = VQL_Query<T> | string | {
+	query: string;
+} & VQL_Var;
 export interface VQLError {
 	err: true;
 	msg: string;
 	c: number;
-	why?: string;
 }
-export type VqlQueryRaw<T = any> = VQLR<T> | string | {
-	query: string;
-} & VQLRef;
 
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.6.0-alpha.1",
+  "version": "0.6.0",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -35,7 +35,6 @@
     "@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",
     "tsc-alias": "^1.8.10",
     "typescript": "^5.7.3"