@wxn0brp/vql 0.6.0-alpha.0 → 0.6.0-beta.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/index.d.ts

@@ -4,6 +4,6 @@ import { createValtheraAdapter } from "./apiAbstract.js";
 import logger from "./logger.js";
 import { LogLevel } from "@wxn0brp/lucerna-log";
 import { FF_VQL } from "./falconFrame.js";
+import { createGwValidFn } from "./gw.js";
 export default VQLProcessor;
-export { createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL };
-export * as VQLSheet from "./sheet/load.js";
+export { VQLProcessor, createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL, createGwValidFn };

package/dist/index.js

@@ -4,6 +4,6 @@ import { createValtheraAdapter } from "./apiAbstract.js";
 import logger from "./logger.js";
 import { LogLevel } from "@wxn0brp/lucerna-log";
 import { FF_VQL } from "./falconFrame.js";
+import { createGwValidFn } from "./gw.js";
 export default VQLProcessor;
-export { createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL };
-export * as VQLSheet from "./sheet/load.js";
+export { VQLProcessor, createValtheraAdapter, VQLConfig, logger as VQLLogger, LogLevel as VQLLogLevel, FF_VQL, createGwValidFn };

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,32 +1,32 @@
 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;
         }
         // If the result is "entity-404", check the next fallback level
         if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
-            const nextFallbackEntityId = hashKey(config, fallbackLevels.slice(0, -1));
+            const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
             return checkPermissionRecursively(nextFallbackEntityId, fallbackLevels.slice(0, -2));
         }
         // If no fallback levels are left or the result is not "entity-404", deny access
         return false;
     };
     // Check permission for the relation field in the parent collection
-    if (!await checkPermissionRecursively(hashKey(config, path), path)) {
+    if (!await checkPermissionRecursively(await hashKey(config, path), path)) {
         return false;
     }
     // Check permissions for search fields
     const searchPaths = extractPathsFromData(search || {});
     for (const searchPath of searchPaths) {
         const key = [...path, ...searchPath.path, searchPath.key];
-        if (!await checkPermissionRecursively(hashKey(config, key), key)) {
+        if (!await checkPermissionRecursively(await hashKey(config, key), key)) {
             return false;
         }
     }
@@ -34,7 +34,7 @@ export async function checkRelationPermission(config, validFn, user, query) {
     if (select) {
         for (const fieldPath of select) {
             const key = [...path, fieldPath];
-            if (!await checkPermissionRecursively(hashKey(config, key), key)) {
+            if (!await checkPermissionRecursively(await hashKey(config, key), key)) {
                 return false;
             }
         }
@@ -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): {
+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: {
@@ -10,9 +10,9 @@ export declare function extractPaths(config: VQLConfig, query: VQLRequest): {
         c?: PermCRUD;
         path?: string[];
     }[];
-};
+}>;
 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

@@ -1,10 +1,10 @@
 import { PermCRUD } from "../types/perm.js";
 import { extractPathsFromData, hashKey } from "./utils.js";
-export function extractPaths(config, query) {
+export async function extractPaths(config, query) {
     const operation = Object.keys(query.d)[0];
     const collection = query.d[operation].collection;
     const permPaths = {
-        db: hashKey(config, query.db),
+        db: await hashKey(config, query.db),
         c: collection,
         paths: []
     };
@@ -79,21 +79,21 @@ 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 = extractPaths(config, query);
+    const permPaths = await extractPaths(config, query);
     // Helper function to recursively check permissions
     const checkPermissionRecursively = async (entityId, requiredPerm, fallbackLevels = []) => {
         // Check if the user has access to the current entity
         // const result = await gw.hasAccess(user.id, entityId, requiredPerm);
-        const result = await validFn(entityId, requiredPerm, user);
+        const result = await permValidFn(entityId, requiredPerm, user);
         if (result.granted) {
             return true;
         }
         // If the result is "entity-404", check the next fallback level
         if (!config.strictACL && result.via === "entity-404" && fallbackLevels.length > 0) {
-            const nextFallbackEntityId = hashKey(config, fallbackLevels.slice(0, -1));
+            const nextFallbackEntityId = await hashKey(config, fallbackLevels.slice(0, -1));
             return checkPermissionRecursively(nextFallbackEntityId, requiredPerm, fallbackLevels.slice(0, -2));
         }
         // If no fallback levels are left or the result is not "entity-404", deny access
@@ -107,7 +107,7 @@ export async function checkRequestPermission(config, validFn, user, query) {
         let fallbackLevels = [];
         if ("c" in path) {
             // Collection-level permission: hash the combination of db and collection
-            entityId = hashKey(config, [query.db, permPaths.c]);
+            entityId = await hashKey(config, [query.db, permPaths.c]);
             requiredPerm = path.c;
             // Fallback to database level if needed
             fallbackLevels = [query.db];

package/dist/permissions/utils.d.ts

@@ -1,5 +1,6 @@
 import { VQLConfig } from "../config.js";
-export declare function hashKey(config: VQLConfig, path: any): string;
+export declare function getHash(json: string): Promise<string>;
+export declare function hashKey(config: VQLConfig, path: any): Promise<string>;
 export declare function extractPathsFromData(data: any, stack?: string[]): {
     path: string[];
     key: string;

package/dist/permissions/utils.js

@@ -1,8 +1,20 @@
-import crypto from "crypto";
-export function hashKey(config, path) {
+let cryptoRef = null;
+export async function getHash(json) {
+    if (typeof window !== "undefined" && window.crypto?.subtle) {
+        const buffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(json));
+        return [...new Uint8Array(buffer)].map(b => b.toString(16).padStart(2, "0")).join("");
+    }
+    else {
+        if (!cryptoRef) {
+            cryptoRef = await import("crypto");
+        }
+        return cryptoRef.createHash("sha256").update(json).digest("hex");
+    }
+}
+export async function hashKey(config, path) {
     const json = JSON.stringify(path);
     if (config.hidePath)
-        return crypto.createHash("sha256").update(json).digest("hex");
+        return await getHash(json);
     else
         return json;
 }

package/dist/processor.d.ts

@@ -1,13 +1,12 @@
 import { Relation, ValtheraCompatible } from "@wxn0brp/db-core";
 import { VQLConfig, VQLConfigInterface } from "./config.js";
-import { VQL, 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;
-    preDefinedSheets: Map<string, VQL>;
     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

@@ -3,27 +3,25 @@ import { VQLConfig } from "./config.js";
 import { executeRelation } from "./cpu/relation.js";
 import { executeQuery } from "./cpu/request.js";
 import logger from "./logger.js";
-import { executeSheetAndReplaceVars } from "./sheet/index.js";
+import { replaceVars } from "./sheet.js";
 import { validateRaw, validateVql } from "./valid.js";
 import { parseVQLS } from "./cpu/string/index.js";
 export class VQLProcessor {
     dbInstances;
-    validFn;
+    permValidFn;
     relation;
-    preDefinedSheets = new Map();
     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);
     }
-    async execute(queryRaw, user = {}) {
+    async execute(queryRaw, user = { _id: "null-null-null" }) {
         if (typeof queryRaw === "string" || "query" in queryRaw) {
             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);
@@ -31,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 {
@@ -48,7 +44,7 @@ export class VQLProcessor {
             logger.warn("Raw validation failed:", validateRawResult);
             return validateRawResult;
         }
-        const query = executeSheetAndReplaceVars(queryRaw, this.preDefinedSheets, user);
+        const query = replaceVars(queryRaw, user);
         logger.debug("Executed sheet (expanded query):", query);
         const validateVqlResult = validateVql(query);
         if (validateVqlResult !== true) {

package/dist/sheet.d.ts

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

package/dist/sheet.js

@@ -0,0 +1,34 @@
+function replaceVariables(obj, variables) {
+    if (typeof obj === "object" && !Array.isArray(obj) && obj !== null && "__" in obj) {
+        const varKey = obj.__;
+        return variables[varKey] ?? obj;
+    }
+    if (typeof obj === "string") {
+        if (obj.startsWith("$"))
+            return variables[obj.slice(1)] ?? obj;
+        return obj;
+    }
+    if (Array.isArray(obj))
+        return obj.map((item) => replaceVariables(item, variables));
+    if (typeof obj === "object" && obj !== null) {
+        const newObj = {};
+        for (const key in obj) {
+            newObj[key] = replaceVariables(obj[key], variables);
+        }
+        return newObj;
+    }
+    return obj;
+}
+export function replaceVars(query, user) {
+    query.var = {
+        _me: user?.id || user?._id || user,
+        _now: Date.now(),
+        _nowShort: Math.floor(Date.now() / 1000),
+        __now: Date.now().toString(),
+        __nowShort: Math.floor(Date.now() / 1000).toString(),
+        ...(query.var || {})
+    };
+    query = replaceVariables(query, query.var);
+    delete query.var;
+    return 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,106 +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: VQLUpdateOne<T>;
-    remove: VQLRemove<T>;
-    removeOne: VQLRemoveOne<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: VQLUpdateOne<T>;
-} | {
-    remove: VQLRemove<T>;
-} | {
-    removeOne: VQLRemoveOne<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> {
-    collection: string;
-    search: Search<T>;
-    updater: UpdaterArg<T>;
-}
-export interface VQLUpdateOne<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 VQLRemoveOne<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;
@@ -111,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,136 @@ 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") {
+        if (Object.keys(value).length > 0)
+            return emptyErr("'getCollections' should be an empty object.");
         return true;
-    const value = d[key];
+    }
     if (typeof value.collection !== "string" || value.collection.trim() === "")
-        return emptyErr();
-    if (key === "issetCollection" || key === "ensureCollection")
+        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, false))
-            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))
-        return emptyErr();
-    if (key === "find" || key === "findOne" || 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,106 +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: VQLUpdateOne<T>;
-	remove: VQLRemove<T>;
-	removeOne: VQLRemoveOne<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: VQLUpdateOne<T>;
-} | {
-	remove: VQLRemove<T>;
-} | {
-	removeOne: VQLRemoveOne<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> {
-	collection: string;
-	search: Search<T>;
-	updater: UpdaterArg<T>;
-}
-export interface VQLUpdateOne<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 VQLRemoveOne<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;
@@ -298,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.0",
+  "version": "0.6.0-beta.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"

package/dist/sheet/index.d.ts

@@ -1,2 +0,0 @@
-import { VQL, VQLR } from "../types/vql.js";
-export declare function executeSheetAndReplaceVars(query: VQLR, preDefinedSheets: Map<string, VQL>, user: any): VQL;

package/dist/sheet/index.js

@@ -1,70 +0,0 @@
-import { deepMerge } from "../merge.js";
-function trimPath(path) {
-    return path && path.length > 2 ? path.slice(0, 2) : path;
-}
-function relationFix(relations) {
-    for (const key in relations) {
-        const value = relations[key];
-        value.path = trimPath(value.path);
-        if (value.relations) {
-            relationFix(value.relations);
-        }
-    }
-}
-function pathFix(vql) {
-    if ("d" in vql) {
-        const key = Object.keys(vql.d)[0];
-        const value = vql.d[key];
-        value.path = trimPath(value.path);
-    }
-    else if ("r" in vql) {
-        const value = vql.r;
-        value.path = trimPath(value.path);
-        if (value.relations) {
-            relationFix(value.relations);
-        }
-    }
-}
-function replaceVariables(obj, variables) {
-    if (typeof obj === "object" && !Array.isArray(obj) && obj !== null && "__" in obj) {
-        const varKey = obj.__;
-        return variables[varKey] ?? obj;
-    }
-    if (typeof obj === "string") {
-        if (obj.startsWith("$"))
-            return variables[obj.slice(1)] ?? obj;
-        return obj;
-    }
-    if (Array.isArray(obj))
-        return obj.map((item) => replaceVariables(item, variables));
-    if (typeof obj === "object" && obj !== null) {
-        const newObj = {};
-        for (const key in obj) {
-            newObj[key] = replaceVariables(obj[key], variables);
-        }
-        return newObj;
-    }
-    return obj;
-}
-export function executeSheetAndReplaceVars(query, preDefinedSheets, user) {
-    if ("ref" in query) {
-        if (preDefinedSheets.has(query.ref)) {
-            const ref = preDefinedSheets.get(query.ref);
-            const merge = deepMerge(query, ref);
-            pathFix(merge);
-            query = merge;
-        }
-        delete query.ref;
-    }
-    query.var = {
-        _me: user?.id || user?._id || user,
-        _now: Date.now(),
-        _nowShort: Math.floor(Date.now() / 1000),
-        __now: Date.now().toString(),
-        __nowShort: Math.floor(Date.now() / 1000).toString(),
-        ...(query.var || {})
-    };
-    query = replaceVariables(query, query.var);
-    delete query.var;
-    return query;
-}

package/dist/sheet/load.d.ts

@@ -1,3 +0,0 @@
-import { VQL } from "../types/vql.js";
-export declare function loadSheetsFromDir(dir: string): Map<string, VQL>;
-export declare function loadSheetFromFile(file: string): Map<string, VQL>;

package/dist/sheet/load.js

@@ -1,22 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs";
-function loadSheet(map, file) {
-    if (!existsSync(file)) {
-        throw new Error(`Sheet ${file} not found`);
-    }
-    const sheet = JSON.parse(readFileSync(file, "utf-8"));
-    for (const key in sheet) {
-        map.set(key, sheet[key]);
-    }
-}
-export function loadSheetsFromDir(dir) {
-    const map = new Map();
-    for (const file of readdirSync(dir)) {
-        loadSheet(map, `${dir}/${file}`);
-    }
-    return map;
-}
-export function loadSheetFromFile(file) {
-    const map = new Map();
-    loadSheet(map, file);
-    return map;
-}