@wxn0brp/vql 0.5.1 → 0.6.0-alpha.1

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

@@ -5,3 +5,8 @@ export declare enum PermCRUD {
     DELETE = 8,
     COLLECTION = 16
 }
+export interface ValidFnResult {
+    granted: boolean;
+    via?: string;
+}
+export type ValidFn = (path: string, perm: number, user: any) => Promise<ValidFnResult>;

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

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

package/dist/valid.js

@@ -1,38 +1,60 @@
-import Ajv from "ajv";
-import ajvFormat from "ajv-formats";
-import { readFileSync } from "fs";
-import { buildAjvErrorTree } from "./ajv.js";
-import { deepMerge } from "./merge.js";
-const filePath = import.meta.dirname + "/schema.json";
-const schema = JSON.parse(readFileSync(filePath, "utf-8"));
-export const ajv = new Ajv({
-    allowUnionTypes: true,
-    strict: false
-});
-ajvFormat(ajv);
-const validVQLR = ajv.compile(schema);
-const modSchema = schema;
-modSchema.anyOf = [
-    {
-        "$ref": "#/definitions/VQL"
-    }
-];
-const validVQL = ajv.compile(modSchema);
-export function validateRaw(config, query) {
-    if (!validVQLR(query)) {
-        let why = validVQLR.errors;
-        why = config.formatAjv ? buildAjvErrorTree(why) : why;
-        why = deepMerge(why, query);
-        return { err: true, msg: "Invalid query raw", c: 400, why };
-    }
+function emptyErr() {
+    return {
+        err: true,
+        msg: "Bad query",
+        c: 400
+    };
+}
+function isObj(obj, one = true) {
+    return typeof obj === "object" && obj !== null && !Array.isArray(obj) && (!one || Object.keys(obj).length !== 0);
+}
+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)))
+        return true;
+    return emptyErr();
+}
+function validR(query) {
+    const { r } = query;
+    if (!("path" in r) || !Array.isArray(r.path) || r.path.length !== 2)
+        return emptyErr();
+    if (!isObj(r.search, false))
+        return emptyErr();
     return true;
 }
-export function validateVql(config, query) {
-    if (!validVQL(query)) {
-        let why = validVQL.errors;
-        why = config.formatAjv ? buildAjvErrorTree(why) : why;
-        why = deepMerge(why, query);
-        return { err: true, msg: "Invalid query", c: 400, why };
+function validD(query) {
+    const { d } = query;
+    const key = Object.keys(d)[0];
+    if (key === "getCollection")
+        return true;
+    const value = d[key];
+    if (typeof value.collection !== "string" || value.collection.trim() === "")
+        return emptyErr();
+    if (key === "issetCollection" || key === "ensureCollection" || key === "removeCollection")
+        return true;
+    if (key === "add") {
+        if (!isObj(value.data))
+            return emptyErr();
+        else
+            return true;
+    }
+    if ("search" in value && !isObj(value.search, false))
+        return emptyErr();
+    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))
+            return emptyErr();
+        else
+            return true;
     }
     return true;
 }
+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();
+}

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.5.1",
+  "version": "0.6.0-alpha.1",
   "main": "dist/index.js",
   "author": "wxn0brP",
   "license": "MIT",
@@ -15,8 +15,9 @@
     "dist"
   ],
   "peerDependencies": {
-    "@wxn0brp/db-core": ">=0.1.2",
-    "@wxn0brp/falcon-frame": ">=0.0.20"
+    "@wxn0brp/db-core": ">=0.1.4",
+    "@wxn0brp/falcon-frame": ">=0.0.20",
+    "@wxn0brp/gate-warden": ">=0.4.0"
   },
   "peerDependenciesMeta": {
     "@wxn0brp/falcon-frame": {
@@ -24,26 +25,23 @@
     },
     "@wxn0brp/db-core": {
       "optional": false
+    },
+    "@wxn0brp/gate-warden": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@types/node": "^24.1.0",
     "@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",
-    "source-map-support": "^0.5.21",
     "tsc-alias": "^1.8.10",
-    "typescript": "^5.7.3",
-    "typescript-json-schema": "^0.65.1"
+    "typescript": "^5.7.3"
   },
   "dependencies": {
-    "@wxn0brp/gate-warden": ">=0.4.0",
-    "@wxn0brp/lucerna-log": "^0.1.1",
-    "ajv": "^8.17.1",
-    "ajv-formats": "^3.0.1",
-    "js-yaml": "^4.1.0",
-    "json5": "^2.2.3"
+    "@wxn0brp/lucerna-log": "^0.1.1"
   },
   "exports": {
     ".": {

package/dist/ajv.d.ts

@@ -1,2 +0,0 @@
-import { ErrorObject } from "ajv";
-export declare function buildAjvErrorTree(errors: ErrorObject[]): Record<string, any>;

package/dist/ajv.js

@@ -1,80 +0,0 @@
-function parseInstancePath(path) {
-    if (!path)
-        return [];
-    const unescaped = path.slice(1).replace(/~0/g, "~").replace(/~1/g, "/");
-    return unescaped.split("/").filter(seg => seg !== "");
-}
-function formatSingleError(error) {
-    const { keyword, params, message } = error;
-    switch (keyword) {
-        case "type":
-            return `expected type: ${params.type}`;
-        case "required":
-            return `missing required property: ${params.missingProperty}`;
-        case "additionalProperties":
-            return `unexpected property: ${params.additionalProperty}`;
-        case "enum":
-            const allowedValues = params.allowedValues.join(", ");
-            return `value not in: [${allowedValues}]`;
-        case "minLength":
-            return `too short (min ${params.limit} characters)`;
-        case "maxLength":
-            return `too long (max ${params.limit} characters)`;
-        case "minimum":
-            return `value < ${params.limit}`;
-        case "maximum":
-            return `value > ${params.limit}`;
-        case "pattern":
-            return `does not match pattern`;
-        case "anyOf":
-            return `value does not satisfy any of the variants`;
-        case "oneOf":
-            return `value satisfies multiple variants`;
-        case "allOf":
-            return `value does not satisfy all conditions`;
-        default:
-            return message || `validation error: ${keyword}`;
-    }
-}
-// Recursively remove error types and leave only messages
-function finalizeNode(node) {
-    if (node.__errors) {
-        node.__errors = node.__errors.map((e) => e.message);
-    }
-    for (const key in node) {
-        if (key !== "__errors" && typeof node[key] === "object") {
-            finalizeNode(node[key]);
-        }
-    }
-}
-export function buildAjvErrorTree(errors) {
-    const errorTree = {};
-    for (const error of errors) {
-        const segments = parseInstancePath(error.instancePath);
-        let currentNode = errorTree;
-        for (const segment of segments) {
-            if (!(segment in currentNode)) {
-                currentNode[segment] = {};
-            }
-            currentNode = currentNode[segment];
-        }
-        const formattedMessage = formatSingleError(error);
-        const isComposite = ["anyOf", "oneOf", "allOf"].includes(error.keyword);
-        if (!currentNode.__errors) {
-            currentNode.__errors = [];
-        }
-        if (isComposite) {
-            // Replace all previous errors with only this general one
-            currentNode.__errors = [{ keyword: error.keyword, message: formattedMessage }];
-        }
-        else {
-            // Check if there is already a general error
-            const hasComposite = currentNode.__errors.some((e) => ["anyOf", "oneOf", "allOf"].includes(e.keyword));
-            if (!hasComposite) {
-                currentNode.__errors.push({ keyword: error.keyword, message: formattedMessage });
-            }
-        }
-    }
-    finalizeNode(errorTree);
-    return errorTree;
-}

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

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

package/dist/cpu/string/json5.js

@@ -1,8 +0,0 @@
-import JSON5 from "json5";
-import { extractMeta } from "./utils.js";
-import { processVQL_MB } from "./middle.js";
-export function parseVQLB(query) {
-    const { db, op, collection, body } = extractMeta(query);
-    const parsed = JSON5.parse(body);
-    return processVQL_MB(db, op, collection, parsed);
-}

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

@@ -1,3 +0,0 @@
-import { VQL } from "../../types/vql.js";
-export declare function processVQL_MB(db: string, op: string, collection: string, parsed: Record<string, any>): VQL;
-export declare function convertSearchObjToSearchArray(obj: Record<string, any>, parentKeys?: string[]): string[][];

package/dist/cpu/string/middle.js

@@ -1,41 +0,0 @@
-export function processVQL_MB(db, op, collection, parsed) {
-    return "relations" in parsed ?
-        processRelation_MB(db, collection, parsed) :
-        processQuery_MB(db, op, collection, parsed);
-}
-export function convertSearchObjToSearchArray(obj, parentKeys = []) {
-    return Object.entries(obj).reduce((acc, [key, value]) => {
-        const currentPath = [...parentKeys, key];
-        if (!value) {
-            return acc;
-        }
-        else if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-            return [...acc, ...convertSearchObjToSearchArray(value, currentPath)];
-        }
-        else {
-            return [...acc, currentPath];
-        }
-    }, []);
-}
-function processRelation_MB(db, collection, parsed) {
-    if ("select" in parsed && typeof parsed.select === "object" && !Array.isArray(parsed.select)) {
-        parsed.select = convertSearchObjToSearchArray(parsed.select);
-    }
-    return {
-        r: {
-            path: [parsed.db || db, parsed.c || collection],
-            ...parsed
-        }
-    };
-}
-function processQuery_MB(db, op, collection, parsed) {
-    return {
-        db,
-        d: {
-            [op]: {
-                collection,
-                ...parsed
-            }
-        }
-    };
-}

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

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

package/dist/cpu/string/simple.js

@@ -1,155 +0,0 @@
-import { extractMeta } from "./utils.js";
-import JSON5 from "json5";
-import { convertSearchObjToSearchArray } from "./middle.js";
-const aliases = {
-    s: "search",
-    f: "fields",
-    o: "options",
-    r: "relations",
-    d: "data",
-    e: "select",
-    u: "updater",
-};
-function parseArgs(input) {
-    const result = {};
-    const tokens = [];
-    let current = "";
-    let inQuotes = false;
-    let escape = false;
-    for (let i = 0; i < input.length; i++) {
-        const char = input[i];
-        if (escape) {
-            current += char;
-            escape = false;
-        }
-        else if (char === "\\") {
-            escape = true;
-        }
-        else if (char === "\"") {
-            inQuotes = !inQuotes;
-        }
-        else if (!inQuotes && (char === " " || char === "=")) {
-            if (current !== "") {
-                tokens.push(current);
-                current = "";
-            }
-        }
-        else {
-            current += char;
-        }
-    }
-    if (current !== "") {
-        tokens.push(current);
-    }
-    for (let i = 0; i < tokens.length; i += 2) {
-        const key = tokens[i];
-        let value = tokens[i + 1] ?? true;
-        if (typeof value === "string") {
-            const trimmed = value.trim();
-            if (trimmed === "") {
-                value = true;
-            }
-            else if (/^".*"$/.test(trimmed)) {
-                value = trimmed.slice(1, -1);
-            }
-            else if (trimmed.toLowerCase() === "true") {
-                value = true;
-            }
-            else if (trimmed.toLowerCase() === "false") {
-                value = false;
-            }
-            else if (!isNaN(Number(trimmed))) {
-                value = Number(trimmed);
-            }
-            else if ((trimmed.startsWith("{") && trimmed.endsWith("}")) || (trimmed.startsWith("[") && trimmed.endsWith("]"))) {
-                try {
-                    value = JSON5.parse(trimmed);
-                }
-                catch { }
-            }
-        }
-        result[key] = value;
-    }
-    return result;
-}
-function buildVQL(db, op, collection, query) {
-    const hasRelations = "relations" in query;
-    if (hasRelations) {
-        const relations = {};
-        for (const key in query.relations) {
-            const value = query.relations[key];
-            relations[key] = {
-                path: [value.db || db, value.c || key],
-                ...value
-            };
-            delete relations[key].db;
-            delete relations[key].c;
-        }
-        if ("select" in query) {
-            query.select = convertSearchObjToSearchArray(query.select);
-        }
-        return {
-            r: {
-                path: [db, collection],
-                ...query,
-                relations,
-            }
-        };
-    }
-    else {
-        if (query.fields && !query.select) {
-            query.select = query.fields;
-            delete query.fields;
-        }
-        if ("select" in query) {
-            query.select = [...new Set(convertSearchObjToSearchArray(query.select).map(k => k[0]).flat())];
-        }
-        return {
-            db,
-            d: {
-                [op]: {
-                    collection,
-                    ...query,
-                }
-            }
-        };
-    }
-}
-export function parseVQLS(query) {
-    const { db, op, collection, body } = extractMeta(query);
-    const parsed = parseArgs(body);
-    for (const keysRaw of Object.keys(parsed)) {
-        const keys = keysRaw.split(".");
-        if (keys.length === 1) {
-            continue;
-        }
-        let obj = parsed;
-        for (let i = 0; i < keys.length; i++) {
-            const key = keys[i];
-            if (i < keys.length - 1) {
-                if (!(key in obj)) {
-                    obj[key] = {};
-                }
-                obj = obj[key];
-            }
-            else {
-                obj[key] = parsed[keysRaw];
-                delete parsed[keysRaw];
-            }
-        }
-    }
-    for (const key in aliases) {
-        if (key in parsed) {
-            parsed[aliases[key]] = parsed[key];
-            delete parsed[key];
-        }
-    }
-    if ((op === "find" || op === "findOne") && !("search" in parsed)) {
-        parsed.search = {};
-    }
-    if ((op === "update" || op === "remove") && !("updater" in parsed) && ("data" in parsed)) {
-        parsed.updater = parsed.data;
-        delete parsed.data;
-    }
-    return buildVQL(db, op, collection, parsed);
-}

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

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

package/dist/cpu/string/yaml.js

@@ -1,19 +0,0 @@
-import { processVQL_MB } from "./middle.js";
-import { extractMeta } from "./utils.js";
-import yaml from "js-yaml";
-export function parseVQLM(query) {
-    const { db, op, collection } = extractMeta(query);
-    let lineEndIndex = 0;
-    let foundNonWhitespace = false;
-    for (let i = 0; i < query.length; i++) {
-        if (!foundNonWhitespace && query[i] !== " " && query[i] !== "\t" && query[i] !== "\r" && query[i] !== "\n")
-            foundNonWhitespace = true;
-        if (foundNonWhitespace && query[i] === "\n") {
-            lineEndIndex = i;
-            break;
-        }
-    }
-    const body = query.slice(lineEndIndex + 1);
-    const parsed = yaml.load(body);
-    return processVQL_MB(db, op, collection, parsed);
-}