@wxn0brp/db-string-query 0.0.8 → 0.0.10

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,69 @@
+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(".");
+
+        if (leftTable === mainTable)
+            return { pk: left, fk: right };
+        else if (rightTable === mainTable)
+            return { pk: right, fk: left };
+
+        if (knownFks.has(left))
+            return { pk: right, fk: left };
+        else if (knownFks.has(right))
+            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 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(fk);
+
+            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;
+    }
+}

package/src/sql/where.ts

@@ -109,6 +109,9 @@ export function parseWhere(where: string): QueryObject {
             }
 
             let key = token;
+            if (key.includes(".")) {
+                key = key.split(".").pop()!;
+            }
             let opToken = tokens[++i]?.trim();
             let value: any = tokens[++i]?.trim();
 

package/src/types.ts

@@ -3,6 +3,14 @@ export interface ValtheraQuery {
     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/{src/test → test}/js.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { ValtheraDbParsers } from "..";
+import { ValtheraDbParsers } from "#index";
 
 const jsParser = new ValtheraDbParsers.js();
 

package/{src/test → test}/sql/delete.test.ts

@@ -1,7 +1,7 @@
+import SQLParser from "#sql";
 import { describe, expect, test } from "bun:test";
-import { ValtheraDbParsers } from "../..";
 
-const sqlParser = new ValtheraDbParsers.sql();
+const sqlParser = new SQLParser();
 
 describe("SQL Parser - DELETE", () => {
 	test("should parse a simple DELETE query", () => {

package/test/sql/index.test.ts

@@ -0,0 +1,17 @@
+import SQLParser from "#sql";
+import { describe, expect, test } from "bun:test";
+
+const sqlParser = new SQLParser();
+
+describe("SQL Parser - SELECT", () => {
+    test("should parse with ;", () => {
+        const query = "SELECT * FROM users WHERE id = 1;";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("find");
+        expect(parsedQuery.args).toHaveLength(4);
+        expect(parsedQuery.args[0]).toBe("users"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+    });
+});

package/{src/test → test}/sql/insert.test.ts

@@ -1,7 +1,7 @@
+import SQLParser from "#sql";
 import { describe, expect, test } from "bun:test";
-import { ValtheraDbParsers } from "../..";
 
-const sqlParser = new ValtheraDbParsers.sql();
+const sqlParser = new SQLParser();
 
 describe("SQL Parser - INSERT", () => {
 	test("should parse a simple INSERT query", () => {

package/{src/test → test}/sql/select.test.ts

@@ -1,10 +1,10 @@
+import SQLParser from "#sql";
 import { describe, expect, test } from "bun:test";
-import { ValtheraDbParsers } from "../..";
 
-const sqlParser = new ValtheraDbParsers.sql();
+const sqlParser = new SQLParser();
 
 describe("SQL Parser - SELECT", () => {
-    test("should parse a simple SELECT query", () => {
+    test("1. should parse a simple SELECT query", () => {
         const query = "SELECT * FROM users WHERE id = 1";
         const parsedQuery = sqlParser.parse(query);
 
@@ -15,7 +15,7 @@ describe("SQL Parser - SELECT", () => {
         expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
     });
 
-    test("should parse a SELECT query with specific columns", () => {
+    test("2. should parse a SELECT query with specific columns", () => {
         const query = "SELECT name, email FROM users WHERE active = 1";
         const parsedQuery = sqlParser.parse(query);
 
@@ -27,7 +27,7 @@ describe("SQL Parser - SELECT", () => {
         expect(parsedQuery.args[3]).toEqual({ select: ["name", "email"] }); // select options
     });
 
-    test("should parse a SELECT query without WHERE clause", () => {
+    test("3. should parse a SELECT query without WHERE clause", () => {
         const query = "SELECT * FROM users";
         const parsedQuery = sqlParser.parse(query);
 
@@ -38,7 +38,7 @@ describe("SQL Parser - SELECT", () => {
         expect(parsedQuery.args[1]).toEqual({}); // empty where clause
     });
 
-    test("should parse a SELECT query with EXCLUDE clause", () => {
+    test("4. should parse a SELECT query with EXCLUDE clause", () => {
         const query = "SELECT * EXCLUDE password, createdAt FROM users WHERE active = 1";
         const parsedQuery = sqlParser.parse(query);
 
@@ -50,7 +50,7 @@ describe("SQL Parser - SELECT", () => {
         expect(parsedQuery.args[3]).toEqual({ exclude: ["password", "createdAt"] }); // exclude options
     });
 
-    test("should parse a SELECT query with complex WHERE conditions", () => {
+    test("5. should parse a SELECT query with complex WHERE conditions", () => {
         const query = "SELECT * FROM users WHERE age > 18 AND status = 'active'";
         const parsedQuery = sqlParser.parse(query);
 
@@ -61,7 +61,28 @@ describe("SQL Parser - SELECT", () => {
         expect(parsedQuery.args[1]).toEqual({ $gt: { age: 18 }, status: "active" }); // where clause
     });
 
-    test("should throw error for invalid SELECT syntax", () => {
+    test("6. should parse a SELECT query with a JOIN clause", () => {
+        const query = "SELECT posts.*, users.name FROM posts JOIN users ON posts.userId = users.id WHERE posts.id = 1";
+        const parsedQuery = sqlParser.parse(query, { defaultDbKey: "db" });
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("relation-find");
+        expect(parsedQuery.args).toHaveLength(4);
+        expect(parsedQuery.args[0]).toEqual(["db", "posts"]); // path
+        expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({
+            users: {
+                type: '1n',
+                path: ['db', 'users'],
+                pk: 'userId',
+                fk: 'id',
+                as: 'users'
+            }
+        }); // relations
+        expect(parsedQuery.args[3]).toEqual({ select: ["posts.*", "users.name"] }); // select options
+    });
+
+    test("7. should throw error for invalid SELECT syntax", () => {
         const query = "SELECT FROM users";
 
         expect(() => {

package/{src/test → test}/sql/update.test.ts

@@ -1,7 +1,7 @@
+import SQLParser from "#sql";
 import { describe, expect, test } from "bun:test";
-import { ValtheraDbParsers } from "../..";
 
-const sqlParser = new ValtheraDbParsers.sql();
+const sqlParser = new SQLParser();
 
 describe("SQL Parser - UPDATE", () => {
     test("should parse a simple UPDATE query", () => {

package/test/sql/utils/join.test.ts

@@ -0,0 +1,42 @@
+import { JoinClause, JoinToRelationsEngine } from "#sql/utils/join.util";
+import { describe, expect, test } from "bun:test";
+
+describe("SQL Utils - Join", () => {
+    test("works", () => {
+        const joinClauses: JoinClause = {
+            comments: "posts.id = comments.post_id",
+            users: "comments.user_id = users.id",
+            tags: "posts.id = tags.post_id"
+        };
+
+        const engine = new JoinToRelationsEngine(
+            "defaultDb",
+            { comments: "blogDb", users: "userDb" }
+        );
+
+        const relations = engine.buildRelations(joinClauses, "posts");
+
+        expect(relations).toBeDefined();
+        expect(relations.comments).toEqual({
+            type: "1n",
+            path: ["blogDb", "comments"],
+            pk: "id",
+            fk: "post_id",
+            as: "comments",
+        })
+        expect(relations.users).toEqual({
+            type: "1n",
+            path: ["blogDb", "comments"],
+            pk: "id",
+            fk: "user_id",
+            as: "users",
+        })
+        expect(relations.tags).toEqual({
+            type: "1n",
+            path: ["defaultDb", "tags"],
+            pk: "id",
+            fk: "post_id",
+            as: "tags",
+        })
+    });
+});

package/test/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compilerOptions": {
+        "module": "ES2022",
+        "target": "ES2022",
+        "moduleResolution": "bundler",
+        "paths": {
+            "#*": [
+                "../src/*"
+            ]
+        },
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "outDir": "./dist",
+        "declaration": true
+    },
+    "include": [
+        "."
+    ]
+}

package/tsconfig.json

@@ -3,7 +3,11 @@
         "module": "ES2022",
         "target": "ES2022",
         "moduleResolution": "bundler",
-        "paths": {},
+        "paths": {
+            "#*": [
+                "./src/*"
+            ]
+        },
         "esModuleInterop": true,
         "skipLibCheck": true,
         "outDir": "./dist",
@@ -11,7 +15,7 @@
         "declaration": true
     },
     "include": [
-       "./src"
+        "./src"
     ],
     "exclude": [
         "node_modules"
@@ -20,4 +24,4 @@
         "resolveFullPaths": true,
         "verbose": false
     }
-}
+}

package/typedocs-generated/404.html

@@ -0,0 +1,76 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>404 - Page Not Found</title>
+    <style>
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol";
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            margin: 0;
+            background-color: #121212;
+            color: #e0e0e0;
+            text-align: center;
+        }
+
+        .container {
+            padding: 20px;
+            border-radius: 8px;
+            background-color: #1e1e1e;
+            box-shadow: 0 4px 8px rgba(0, 0, 0, 0.3);
+        }
+
+        h1 {
+            font-size: 3em;
+            color: #cf6679;
+            margin-bottom: 10px;
+        }
+
+        p {
+            font-size: 1.2em;
+            margin-bottom: 20px;
+        }
+
+        a {
+            color: #bb86fc;
+            text-decoration: none;
+        }
+
+        a:hover {
+            text-decoration: underline;
+        }
+
+        #go-back {
+            background-color: #03dac6;
+            color: #121212;
+            border: none;
+            padding: 10px 20px;
+            border-radius: 4px;
+            cursor: pointer;
+            font-size: 1em;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+
+<body>
+    <div class="container">
+        <h1>404</h1>
+        <p>Oops! The page you're looking for doesn't exist.</p>
+        <p>You might have mistyped the address or the page may have moved.</p>
+        <p><a id="home-link" href="/">Go to Homepage</a></p>
+        <button onclick="history.back()" id="go-back">Go Back</button>
+    </div>
+
+    <script type="module">
+        const segments = window.location.pathname.split("/").filter(Boolean);
+        document.querySelector("#home-link").href = "/" + (segments.length > 1 ? segments[0] : "");
+    </script>
+</body>
+
+</html>

package/typedocs-generated/assets/hierarchy.js

@@ -1 +1 @@
-window.hierarchyData = "eJyVjssKwjAQRf/lrtNKBEObr3DlRoqEZkqjaaqZFBTpv0t9FF0IupnFzL3nzBWx7xNDb6WqBCI1nurk+sDQV0g1zWA6gsbG+NRSNGsTmSIEDi5Y6OVKCQzRQ8OFRLExNfEiXY7E+Wclb1PnIVB7wwyNxDabGNncm46t8zZSgN6qUhSyGgVU+faGpcYMPs1+uSxe/juYeLHn/Jn6qnwsRoFC/sfmk9+5YOn8q2Icb1X9dqM="
+window.hierarchyData = "eJyVjssKwjAQRf/lrmPLCIrJV7hyI0VCM6XRmGomgiL9d6mPogtBN7OYmXvuuSJ1XRaYNelKIXETuM6+iwJzBelhRrtnGKxsyC0nu7RJOEFh56ODmc7mCqcUYOBj5tTYmqXMlwNL8Rkp2rwPUKiDFYFBFjcZGJMxNxxbH1ziCLPWWhFR1Svodw/HjT2FPArQdPESuJNZyq0Uz6+vnY9Fr0BE/8HlGDY+Oj7/2tH3Nx6zdwM="

package/typedocs-generated/assets/highlight.css

@@ -6,7 +6,7 @@
     --light-hl-2: #A31515;
     --dark-hl-2: #CE9178;
     --light-hl-3: #AF00DB;
-    --dark-hl-3: #CE92A4;
+    --dark-hl-3: #C586C0;
     --light-hl-4: #001080;
     --dark-hl-4: #9CDCFE;
     --light-hl-5: #0000FF;

package/typedocs-generated/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "eJyl1slOwzAQBuB3MdeKpS0Iei2o4sYi4IAq5MZTxcW4wXagCPHuKJ6qsbPUg7jGf77MOBkrz9/MwcaxCWMDVnCXswl7W4tSgT06zN2bYgP2KrVgk+GAZblUwoBmk+fdbY9cuRwMv1zccGPB2Nr54EbyhZdaqdgeDX8GHeIdKO7kWqfMXa6lzgNXagGbdpf+8n9bbWMHH9u0WBS7NPLjk4vx6HhMbXmvbYJ8rIetrzq4lSU1LWDJS+Xq+zPFrcX7t2uxczI8j55t36u1LjrnWihoV2bf1QuukSrE6NQAdwG2LHXmNybigmhsn4WvA2OXoIAoYjQtmnVB88y6SGpXG2mdJXkYTYozcCRuBi5pXWsLhsZhNCneg4KMJmI0KT4UgvrNYHSP6IccnztVvLQptpVv2YSzq/Lo51fvKNcMaaJLJ1XHgVIpfolUjO//DlxpdN9OIRYE09vf+3kE1n3H1xu295mD6TmV/BK9vadYiitCq8511BRW5cC6nnN0ZQ+3q42Sq6sv29VG1aQDWuCxtgevGglS/Q+ROOMJKkjtqReHO0EFqX6qxKlOUEGqSTXe0VcBHYPhL//pDwP/L2pJagdmybMdFgcb9ulZx6/FbQnmiyD6XBuc/8x/AWLth2k="
+window.navigationData = "eJylll9P2zAUxb+L9xoxGgobfaUIbS/bgLEHVFVufLuYGSfYDhQhvvsUu03sxHEc8Rqf8/O5vv6T+zekYKfQAqEElVjlaIEeC1IxkJ+PcvXIUIL+UU7QIk1QllNGBHC0uG9sd5ipHARebn5iIUHIlvOMBcUbTeqpXPZJ+p54iNfAsKIFH2M2uh51ZXEpJ7DrV6k/f7TUPuzT815NNmWjNvj57Hx+cjyPLTnIFpbepdulP3hwDzKqaAJbXDHV+jOGpTT+/ZjLmaVfnbnlUz3mQ+eYEwYDg1nBGGR1af3o8omtjXndyqKqMa4LAVhBy91WXCMGyZbLnebM7qKRLUVRTkXXnlHw5Y5KJaeijWsUfgVqKvkKVA9rN54AA3uVPd0zkgmdW3aY3qQHquUIBqVcglDBoEYyIei3DtMb9EC1HMGgEuoOBIMayYSgNx2mN+iBajkCO0rfd98Lyi8YriSMbdk9vOsam8DEMOIJM9i24GJXJcEj29dIJiz27w7Tm/ZAtRyeoBEvW82Mf90GL/oWE3XfV4oyz3NTU/RQVBjdqmtQleBDq2VglnB8wwxuc4t147nVrIe0oPyoVgcKXDeiqFLrLX9bNO/+Jf9LOfi70MV7rf3uJM5c3ROjXssA3ndQ0uPzL7PTtLMJX3IQA8dFD8X3/Y9LcltlWK1u5Gjo6vqp9OeoRD9K+82lXIHY4qxB1MMdzumZ58/O/DEGQK4wBvmrAvEaQdS6PnD1vvoPAUgwPQ=="

package/typedocs-generated/assets/search.js

@@ -1 +1 @@
-window.searchData = "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";
+window.searchData = "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";

package/typedocs-generated/assets/style.css

@@ -1595,9 +1595,9 @@
         .container-main {
             grid-template-columns:
                 minmax(0, 1fr) minmax(0, 2.5fr) minmax(
-                0,
-                20rem
-            );
+                    0,
+                    20rem
+                );
             grid-template-areas: "sidebar content toc";
         }