@wxn0brp/db-string-query 0.0.7 → 0.0.9

package/dist/sql/where.js

@@ -1,5 +1,5 @@
 const operators = {
-    "=": "",
+    "=": null,
     "<": "$lt",
     ">": "$gt",
     "<=": "$lte",
@@ -8,6 +8,29 @@ const operators = {
     "IN": "$in",
     "NOT IN": "$nin"
 };
+function mergeQueries(target, source) {
+    for (const key in source) {
+        if (key.startsWith('$')) {
+            // If the key is an operator, simply add it
+            target[key] = source[key];
+        }
+        else {
+            // If the key is a field, check if there is not already an operator in the target
+            if (target[key] !== undefined) {
+                // If target[key] is an object with an operator, merge the objects
+                if (typeof target[key] === 'object' && !Array.isArray(target[key])) {
+                    Object.assign(target[key], source[key]);
+                }
+                else {
+                    target[key] = source[key];
+                }
+            }
+            else {
+                target[key] = source[key];
+            }
+        }
+    }
+}
 export function parseWhere(where) {
     if (!where)
         return {};
@@ -55,15 +78,21 @@ export function parseWhere(where) {
                     current = groupedQuery;
                 }
                 else if (op === "AND") {
-                    current = { ...parentCurrent, ...groupedQuery };
+                    const newCurrent = {};
+                    mergeQueries(newCurrent, parentCurrent);
+                    mergeQueries(newCurrent, groupedQuery);
+                    current = newCurrent;
                 }
             }
             else {
-                current = { ...parentCurrent, ...groupedQuery };
+                const newCurrent = {};
+                mergeQueries(newCurrent, parentCurrent);
+                mergeQueries(newCurrent, groupedQuery);
+                current = newCurrent;
             }
             // Restore parent's stack and operator stack
             operatorStack = parentFrame.operatorStack;
-            stack = parentStack;
+            stack = parentFrame.stack;
         }
         else if (token.toUpperCase() === "AND" || token.toUpperCase() === "OR") {
             operatorStack.push(token.toUpperCase());
@@ -79,10 +108,13 @@ export function parseWhere(where) {
                 }
             }
             let key = token;
-            let op = tokens[++i]?.trim();
+            if (key.includes(".")) {
+                key = key.split(".").pop();
+            }
+            let opToken = tokens[++i]?.trim();
             let value = tokens[++i]?.trim();
-            if (!key || !op || value === undefined) {
-                throw new Error(`Invalid condition near '${key} ${op} ${value}'`);
+            if (!key || !opToken || value === undefined) {
+                throw new Error(`Invalid condition near '${key} ${opToken} ${value}'`);
             }
             // Handle quoted values
             if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
@@ -93,9 +125,9 @@ export function parseWhere(where) {
                 value = Number(value);
             }
             // Handle IN and NOT IN operations
-            if (op.toUpperCase() === "IN" || op.toUpperCase() === "NOT IN") {
+            if (opToken.toUpperCase() === "IN" || opToken.toUpperCase() === "NOT IN") {
                 if (!value.startsWith("(") || !value.endsWith(")")) {
-                    throw new Error(`Invalid syntax for '${op}' near '${value}'`);
+                    throw new Error(`Invalid syntax for '${opToken}' near '${value}'`);
                 }
                 value = value.slice(1, -1).split(",").map((v) => {
                     v = v.trim();
@@ -105,18 +137,23 @@ export function parseWhere(where) {
                     return isNaN(Number(v)) ? v : Number(v);
                 });
             }
-            // Map the operator to MongoDB's query operators
-            const mappedOp = operators[op.toUpperCase()] || "";
-            if (mappedOp) {
-                if (mappedOp === "$not") {
-                    current[key] = { [mappedOp]: value };
+            // Map the operator to the query operators
+            const mappedOp = operators[opToken.toUpperCase()];
+            if (mappedOp !== undefined) {
+                if (mappedOp === null) {
+                    // "=" operator - direct assignment
+                    current[key] = value;
                 }
                 else {
-                    current[key] = current[key] || {};
-                    current[key][mappedOp] = value;
+                    // Other operators - they go to the root level
+                    if (!current[mappedOp]) {
+                        current[mappedOp] = {};
+                    }
+                    current[mappedOp][key] = value;
                 }
             }
             else {
+                // If operator not found, default to direct assignment
                 current[key] = value;
             }
         }
@@ -128,4 +165,4 @@ export function parseWhere(where) {
     }
     return current;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/types.d.ts

@@ -2,6 +2,10 @@ export interface ValtheraQuery {
     method: string;
     args: any[];
 }
+export interface Opts {
+    defaultDbKey: string;
+    tableDbMap?: Record<string, string>;
+}
 export interface ValtheraParser {
-    parse(query: string): ValtheraQuery;
+    parse(query: string, opts?: Opts): ValtheraQuery;
 }

package/package.json

@@ -1,44 +1,46 @@
 {
-    "name": "@wxn0brp/db-string-query",
-    "version": "0.0.7",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/wxn0brP/ValtheraDB-string-query.git"
+  "name": "@wxn0brp/db-string-query",
+  "version": "0.0.9",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wxn0brP/ValtheraDB-string-query.git"
+  },
+  "homepage": "https://github.com/wxn0brP/ValtheraDB-string-query",
+  "author": "wxn0brP",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "*",
+    "@types/node": "*",
+    "@wxn0brp/db-core": "^0.2.7",
+    "json5": "^2.2.3",
+    "tsc-alias": "*",
+    "typescript": "*"
+  },
+  "peerDependencies": {
+    "@wxn0brp/db-core": ">=0.2.7",
+    "json5": "^2.2.3"
+  },
+  "peerDependenciesMeta": {
+    "json5": {
+      "optional": true
     },
-    "homepage": "https://github.com/wxn0brP/ValtheraDB-string-query",
-    "author": "wxn0brP",
-    "license": "MIT",
-    "type": "module",
-    "scripts": {
-        "build": "tsc && tsc-alias",
-        "start": "node dist/index.js"
-    },
-    "devDependencies": {
-        "@types/node": "*",
-        "json5": "^2.2.3",
-        "tsc-alias": "*",
-        "typescript": "*"
-    },
-    "peerDependencies": {
-        "json5": "^2.2.3"
-    },
-    "peerDependenciesMeta": {
-        "json5": {
-            "optional": true
-        }
+    "@wxn0brp/db-core": {
+      "optional": true
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js",
+      "import": "./dist/index.js"
     },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js",
-            "import": "./dist/index.js"
-        },
-        "./*": {
-            "types": "./dist/*.d.ts",
-            "default": "./dist/*.js",
-            "import": "./dist/*.js"
-        }
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js",
+      "import": "./dist/*.js"
     }
+  }
 }

package/src/sql/handle/collection.ts

@@ -0,0 +1,28 @@
+import { parseReturn } from "../utils";
+
+export function handleGet(query: string) {
+    if (!/^GET\s+COLLECTIONS$/i.test(query)) {
+        throw new Error("Invalid GET COLLECTIONS syntax.");
+    }
+    return parseReturn("getCollections", []);
+}
+
+export function handleCreate(query: string) {
+    const match = query.match(
+        /^CREATE\s+(?:TABLE|COLLECTION)\s+(IF\s+NOT\s+EXISTS\s+)?(\w+).*/i
+    );
+    if (!match) throw new Error("Invalid CREATE TABLE/COLLECTION syntax.");
+    return parseReturn("ensureCollection", [match[2]]);
+}
+
+export function handleDrop(query: string) {
+    const match = query.match(/^DROP\s+(?:TABLE|COLLECTION)\s+(?:IF\s+EXISTS\s+)?(\w+)$/i);
+    if (!match) throw new Error("Invalid DROP TABLE/COLLECTION syntax.");
+    return parseReturn("removeCollection", [match[1]]);
+}
+
+export function handleExists(query: string) {
+    const match = query.match(/^EXISTS\s+(?:TABLE|COLLECTION)\s+(\w+)$/i);
+    if (!match) throw new Error("Invalid EXISTS TABLE/COLLECTION syntax.");
+    return parseReturn("issetCollection", [match[1]]);
+}

package/src/sql/handle/delete.ts

@@ -0,0 +1,12 @@
+import { parseReturn } from "#sql/utils";
+import { parseWhere } from "#sql/where";
+
+export function handleDelete(query: string) {
+    const match = query.match(/DELETE FROM ([\w\/]+)(?: WHERE (.+))?/i);
+    if (!match) throw new Error("Invalid DELETE syntax");
+
+    const collection = match[1];
+    const whereClause = match[2] ? parseWhere(match[2]) : {};
+
+    return parseReturn("remove", [collection, whereClause]);
+}

package/src/sql/handle/insert.ts

@@ -0,0 +1,50 @@
+import { parseReturn } from "#sql/utils";
+
+export function handleInsert(query: string) {
+    const match = query.match(/INSERT INTO ([\w\/]+)\s*\(([^)]+)\)\s*VALUES\s*\(([^)]+)\)/i);
+    if (!match) throw new Error("Invalid INSERT syntax");
+    const collection = match[1];
+    const keys = match[2].split(/\s*,\s*/);
+
+    function splitByCommasOutsideQuotes(str: string): string[] {
+        const tokens: string[] = [];
+        let current = '';
+        let inSingleQuote = false;
+        let inDoubleQuote = false;
+
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            if ((char === "'") && !inDoubleQuote) {
+                inSingleQuote = !inSingleQuote;
+                current += char;
+            } else if (char === '"' && !inSingleQuote) {
+                inDoubleQuote = !inDoubleQuote;
+                current += char;
+            } else if (char === ',' && !inSingleQuote && !inDoubleQuote) {
+                tokens.push(current);
+                current = '';
+            } else {
+                current += char;
+            }
+        }
+        tokens.push(current);
+        return tokens;
+    }
+
+    const rawValues = splitByCommasOutsideQuotes(match[3]);
+    const values = rawValues.map(v => {
+        v = v.trim();
+        if (v.length >= 2) {
+            if (v[0] === "'" && v[v.length - 1] === "'") {
+                v = v.substring(1, v.length - 1);
+            } else if (v[0] === '"' && v[v.length - 1] === '"') {
+                v = v.substring(1, v.length - 1);
+            }
+        }
+        return v;
+    });
+
+    if (keys.length !== values.length) throw new Error("Number of columns and values does not match");
+    const data = Object.fromEntries(keys.map((k, i) => [k, isNaN(values[i] as any) ? values[i] : Number(values[i])]));
+    return parseReturn("add", [collection, data]);
+}

package/src/sql/handle/select.ts

@@ -0,0 +1,68 @@
+import { parseReturn } from "#sql/utils";
+import { parseWhere } from "#sql/where";
+import { Opts } from "#types.js";
+import { JoinToRelationsEngine } from "../utils/join.util.js";
+
+export function handleSelect(
+    query: string,
+    opts?: Opts,
+) {
+    let whereClauseStr: string | undefined;
+    let mainQueryPart = query;
+
+    const whereIndex = query.toUpperCase().lastIndexOf(" WHERE ");
+    if (whereIndex !== -1) {
+        whereClauseStr = query.substring(whereIndex + 7).trim();
+        mainQueryPart = query.substring(0, whereIndex);
+    }
+
+    const match = mainQueryPart.match(/SELECT\s+(.+?)\s+FROM\s+([\w\/]+)((?:\s+JOIN\s+.+)*)?/i);
+    if (!match) throw new Error("Invalid SELECT syntax");
+
+    const columnsPart = match[1].trim();
+    const collection = match[2];
+    const joinPart = match[3] || "";
+    const whereClause = whereClauseStr ? parseWhere(whereClauseStr) : {};
+
+    const findOpts = parseSelectClause(columnsPart);
+
+    if (joinPart && opts?.defaultDbKey) {
+        const joinClauses = parseJoinClauses(joinPart);
+        const relationsEngine = new JoinToRelationsEngine(opts.defaultDbKey, opts.tableDbMap);
+        const relations = relationsEngine.buildRelations(joinClauses, collection);
+        const path = [opts.defaultDbKey, collection];
+        return parseReturn("relation-find", [path, whereClause, relations, findOpts]);
+    }
+
+    return parseReturn("find", [collection, whereClause, {}, findOpts]);
+}
+
+export function parseJoinClauses(joinPart: string): Record<string, string> {
+    const joinClauses: Record<string, string> = {};
+    const joinRegex = /\s+JOIN\s+([\w\/]+)(?:\s+AS\s+)?([\w\/]+)?\s+ON\s+([^\s]+)\s*=\s*([^\s]+)/gi;
+    let match;
+    while ((match = joinRegex.exec(joinPart)) !== null) {
+        const table = match[1];
+        const alias = match[2] || table;
+        const condition = `${match[3]} = ${match[4]}`;
+        joinClauses[alias] = condition;
+    }
+    return joinClauses;
+}
+
+export function parseSelectClause(selectClause: string): { select?: string[]; exclude?: string[] } {
+    selectClause = selectClause.trim();
+
+    if (selectClause === "*") return {};
+
+    const excludeMatch = selectClause.match(/\*\s+EXCLUDE\s+(.+)/i);
+    if (excludeMatch) {
+        return {
+            exclude: excludeMatch[1].split(/\s*,\s*/),
+        };
+    }
+
+    return {
+        select: selectClause.split(/\s*,\s*/),
+    };
+}

package/src/sql/handle/update.ts

@@ -0,0 +1,13 @@
+import { parseReturn, parseSet } from "#sql/utils";
+import { parseWhere } from "#sql/where";
+
+export function handleUpdate(query: string) {
+    const match = query.match(/UPDATE\s+([\w\/]+)\s+SET\s+(.+)\s+WHERE\s+(.+)/i);
+    if (!match) throw new Error("Invalid UPDATE syntax");
+
+    const collection = match[1];
+    const setClause = parseSet(match[2]);
+    const whereClause = parseWhere(match[3]);
+
+    return parseReturn("update", [collection, whereClause, setClause]);
+}

package/src/sql/index.ts

@@ -1,23 +1,22 @@
-import { ValtheraParser } from "../types";
-import {
-    handleCreate,
-    handleDelete,
-    handleDrop,
-    handleExists,
-    handleGet,
-    handleInsert,
-    handleSelect,
-    handleUpdate
-} from "./handle";
+import { Opts, ValtheraParser } from "../types";
+import { handleCreate, handleDrop, handleExists, handleGet } from "./handle/collection";
+import { handleDelete } from "./handle/delete";
+import { handleInsert } from "./handle/insert";
+import { handleSelect } from "./handle/select";
+import { handleUpdate } from "./handle/update";
 
 class SQLParser implements ValtheraParser {
-    parse(query: string) {
+    parse(
+        query: string,
+        opts?: Opts
+    ) {
         query = query.replace(/\s+/g, " ").trim();
+        if (query.endsWith(";")) query = query.slice(0, -1);
         const tokens = query.split(/\s+/);
         const method = tokens[0].toUpperCase();
 
         if (method === "SELECT") {
-            return handleSelect(query);
+            return handleSelect(query, opts);
         } else if (method === "INSERT") {
             return handleInsert(query);
         } else if (method === "UPDATE") {

package/src/sql/utils/join.util.ts

@@ -0,0 +1,73 @@
+import { RelationTypes } from "@wxn0brp/db-core";
+export type JoinClause = Record<string, string>;
+
+export class JoinToRelationsEngine {
+    private knownForeignKeys: Set<string> = new Set();
+
+    constructor(
+        private defaultDbKey: string,
+        private tableDbMap?: Record<string, string>
+    ) { }
+
+    private identifyPkFk(left: string, right: string, mainTable: string, knownFks: Set<string>): { pk: string, fk: string } {
+        const [leftTable, leftField] = left.split(".");
+        const [rightTable, rightField] = right.split(".");
+
+        // Check if one of the fields is already known as a foreign key
+        const leftFull = `${leftTable}.${leftField}`;
+        const rightFull = `${rightTable}.${rightField}`;
+
+        if (knownFks.has(leftFull))
+            return { pk: right, fk: left };
+        else if (knownFks.has(rightFull))
+            return { pk: left, fk: right };
+
+        // If either of the above conditions are met, use a heuristic: set pk to the field named "id" or "_id"
+        if (leftField === "id" || leftField === "_id") {
+            return { pk: left, fk: right };
+        } else if (rightField === "id" || rightField === "_id") {
+            return { pk: right, fk: left };
+        }
+
+        if (leftTable === mainTable)
+            return { pk: left, fk: right };
+        else if (rightTable === mainTable)
+            return { pk: right, fk: left };
+
+        // If still unsure, throw an error
+        throw new Error(`Cannot determine pk/fk from condition: "${left} = ${right}"`);
+    }
+
+    public buildRelations(
+        joinClauses: JoinClause,
+        mainTable: string
+    ): RelationTypes.Relation {
+        const relations: RelationTypes.Relation = {};
+        const knownFks = new Set(this.knownForeignKeys);
+
+        for (const [alias, condition] of Object.entries(joinClauses)) {
+            const [left, right] = condition.split(/\s*=\s*/);
+
+            const { pk, fk } = this.identifyPkFk(left, right, mainTable, knownFks);
+
+            const [pkTable, pkField] = pk.split(".");
+            const [fkTable, fkField] = fk.split(".");
+
+            knownFks.add(`${fkTable}.${fkField}`);
+
+            const dbKey = this.tableDbMap?.[fkTable] || this.defaultDbKey;
+
+            relations[alias] = {
+                type: "1n",
+                path: [dbKey, fkTable],
+                pk: pkField,
+                fk: fkField,
+                as: alias,
+            };
+        }
+
+        this.knownForeignKeys = knownFks;
+
+        return relations;
+    }
+}