@wxn0brp/vql 0.6.0-alpha.0 → 0.6.0-alpha.1

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.js

@@ -12,21 +12,21 @@ export async function checkRelationPermission(config, validFn, user, query) {
         }
         // 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;
             }
         }

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): {
+export declare function extractPaths(config: VQLConfig, query: VQLRequest): Promise<{
     db: string;
     c: string;
     paths: {
@@ -10,7 +10,7 @@ export declare function extractPaths(config: VQLConfig, query: VQLRequest): {
         c?: PermCRUD;
         path?: string[];
     }[];
-};
+}>;
 export declare function processFieldPath(pathObj: {
     path: string[];
     key: string;

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: []
     };
@@ -82,7 +82,7 @@ export function processFieldPath(pathObj) {
 export async function checkRequestPermission(config, validFn, 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
@@ -93,7 +93,7 @@ export async function checkRequestPermission(config, validFn, user, query) {
         }
         // 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,12 +1,11 @@
 import { Relation, ValtheraCompatible } from "@wxn0brp/db-core";
 import { VQLConfig, VQLConfigInterface } from "./config.js";
-import { VQL, VQLError, VqlQueryRaw } from "./types/vql.js";
+import { VQLError, VqlQueryRaw } from "./types/vql.js";
 import { ValidFn } from "./types/perm.js";
 export declare class VQLProcessor {
     dbInstances: Record<string, ValtheraCompatible>;
     validFn: ValidFn;
     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>;

package/dist/processor.js

@@ -3,14 +3,13 @@ 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;
     relation;
-    preDefinedSheets = new Map();
     config;
     constructor(dbInstances, config = new VQLConfig(), validFn = async () => ({ granted: true, via: "" })) {
         this.dbInstances = dbInstances;
@@ -18,7 +17,7 @@ export class VQLProcessor {
         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;
@@ -48,7 +47,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, VQLR } from "./types/vql.js";
+export declare function replaceVars(query: VQLR, user: any): VQL;

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/vql.d.ts

@@ -8,9 +8,9 @@ export interface VQLQuery<T = any> {
     f: VQLFindOne<T>;
     add: VQLAdd<T>;
     update: VQLUpdate<T>;
-    updateOne: VQLUpdateOne<T>;
+    updateOne: VQLUpdate<T>;
     remove: VQLRemove<T>;
-    removeOne: VQLRemoveOne<T>;
+    removeOne: VQLRemove<T>;
     updateOneOrAdd: VQLUpdateOneOrAdd<T>;
     removeCollection: VQLCollectionOperation;
     ensureCollection: VQLCollectionOperation;
@@ -28,11 +28,11 @@ export type VQLQueryData<T = any> = {
 } | {
     update: VQLUpdate<T>;
 } | {
-    updateOne: VQLUpdateOne<T>;
+    updateOne: VQLUpdate<T>;
 } | {
     remove: VQLRemove<T>;
 } | {
-    removeOne: VQLRemoveOne<T>;
+    removeOne: VQLRemove<T>;
 } | {
     updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 } | {
@@ -76,19 +76,10 @@ export interface VQLUpdate<T = any> {
     search: Search<T>;
     updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne<T = any> {
-    collection: string;
-    search: Search<T>;
-    updater: UpdaterArg<T>;
-}
 export interface VQLRemove<T = any> {
     collection: string;
     search: Search<T>;
 }
-export interface VQLRemoveOne<T = any> {
-    collection: string;
-    search: Search<T>;
-}
 export interface VQLUpdateOneOrAdd<T = any> {
     collection: string;
     search: Search<T>;

package/dist/valid.js

@@ -31,17 +31,17 @@ function validD(query) {
     const value = d[key];
     if (typeof value.collection !== "string" || value.collection.trim() === "")
         return emptyErr();
-    if (key === "issetCollection" || key === "ensureCollection")
+    if (key === "issetCollection" || key === "ensureCollection" || key === "removeCollection")
         return true;
     if (key === "add") {
-        if (!isObj(value.data, false))
+        if (!isObj(value.data))
             return emptyErr();
         else
             return true;
     }
-    if ("search" in value && !isObj(value.search))
+    if ("search" in value && !isObj(value.search, false))
         return emptyErr();
-    if (key === "find" || key === "findOne" || key === "remove" || key === "removeOne")
+    if (key === "find" || key === "findOne" || key === "f" || key === "remove" || key === "removeOne")
         return true;
     if (key === "update" || key === "updateOne" || key === "updateOneOrAdd") {
         if (!isObj(value.updater, false))

package/dist/vql.d.ts

@@ -195,9 +195,9 @@ export interface VQLQuery<T = any> {
 	f: VQLFindOne<T>;
 	add: VQLAdd<T>;
 	update: VQLUpdate<T>;
-	updateOne: VQLUpdateOne<T>;
+	updateOne: VQLUpdate<T>;
 	remove: VQLRemove<T>;
-	removeOne: VQLRemoveOne<T>;
+	removeOne: VQLRemove<T>;
 	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 	removeCollection: VQLCollectionOperation;
 	ensureCollection: VQLCollectionOperation;
@@ -215,11 +215,11 @@ export type VQLQueryData<T = any> = {
 } | {
 	update: VQLUpdate<T>;
 } | {
-	updateOne: VQLUpdateOne<T>;
+	updateOne: VQLUpdate<T>;
 } | {
 	remove: VQLRemove<T>;
 } | {
-	removeOne: VQLRemoveOne<T>;
+	removeOne: VQLRemove<T>;
 } | {
 	updateOneOrAdd: VQLUpdateOneOrAdd<T>;
 } | {
@@ -263,19 +263,10 @@ export interface VQLUpdate<T = any> {
 	search: Search<T>;
 	updater: UpdaterArg<T>;
 }
-export interface VQLUpdateOne<T = any> {
-	collection: string;
-	search: Search<T>;
-	updater: UpdaterArg<T>;
-}
 export interface VQLRemove<T = any> {
 	collection: string;
 	search: Search<T>;
 }
-export interface VQLRemoveOne<T = any> {
-	collection: string;
-	search: Search<T>;
-}
 export interface VQLUpdateOneOrAdd<T = any> {
 	collection: string;
 	search: Search<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wxn0brp/vql",
-  "version": "0.6.0-alpha.0",
+  "version": "0.6.0-alpha.1",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",

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;
-}