@wxn0brp/db-string-query 0.0.7

package/.github/workflows/build.yml

@@ -0,0 +1,25 @@
+name: Build
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - "*"
+
+  workflow_dispatch:
+
+concurrency:
+  group: build
+  cancel-in-progress: true
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: wxn0brP/rusalka@master
+        with:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# ValtheraDB Query Processor
+
+`@wxn0brp/db-string-query` is a powerful query processor for ValtheraDB. It allows you to parse database queries written in either a JavaScript-like syntax or a SQL-like syntax. This provides flexibility in how you interact with your database.
+
+## Features
+
+-   **Dual Syntax Support**: Write queries in either JS-like or SQL-like syntax.
+-   **Extensible**: Easily extendable with new methods and handlers.
+-   **Typed**: Written in TypeScript for type safety.
+
+## Installation
+
+```bash
+npm install @wxn0brp/db-string-query
+```
+
+## Usage
+
+The library exports a `ValtheraDbParsers` object which contains the `js` and `sql` parsers.
+
+### JS-like Syntax
+
+The JS-like syntax is similar to calling a function. The query string should be in the format `method(arg1, arg2, ...)`. Arguments are parsed using `JSON5`, so you can pass complex objects.
+
+```typescript
+import { ValtheraDbParsers } from "@wxn0brp/db-string-query";
+
+const jsParser = new ValtheraDbParsers.js();
+
+const query = `myMethod({ a: 1, b: "hello" }, [1, 2, 3])`;
+const parsedQuery = jsParser.parse(query);
+
+console.log(parsedQuery);
+// Output:
+// {
+//   method: 'myMethod',
+//   args: [ { a: 1, b: 'hello' }, [ 1, 2, 3 ] ]
+// }
+```
+
+### SQL-like Syntax
+
+The SQL-like syntax provides a familiar way to interact with the database. 
+
+> Note: The SQL-like syntax is not full SQL. It is a simplified subset, supporting only basic, straightforward cases.
+
+```typescript
+import { ValtheraDbParsers } from "@wxn0brp/db-string-query";
+
+const sqlParser = new ValtheraDbParsers.sql();
+
+const query = "SELECT * FROM users WHERE id = 1";
+const parsedQuery = sqlParser.parse(query);
+
+console.log(parsedQuery);
+```
+
+#### Supported SQL Commands
+
+The SQL parser supports the following commands:
+
+-   `SELECT`: Retrieve data from a collection.
+-   `INSERT`: Add new data to a collection.
+-   `UPDATE`: Modify existing data in a collection.
+-   `DELETE`: Remove data from a collection.
+-   `GET COLLECTIONS`: Get list of collection.
+-   `CREATE`: Create a new collection.
+-   `DROP`: Delete a collection.
+-   `EXISTS`: Check if a collection exists.
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import valtheraJsParser from "./js.js";
+import valtheraSQLParser from "./sql/index.js";
+export declare const ValtheraDbParsers: {
+    js: typeof valtheraJsParser;
+    sql: typeof valtheraSQLParser;
+};
+export declare const ValtheraDbRelations: {};

package/dist/index.js

@@ -0,0 +1,8 @@
+import valtheraJsParser from "./js.js";
+import valtheraSQLParser from "./sql/index.js";
+export const ValtheraDbParsers = {
+    js: valtheraJsParser,
+    sql: valtheraSQLParser
+};
+export const ValtheraDbRelations = {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxnQkFBZ0IsTUFBTSxNQUFNLENBQUM7QUFDcEMsT0FBTyxpQkFBaUIsTUFBTSxPQUFPLENBQUM7QUFFdEMsTUFBTSxDQUFDLE1BQU0saUJBQWlCLEdBQUc7SUFDN0IsRUFBRSxFQUFFLGdCQUFnQjtJQUNwQixHQUFHLEVBQUUsaUJBQWlCO0NBQ3pCLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRyxFQUFFLENBQUMifQ==

package/dist/js.d.ts

@@ -0,0 +1,9 @@
+import { ValtheraParser } from "./types.js";
+declare class JsParser implements ValtheraParser {
+    parse(query: string): {
+        method: string;
+        args: any[];
+    };
+    private parseArgs;
+}
+export default JsParser;

package/dist/js.js

@@ -0,0 +1,34 @@
+import JSON5 from "json5";
+class JsParser {
+    parse(query) {
+        const match = query.match(/^(\w+)\((.*)\)$/);
+        if (!match)
+            throw new Error("Invalid query");
+        const [, method, argsStr] = match;
+        let args = this.parseArgs(argsStr);
+        return { method, args };
+    }
+    parseArgs(argsStr) {
+        const args = [];
+        let buffer = "";
+        let bracketDepth = 0;
+        for (let char of argsStr) {
+            if (char === "{" || char === "[")
+                bracketDepth++;
+            if (char === "}" || char === "]")
+                bracketDepth--;
+            if (char === "," && bracketDepth === 0) {
+                args.push(JSON5.parse(buffer.trim()));
+                buffer = "";
+            }
+            else {
+                buffer += char;
+            }
+        }
+        if (buffer.trim())
+            args.push(JSON5.parse(buffer.trim()));
+        return args;
+    }
+}
+export default JsParser;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvanMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRzFCLE1BQU0sUUFBUTtJQUNWLEtBQUssQ0FBQyxLQUFhO1FBQ2YsTUFBTSxLQUFLLEdBQUcsS0FBSyxDQUFDLEtBQUssQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO1FBQzdDLElBQUksQ0FBQyxLQUFLO1lBQUUsTUFBTSxJQUFJLEtBQUssQ0FBQyxlQUFlLENBQUMsQ0FBQztRQUU3QyxNQUFNLENBQUMsRUFBRSxNQUFNLEVBQUUsT0FBTyxDQUFDLEdBQUcsS0FBSyxDQUFDO1FBQ2xDLElBQUksSUFBSSxHQUFHLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxDQUFDLENBQUM7UUFFbkMsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRU8sU0FBUyxDQUFDLE9BQWU7UUFDN0IsTUFBTSxJQUFJLEdBQUcsRUFBRSxDQUFDO1FBQ2hCLElBQUksTUFBTSxHQUFHLEVBQUUsQ0FBQztRQUNoQixJQUFJLFlBQVksR0FBRyxDQUFDLENBQUM7UUFFckIsS0FBSyxJQUFJLElBQUksSUFBSSxPQUFPLEVBQUUsQ0FBQztZQUN2QixJQUFJLElBQUksS0FBSyxHQUFHLElBQUksSUFBSSxLQUFLLEdBQUc7Z0JBQUUsWUFBWSxFQUFFLENBQUM7WUFDakQsSUFBSSxJQUFJLEtBQUssR0FBRyxJQUFJLElBQUksS0FBSyxHQUFHO2dCQUFFLFlBQVksRUFBRSxDQUFDO1lBRWpELElBQUksSUFBSSxLQUFLLEdBQUcsSUFBSSxZQUFZLEtBQUssQ0FBQyxFQUFFLENBQUM7Z0JBQ3JDLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxNQUFNLENBQUMsSUFBSSxFQUFFLENBQUMsQ0FBQyxDQUFDO2dCQUN0QyxNQUFNLEdBQUcsRUFBRSxDQUFDO1lBQ2hCLENBQUM7aUJBQU0sQ0FBQztnQkFDSixNQUFNLElBQUksSUFBSSxDQUFDO1lBQ25CLENBQUM7UUFDTCxDQUFDO1FBRUQsSUFBSSxNQUFNLENBQUMsSUFBSSxFQUFFO1lBQUUsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxJQUFJLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFFekQsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztDQUNKO0FBRUQsZUFBZSxRQUFRLENBQUMifQ==

package/dist/sql/handle.d.ts

@@ -0,0 +1,12 @@
+export declare function handleSelect(query: string): import("../types.js").ValtheraQuery;
+export declare function parseSelectClause(selectClause: string): {
+    select?: string[];
+    exclude?: string[];
+};
+export declare function handleInsert(query: string): import("../types.js").ValtheraQuery;
+export declare function handleUpdate(query: string): import("../types.js").ValtheraQuery;
+export declare function handleDelete(query: string): import("../types.js").ValtheraQuery;
+export declare function handleGet(query: string): import("../types.js").ValtheraQuery;
+export declare function handleCreate(query: string): import("../types.js").ValtheraQuery;
+export declare function handleDrop(query: string): import("../types.js").ValtheraQuery;
+export declare function handleExists(query: string): import("../types.js").ValtheraQuery;

package/dist/sql/handle.js

@@ -0,0 +1,119 @@
+import { parseReturn, parseSet } from "./utils.js";
+import { parseWhere } from "./where.js";
+export function handleSelect(query) {
+    const match = query.match(/SELECT\s+(.+?)\s+FROM\s+([\w\/]+)(?:\s+WHERE\s+(.+))?/i);
+    if (!match)
+        throw new Error("Invalid SELECT syntax");
+    const columnsPart = match[1].trim();
+    const collection = match[2];
+    const whereClause = match[3] ? parseWhere(match[3]) : {};
+    const findOpts = parseSelectClause(columnsPart);
+    return parseReturn("find", [collection, whereClause, {}, findOpts]);
+}
+export function parseSelectClause(selectClause) {
+    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*/),
+    };
+}
+export function handleInsert(query) {
+    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) {
+        const tokens = [];
+        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]) ? values[i] : Number(values[i])]));
+    return parseReturn("add", [collection, data]);
+}
+export function handleUpdate(query) {
+    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]);
+}
+export function handleDelete(query) {
+    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]);
+}
+// collection
+export function handleGet(query) {
+    if (!/^GET\s+COLLECTIONS$/i.test(query)) {
+        throw new Error("Invalid GET COLLECTIONS syntax.");
+    }
+    return parseReturn("getCollections", []);
+}
+export function handleCreate(query) {
+    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) {
+    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) {
+    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]]);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/sql/index.d.ts

@@ -0,0 +1,5 @@
+import { ValtheraParser } from "../types.js";
+declare class SQLParser implements ValtheraParser {
+    parse(query: string): import("../types.js").ValtheraQuery;
+}
+export default SQLParser;

package/dist/sql/index.js

@@ -0,0 +1,38 @@
+import { handleCreate, handleDelete, handleDrop, handleExists, handleGet, handleInsert, handleSelect, handleUpdate } from "./handle.js";
+class SQLParser {
+    parse(query) {
+        query = query.replace(/\s+/g, " ").trim();
+        const tokens = query.split(/\s+/);
+        const method = tokens[0].toUpperCase();
+        if (method === "SELECT") {
+            return handleSelect(query);
+        }
+        else if (method === "INSERT") {
+            return handleInsert(query);
+        }
+        else if (method === "UPDATE") {
+            return handleUpdate(query);
+        }
+        else if (method === "DELETE") {
+            return handleDelete(query);
+        }
+        // collection
+        else if (method === "GET") {
+            return handleGet(query);
+        }
+        else if (method === "CREATE") {
+            return handleCreate(query);
+        }
+        else if (method === "DROP") {
+            return handleDrop(query);
+        }
+        else if (method === "EXISTS") {
+            return handleExists(query);
+        }
+        else {
+            throw new Error("Unknown query: " + tokens[0]);
+        }
+    }
+}
+export default SQLParser;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFDSCxZQUFZLEVBQ1osWUFBWSxFQUNaLFVBQVUsRUFDVixZQUFZLEVBQ1osU0FBUyxFQUNULFlBQVksRUFDWixZQUFZLEVBQ1osWUFBWSxFQUNmLE1BQU0sVUFBVSxDQUFDO0FBRWxCLE1BQU0sU0FBUztJQUNYLEtBQUssQ0FBQyxLQUFhO1FBQ2YsS0FBSyxHQUFHLEtBQUssQ0FBQyxPQUFPLENBQUMsTUFBTSxFQUFFLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO1FBQzFDLE1BQU0sTUFBTSxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDbEMsTUFBTSxNQUFNLEdBQUcsTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRXZDLElBQUksTUFBTSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQ3RCLE9BQU8sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9CLENBQUM7YUFBTSxJQUFJLE1BQU0sS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUM3QixPQUFPLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUMvQixDQUFDO2FBQU0sSUFBSSxNQUFNLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDN0IsT0FBTyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDL0IsQ0FBQzthQUFNLElBQUksTUFBTSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzdCLE9BQU8sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9CLENBQUM7UUFDRCxhQUFhO2FBQ1IsSUFBSSxNQUFNLEtBQUssS0FBSyxFQUFFLENBQUM7WUFDeEIsT0FBTyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDNUIsQ0FBQzthQUFNLElBQUksTUFBTSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQzdCLE9BQU8sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQy9CLENBQUM7YUFBTSxJQUFJLE1BQU0sS0FBSyxNQUFNLEVBQUUsQ0FBQztZQUMzQixPQUFPLFVBQVUsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUM3QixDQUFDO2FBQU0sSUFBSSxNQUFNLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDN0IsT0FBTyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDL0IsQ0FBQzthQUFNLENBQUM7WUFDSixNQUFNLElBQUksS0FBSyxDQUFDLGlCQUFpQixHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQ25ELENBQUM7SUFDTCxDQUFDO0NBQ0o7QUFFRCxlQUFlLFNBQVMsQ0FBQyJ9

package/dist/sql/utils.d.ts

@@ -0,0 +1,3 @@
+import { ValtheraQuery } from "../types.js";
+export declare function parseReturn(method: string, args: any[]): ValtheraQuery;
+export declare function parseSet(setString: string): any;

package/dist/sql/utils.js

@@ -0,0 +1,13 @@
+export function parseReturn(method, args) {
+    return { method, args };
+}
+export function parseSet(setString) {
+    return Object.fromEntries(setString.split(/\s*,\s*/).map(pair => {
+        const [key, value] = pair.split(/\s*=\s*/);
+        let parsedValue = value.replace(/^'|'$/g, "");
+        if (!isNaN(parsedValue))
+            parsedValue = Number(parsedValue);
+        return [key, parsedValue];
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsL3V0aWxzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sVUFBVSxXQUFXLENBQUMsTUFBYyxFQUFFLElBQVc7SUFDbkQsT0FBTyxFQUFFLE1BQU0sRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUM1QixDQUFDO0FBRUQsTUFBTSxVQUFVLFFBQVEsQ0FBQyxTQUFpQjtJQUN0QyxPQUFPLE1BQU0sQ0FBQyxXQUFXLENBQ3JCLFNBQVMsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFO1FBQ2xDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLEdBQVEsSUFBSSxDQUFDLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUNoRCxJQUFJLFdBQVcsR0FBRyxLQUFLLENBQUMsT0FBTyxDQUFDLFFBQVEsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUM5QyxJQUFJLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQztZQUFFLFdBQVcsR0FBRyxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDM0QsT0FBTyxDQUFDLEdBQUcsRUFBRSxXQUFXLENBQUMsQ0FBQztJQUM5QixDQUFDLENBQUMsQ0FDTCxDQUFDO0FBQ04sQ0FBQyJ9

package/dist/sql/where.d.ts

@@ -0,0 +1,3 @@
+type QueryObject = Record<string, any>;
+export declare function parseWhere(where: string): QueryObject;
+export {};

package/dist/sql/where.js

@@ -0,0 +1,131 @@
+const operators = {
+    "=": "",
+    "<": "$lt",
+    ">": "$gt",
+    "<=": "$lte",
+    ">=": "$gte",
+    "!=": "$not",
+    "IN": "$in",
+    "NOT IN": "$nin"
+};
+export function parseWhere(where) {
+    if (!where)
+        return {};
+    const trimmed = where.trim();
+    if (trimmed === "" || trimmed === "1")
+        return {};
+    // Tokenize the input string, handling parentheses and quoted values
+    const tokens = where
+        .replace(/\s+(?=(?:[^'"]*['"][^'"]*['"])*[^'"]*$)/g, " ")
+        .match(/(?:\(|\)|'[^']*'|"[^"]*"|[^\s()'"]+)/g) || [];
+    let frames = [];
+    let current = {};
+    let operatorStack = [];
+    let stack = [];
+    for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i].trim();
+        if (!token)
+            continue;
+        if (token === '(') {
+            // Push current context to the stack and reset for the new group
+            frames.push({ current, operatorStack, stack });
+            current = {};
+            operatorStack = [];
+            stack = [];
+        }
+        else if (token === ')') {
+            // Combine current and stack into a grouped query
+            let groupedQuery = current;
+            if (stack.length > 0) {
+                stack.push(current);
+                groupedQuery = { $or: stack };
+            }
+            if (frames.length === 0) {
+                throw new Error("Unmatched closing parenthesis");
+            }
+            const parentFrame = frames.pop();
+            const parentCurrent = parentFrame.current;
+            const parentOperatorStack = parentFrame.operatorStack;
+            const parentStack = parentFrame.stack;
+            // Merge the grouped query into the parent context
+            if (parentOperatorStack.length > 0) {
+                const op = parentOperatorStack.pop();
+                if (op === "OR") {
+                    parentStack.push(parentCurrent);
+                    current = groupedQuery;
+                }
+                else if (op === "AND") {
+                    current = { ...parentCurrent, ...groupedQuery };
+                }
+            }
+            else {
+                current = { ...parentCurrent, ...groupedQuery };
+            }
+            // Restore parent's stack and operator stack
+            operatorStack = parentFrame.operatorStack;
+            stack = parentStack;
+        }
+        else if (token.toUpperCase() === "AND" || token.toUpperCase() === "OR") {
+            operatorStack.push(token.toUpperCase());
+        }
+        else {
+            // Process condition (key, operator, value)
+            if (operatorStack.length) {
+                const op = operatorStack[operatorStack.length - 1];
+                if (op === "OR") {
+                    stack.push(current);
+                    current = {};
+                    operatorStack.pop();
+                }
+            }
+            let key = token;
+            let op = tokens[++i]?.trim();
+            let value = tokens[++i]?.trim();
+            if (!key || !op || value === undefined) {
+                throw new Error(`Invalid condition near '${key} ${op} ${value}'`);
+            }
+            // Handle quoted values
+            if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
+                value = value.slice(1, -1);
+            }
+            // Parse numeric values
+            if (!isNaN(Number(value))) {
+                value = Number(value);
+            }
+            // Handle IN and NOT IN operations
+            if (op.toUpperCase() === "IN" || op.toUpperCase() === "NOT IN") {
+                if (!value.startsWith("(") || !value.endsWith(")")) {
+                    throw new Error(`Invalid syntax for '${op}' near '${value}'`);
+                }
+                value = value.slice(1, -1).split(",").map((v) => {
+                    v = v.trim();
+                    if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+                        return v.slice(1, -1);
+                    }
+                    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 };
+                }
+                else {
+                    current[key] = current[key] || {};
+                    current[key][mappedOp] = value;
+                }
+            }
+            else {
+                current[key] = value;
+            }
+        }
+    }
+    // Combine any remaining OR conditions
+    if (stack.length > 0) {
+        stack.push(current);
+        return { $or: stack };
+    }
+    return current;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2hlcmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc3FsL3doZXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sU0FBUyxHQUEyQjtJQUN0QyxHQUFHLEVBQUUsRUFBRTtJQUNQLEdBQUcsRUFBRSxLQUFLO0lBQ1YsR0FBRyxFQUFFLEtBQUs7SUFDVixJQUFJLEVBQUUsTUFBTTtJQUNaLElBQUksRUFBRSxNQUFNO0lBQ1osSUFBSSxFQUFFLE1BQU07SUFDWixJQUFJLEVBQUUsS0FBSztJQUNYLFFBQVEsRUFBRSxNQUFNO0NBQ25CLENBQUM7QUFFRixNQUFNLFVBQVUsVUFBVSxDQUFDLEtBQWE7SUFDcEMsSUFBSSxDQUFDLEtBQUs7UUFBRSxPQUFPLEVBQUUsQ0FBQztJQUN0QixNQUFNLE9BQU8sR0FBRyxLQUFLLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDN0IsSUFBSSxPQUFPLEtBQUssRUFBRSxJQUFJLE9BQU8sS0FBSyxHQUFHO1FBQUUsT0FBTyxFQUFFLENBQUM7SUFFakQsb0VBQW9FO0lBQ3BFLE1BQU0sTUFBTSxHQUFHLEtBQUs7U0FDZixPQUFPLENBQUMsMENBQTBDLEVBQUUsR0FBRyxDQUFDO1NBQ3hELEtBQUssQ0FBQyx1Q0FBdUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUUxRCxJQUFJLE1BQU0sR0FBMkUsRUFBRSxDQUFDO0lBQ3hGLElBQUksT0FBTyxHQUFnQixFQUFFLENBQUM7SUFDOUIsSUFBSSxhQUFhLEdBQWEsRUFBRSxDQUFDO0lBQ2pDLElBQUksS0FBSyxHQUFVLEVBQUUsQ0FBQztJQUV0QixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsTUFBTSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ3JDLElBQUksS0FBSyxHQUFHLE1BQU0sQ0FBQyxDQUFDLENBQUMsQ0FBQyxJQUFJLEVBQUUsQ0FBQztRQUM3QixJQUFJLENBQUMsS0FBSztZQUFFLFNBQVM7UUFFckIsSUFBSSxLQUFLLEtBQUssR0FBRyxFQUFFLENBQUM7WUFDaEIsZ0VBQWdFO1lBQ2hFLE1BQU0sQ0FBQyxJQUFJLENBQUMsRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFFLEtBQUssRUFBRSxDQUFDLENBQUM7WUFDL0MsT0FBTyxHQUFHLEVBQUUsQ0FBQztZQUNiLGFBQWEsR0FBRyxFQUFFLENBQUM7WUFDbkIsS0FBSyxHQUFHLEVBQUUsQ0FBQztRQUNmLENBQUM7YUFBTSxJQUFJLEtBQUssS0FBSyxHQUFHLEVBQUUsQ0FBQztZQUN2QixpREFBaUQ7WUFDakQsSUFBSSxZQUFZLEdBQWdCLE9BQU8sQ0FBQztZQUN4QyxJQUFJLEtBQUssQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7Z0JBQ25CLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7Z0JBQ3BCLFlBQVksR0FBRyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztZQUNsQyxDQUFDO1lBRUQsSUFBSSxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO2dCQUN0QixNQUFNLElBQUksS0FBSyxDQUFDLCtCQUErQixDQUFDLENBQUM7WUFDckQsQ0FBQztZQUNELE1BQU0sV0FBVyxHQUFHLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQztZQUNqQyxNQUFNLGFBQWEsR0FBRyxXQUFXLENBQUMsT0FBTyxDQUFDO1lBQzFDLE1BQU0sbUJBQW1CLEdBQUcsV0FBVyxDQUFDLGFBQWEsQ0FBQztZQUN0RCxNQUFNLFdBQVcsR0FBRyxXQUFXLENBQUMsS0FBSyxDQUFDO1lBRXRDLGtEQUFrRDtZQUNsRCxJQUFJLG1CQUFtQixDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztnQkFDakMsTUFBTSxFQUFFLEdBQUcsbUJBQW1CLENBQUMsR0FBRyxFQUFFLENBQUM7Z0JBQ3JDLElBQUksRUFBRSxLQUFLLElBQUksRUFBRSxDQUFDO29CQUNkLFdBQVcsQ0FBQyxJQUFJLENBQUMsYUFBYSxDQUFDLENBQUM7b0JBQ2hDLE9BQU8sR0FBRyxZQUFZLENBQUM7Z0JBQzNCLENBQUM7cUJBQU0sSUFBSSxFQUFFLEtBQUssS0FBSyxFQUFFLENBQUM7b0JBQ3RCLE9BQU8sR0FBRyxFQUFFLEdBQUcsYUFBYSxFQUFFLEdBQUcsWUFBWSxFQUFFLENBQUM7Z0JBQ3BELENBQUM7WUFDTCxDQUFDO2lCQUFNLENBQUM7Z0JBQ0osT0FBTyxHQUFHLEVBQUUsR0FBRyxhQUFhLEVBQUUsR0FBRyxZQUFZLEVBQUUsQ0FBQztZQUNwRCxDQUFDO1lBRUQsNENBQTRDO1lBQzVDLGFBQWEsR0FBRyxXQUFXLENBQUMsYUFBYSxDQUFDO1lBQzFDLEtBQUssR0FBRyxXQUFXLENBQUM7UUFDeEIsQ0FBQzthQUFNLElBQUksS0FBSyxDQUFDLFdBQVcsRUFBRSxLQUFLLEtBQUssSUFBSSxLQUFLLENBQUMsV0FBVyxFQUFFLEtBQUssSUFBSSxFQUFFLENBQUM7WUFDdkUsYUFBYSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxFQUFFLENBQUMsQ0FBQztRQUM1QyxDQUFDO2FBQU0sQ0FBQztZQUNKLDJDQUEyQztZQUMzQyxJQUFJLGFBQWEsQ0FBQyxNQUFNLEVBQUUsQ0FBQztnQkFDdkIsTUFBTSxFQUFFLEdBQUcsYUFBYSxDQUFDLGFBQWEsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUM7Z0JBQ25ELElBQUksRUFBRSxLQUFLLElBQUksRUFBRSxDQUFDO29CQUNkLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7b0JBQ3BCLE9BQU8sR0FBRyxFQUFFLENBQUM7b0JBQ2IsYUFBYSxDQUFDLEdBQUcsRUFBRSxDQUFDO2dCQUN4QixDQUFDO1lBQ0wsQ0FBQztZQUVELElBQUksR0FBRyxHQUFHLEtBQUssQ0FBQztZQUNoQixJQUFJLEVBQUUsR0FBRyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQztZQUM3QixJQUFJLEtBQUssR0FBUSxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxJQUFJLEVBQUUsQ0FBQztZQUVyQyxJQUFJLENBQUMsR0FBRyxJQUFJLENBQUMsRUFBRSxJQUFJLEtBQUssS0FBSyxTQUFTLEVBQUUsQ0FBQztnQkFDckMsTUFBTSxJQUFJLEtBQUssQ0FBQywyQkFBMkIsR0FBRyxJQUFJLEVBQUUsSUFBSSxLQUFLLEdBQUcsQ0FBQyxDQUFDO1lBQ3RFLENBQUM7WUFFRCx1QkFBdUI7WUFDdkIsSUFBSSxDQUFDLEtBQUssQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksS0FBSyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxLQUFLLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxDQUFDLEVBQUUsQ0FBQztnQkFDbkcsS0FBSyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFDL0IsQ0FBQztZQUVELHVCQUF1QjtZQUN2QixJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUM7Z0JBQ3hCLEtBQUssR0FBRyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7WUFDMUIsQ0FBQztZQUVELGtDQUFrQztZQUNsQyxJQUFJLEVBQUUsQ0FBQyxXQUFXLEVBQUUsS0FBSyxJQUFJLElBQUksRUFBRSxDQUFDLFdBQVcsRUFBRSxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUM3RCxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztvQkFDakQsTUFBTSxJQUFJLEtBQUssQ0FBQyx1QkFBdUIsRUFBRSxXQUFXLEtBQUssR0FBRyxDQUFDLENBQUM7Z0JBQ2xFLENBQUM7Z0JBQ0QsS0FBSyxHQUFHLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQVMsRUFBRSxFQUFFO29CQUNwRCxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksRUFBRSxDQUFDO29CQUNiLElBQUksQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FBQyxFQUFFLENBQUM7d0JBQ25GLE9BQU8sQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQztvQkFDMUIsQ0FBQztvQkFDRCxPQUFPLEtBQUssQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLENBQUM7Z0JBQzVDLENBQUMsQ0FBQyxDQUFDO1lBQ1AsQ0FBQztZQUVELGdEQUFnRDtZQUNoRCxNQUFNLFFBQVEsR0FBRyxTQUFTLENBQUMsRUFBRSxDQUFDLFdBQVcsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFDO1lBQ25ELElBQUksUUFBUSxFQUFFLENBQUM7Z0JBQ1gsSUFBSSxRQUFRLEtBQUssTUFBTSxFQUFFLENBQUM7b0JBQ3RCLE9BQU8sQ0FBQyxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUMsUUFBUSxDQUFDLEVBQUUsS0FBSyxFQUFFLENBQUM7Z0JBQ3pDLENBQUM7cUJBQU0sQ0FBQztvQkFDSixPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxJQUFJLEVBQUUsQ0FBQztvQkFDakMsT0FBTyxDQUFDLEdBQUcsQ0FBeUIsQ0FBQyxRQUFRLENBQUMsR0FBRyxLQUFLLENBQUM7Z0JBQzVELENBQUM7WUFDTCxDQUFDO2lCQUFNLENBQUM7Z0JBQ0osT0FBTyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEtBQUssQ0FBQztZQUN6QixDQUFDO1FBQ0wsQ0FBQztJQUNMLENBQUM7SUFFRCxzQ0FBc0M7SUFDdEMsSUFBSSxLQUFLLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO1FBQ25CLEtBQUssQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDcEIsT0FBTyxFQUFFLEdBQUcsRUFBRSxLQUFLLEVBQUUsQ0FBQztJQUMxQixDQUFDO0lBRUQsT0FBTyxPQUFPLENBQUM7QUFDbkIsQ0FBQyJ9

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+export interface ValtheraQuery {
+    method: string;
+    args: any[];
+}
+export interface ValtheraParser {
+    parse(query: string): ValtheraQuery;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

package/package.json

@@ -0,0 +1,44 @@
+{
+    "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"
+    },
+    "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
+        }
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js",
+            "import": "./dist/index.js"
+        },
+        "./*": {
+            "types": "./dist/*.d.ts",
+            "default": "./dist/*.js",
+            "import": "./dist/*.js"
+        }
+    }
+}

package/rusalka/build.ts

@@ -0,0 +1 @@
+export const publishToNpm = true;

package/src/index.ts

@@ -0,0 +1,9 @@
+import valtheraJsParser from "./js";
+import valtheraSQLParser from "./sql";
+
+export const ValtheraDbParsers = {
+    js: valtheraJsParser,
+    sql: valtheraSQLParser
+};
+
+export const ValtheraDbRelations = {};

package/src/js.ts

@@ -0,0 +1,38 @@
+import JSON5 from "json5";
+import { ValtheraParser } from "./types";
+
+class JsParser implements ValtheraParser {
+    parse(query: string) {
+        const match = query.match(/^(\w+)\((.*)\)$/);
+        if (!match) throw new Error("Invalid query");
+
+        const [, method, argsStr] = match;
+        let args = this.parseArgs(argsStr);
+
+        return { method, args };
+    }
+
+    private parseArgs(argsStr: string) {
+        const args = [];
+        let buffer = "";
+        let bracketDepth = 0;
+
+        for (let char of argsStr) {
+            if (char === "{" || char === "[") bracketDepth++;
+            if (char === "}" || char === "]") bracketDepth--;
+
+            if (char === "," && bracketDepth === 0) {
+                args.push(JSON5.parse(buffer.trim()));
+                buffer = "";
+            } else {
+                buffer += char;
+            }
+        }
+
+        if (buffer.trim()) args.push(JSON5.parse(buffer.trim()));
+
+        return args;
+    }
+}
+
+export default JsParser;

package/src/sql/handle.ts

@@ -0,0 +1,129 @@
+import { parseReturn, parseSet } from "./utils";
+import { parseWhere } from "./where";
+
+export function handleSelect(query: string) {
+    const match = query.match(/SELECT\s+(.+?)\s+FROM\s+([\w\/]+)(?:\s+WHERE\s+(.+))?/i);
+    if (!match) throw new Error("Invalid SELECT syntax");
+
+    const columnsPart = match[1].trim();
+    const collection = match[2];
+    const whereClause = match[3] ? parseWhere(match[3]) : {};
+
+    const findOpts = parseSelectClause(columnsPart);
+    return parseReturn("find", [collection, whereClause, {}, findOpts]);
+}
+
+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*/),
+    };
+}
+
+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]);
+}
+
+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]);
+}
+
+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]);
+}
+
+// collection
+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/index.ts

@@ -0,0 +1,43 @@
+import { ValtheraParser } from "../types";
+import {
+    handleCreate,
+    handleDelete,
+    handleDrop,
+    handleExists,
+    handleGet,
+    handleInsert,
+    handleSelect,
+    handleUpdate
+} from "./handle";
+
+class SQLParser implements ValtheraParser {
+    parse(query: string) {
+        query = query.replace(/\s+/g, " ").trim();
+        const tokens = query.split(/\s+/);
+        const method = tokens[0].toUpperCase();
+
+        if (method === "SELECT") {
+            return handleSelect(query);
+        } else if (method === "INSERT") {
+            return handleInsert(query);
+        } else if (method === "UPDATE") {
+            return handleUpdate(query);
+        } else if (method === "DELETE") {
+            return handleDelete(query);
+        }
+        // collection
+        else if (method === "GET") {
+            return handleGet(query);
+        } else if (method === "CREATE") {
+            return handleCreate(query);
+        } else if (method === "DROP") {
+            return handleDrop(query);
+        } else if (method === "EXISTS") {
+            return handleExists(query);
+        } else {
+            throw new Error("Unknown query: " + tokens[0]);
+        }
+    }
+}
+
+export default SQLParser;

package/src/sql/utils.ts

@@ -0,0 +1,17 @@
+import { ValtheraQuery } from "../types";
+
+
+export function parseReturn(method: string, args: any[]): ValtheraQuery {
+    return { method, args };
+}
+
+export function parseSet(setString: string) {
+    return Object.fromEntries(
+        setString.split(/\s*,\s*/).map(pair => {
+            const [key, value]: any = pair.split(/\s*=\s*/);
+            let parsedValue = value.replace(/^'|'$/g, "");
+            if (!isNaN(parsedValue)) parsedValue = Number(parsedValue);
+            return [key, parsedValue];
+        })
+    );
+}

package/src/sql/where.ts

@@ -0,0 +1,138 @@
+type QueryObject = Record<string, any>;
+
+const operators: Record<string, string> = {
+    "=": "",
+    "<": "$lt",
+    ">": "$gt",
+    "<=": "$lte",
+    ">=": "$gte",
+    "!=": "$not",
+    "IN": "$in",
+    "NOT IN": "$nin"
+};
+
+export function parseWhere(where: string): QueryObject {
+    if (!where) return {};
+    const trimmed = where.trim();
+    if (trimmed === "" || trimmed === "1") return {};
+
+    // Tokenize the input string, handling parentheses and quoted values
+    const tokens = where
+        .replace(/\s+(?=(?:[^'"]*['"][^'"]*['"])*[^'"]*$)/g, " ")
+        .match(/(?:\(|\)|'[^']*'|"[^"]*"|[^\s()'"]+)/g) || [];
+
+    let frames: Array<{ current: QueryObject, operatorStack: string[], stack: any[] }> = [];
+    let current: QueryObject = {};
+    let operatorStack: string[] = [];
+    let stack: any[] = [];
+
+    for (let i = 0; i < tokens.length; i++) {
+        let token = tokens[i].trim();
+        if (!token) continue;
+
+        if (token === '(') {
+            // Push current context to the stack and reset for the new group
+            frames.push({ current, operatorStack, stack });
+            current = {};
+            operatorStack = [];
+            stack = [];
+        } else if (token === ')') {
+            // Combine current and stack into a grouped query
+            let groupedQuery: QueryObject = current;
+            if (stack.length > 0) {
+                stack.push(current);
+                groupedQuery = { $or: stack };
+            }
+
+            if (frames.length === 0) {
+                throw new Error("Unmatched closing parenthesis");
+            }
+            const parentFrame = frames.pop();
+            const parentCurrent = parentFrame.current;
+            const parentOperatorStack = parentFrame.operatorStack;
+            const parentStack = parentFrame.stack;
+
+            // Merge the grouped query into the parent context
+            if (parentOperatorStack.length > 0) {
+                const op = parentOperatorStack.pop();
+                if (op === "OR") {
+                    parentStack.push(parentCurrent);
+                    current = groupedQuery;
+                } else if (op === "AND") {
+                    current = { ...parentCurrent, ...groupedQuery };
+                }
+            } else {
+                current = { ...parentCurrent, ...groupedQuery };
+            }
+
+            // Restore parent's stack and operator stack
+            operatorStack = parentFrame.operatorStack;
+            stack = parentStack;
+        } else if (token.toUpperCase() === "AND" || token.toUpperCase() === "OR") {
+            operatorStack.push(token.toUpperCase());
+        } else {
+            // Process condition (key, operator, value)
+            if (operatorStack.length) {
+                const op = operatorStack[operatorStack.length - 1];
+                if (op === "OR") {
+                    stack.push(current);
+                    current = {};
+                    operatorStack.pop();
+                }
+            }
+
+            let key = token;
+            let op = tokens[++i]?.trim();
+            let value: any = tokens[++i]?.trim();
+
+            if (!key || !op || value === undefined) {
+                throw new Error(`Invalid condition near '${key} ${op} ${value}'`);
+            }
+
+            // Handle quoted values
+            if ((value.startsWith("'") && value.endsWith("'")) || (value.startsWith('"') && value.endsWith('"'))) {
+                value = value.slice(1, -1);
+            }
+
+            // Parse numeric values
+            if (!isNaN(Number(value))) {
+                value = Number(value);
+            }
+
+            // Handle IN and NOT IN operations
+            if (op.toUpperCase() === "IN" || op.toUpperCase() === "NOT IN") {
+                if (!value.startsWith("(") || !value.endsWith(")")) {
+                    throw new Error(`Invalid syntax for '${op}' near '${value}'`);
+                }
+                value = value.slice(1, -1).split(",").map((v: string) => {
+                    v = v.trim();
+                    if ((v.startsWith("'") && v.endsWith("'")) || (v.startsWith('"') && v.endsWith('"'))) {
+                        return v.slice(1, -1);
+                    }
+                    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 };
+                } else {
+                    current[key] = current[key] || {};
+                    (current[key] as Record<string, any>)[mappedOp] = value;
+                }
+            } else {
+                current[key] = value;
+            }
+        }
+    }
+
+    // Combine any remaining OR conditions
+    if (stack.length > 0) {
+        stack.push(current);
+        return { $or: stack };
+    }
+
+    return current;
+}

package/src/types.ts

@@ -0,0 +1,8 @@
+export interface ValtheraQuery {
+    method: string;
+    args: any[];
+}
+
+export interface ValtheraParser {
+    parse(query: string): ValtheraQuery;
+}

package/suglite.json

@@ -0,0 +1,10 @@
+{
+    "cmd": "yarn build && yarn start",
+    "watch": [
+        "src"
+    ],
+    "restart_cmd": "clear",
+    "events": {
+        "rs": "clear"
+    }
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "ES2022",
+        "target": "ES2022",
+        "moduleResolution": "bundler",
+        "paths": {},
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "outDir": "./dist",
+        "inlineSourceMap": true,
+        "declaration": true
+    },
+    "include": [
+       "./src"
+    ],
+    "exclude": [
+        "node_modules"
+    ],
+    "tsc-alias": {
+        "resolveFullPaths": true,
+        "verbose": false
+    }
+}