@wxn0brp/db-string-query 0.0.7 → 0.0.9

package/src/sql/where.ts

@@ -1,7 +1,7 @@
 type QueryObject = Record<string, any>;
 
 const operators: Record<string, string> = {
-    "=": "",
+    "=": null,
     "<": "$lt",
     ">": "$gt",
     "<=": "$lte",
@@ -11,6 +11,27 @@ const operators: Record<string, string> = {
     "NOT IN": "$nin"
 };
 
+function mergeQueries(target: QueryObject, source: QueryObject) {
+    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: string): QueryObject {
     if (!where) return {};
     const trimmed = where.trim();
@@ -47,7 +68,7 @@ export function parseWhere(where: string): QueryObject {
             if (frames.length === 0) {
                 throw new Error("Unmatched closing parenthesis");
             }
-            const parentFrame = frames.pop();
+            const parentFrame = frames.pop()!;
             const parentCurrent = parentFrame.current;
             const parentOperatorStack = parentFrame.operatorStack;
             const parentStack = parentFrame.stack;
@@ -59,15 +80,21 @@ export function parseWhere(where: string): QueryObject {
                     parentStack.push(parentCurrent);
                     current = groupedQuery;
                 } else if (op === "AND") {
-                    current = { ...parentCurrent, ...groupedQuery };
+                    const newCurrent: QueryObject = {};
+                    mergeQueries(newCurrent, parentCurrent);
+                    mergeQueries(newCurrent, groupedQuery);
+                    current = newCurrent;
                 }
             } else {
-                current = { ...parentCurrent, ...groupedQuery };
+                const newCurrent: QueryObject = {};
+                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());
         } else {
@@ -82,11 +109,14 @@ export function parseWhere(where: string): QueryObject {
             }
 
             let key = token;
-            let op = tokens[++i]?.trim();
+            if (key.includes(".")) {
+                key = key.split(".").pop()!;
+            }
+            let opToken = tokens[++i]?.trim();
             let value: any = 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
@@ -100,9 +130,9 @@ export function parseWhere(where: string): QueryObject {
             }
 
             // 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: string) => {
                     v = v.trim();
@@ -113,16 +143,22 @@ export function parseWhere(where: string): QueryObject {
                 });
             }
 
-            // 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] as Record<string, any>)[mappedOp] = value;
+                    // Other operators - they go to the root level
+                    if (!current[mappedOp]) {
+                        current[mappedOp] = {};
+                    }
+                    (current[mappedOp] as Record<string, any>)[key] = value;
                 }
             } else {
+                // If operator not found, default to direct assignment
                 current[key] = value;
             }
         }

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/suglite.json

@@ -1,5 +1,5 @@
 {
-    "cmd": "yarn build && yarn start",
+    "cmd": "tsc --noEmit && bun test",
     "watch": [
         "src"
     ],
@@ -7,4 +7,4 @@
     "events": {
         "rs": "clear"
     }
-}
+}

package/test/js.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "#index";
+
+const jsParser = new ValtheraDbParsers.js();
+
+describe("JS-like Parser", () => {
+    test("should parse a simple method call with arguments", () => {
+        const query = "myMethod(1, 'hello')";
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("myMethod");
+        expect(parsedQuery.args).toHaveLength(2);
+        expect(parsedQuery.args[0]).toBe(1);
+        expect(parsedQuery.args[1]).toBe("hello");
+    });
+
+    test("should parse method call with object argument", () => {
+        const query = `find({ id: 1, name: "John" })`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("find");
+        expect(parsedQuery.args).toHaveLength(1);
+        expect(parsedQuery.args[0]).toEqual({ id: 1, name: "John" });
+    });
+
+    test("should parse method call with array argument", () => {
+        const query = `myMethod([1, 2, 3])`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("myMethod");
+        expect(parsedQuery.args).toHaveLength(1);
+        expect(parsedQuery.args[0]).toEqual([1, 2, 3]);
+    });
+
+    test("should parse method call with nested objects and arrays", () => {
+        const query = `complexMethod({ users: [{ id: 1, active: true }], settings: { theme: "dark" } })`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("complexMethod");
+        expect(parsedQuery.args).toHaveLength(1);
+        expect(parsedQuery.args[0]).toEqual({
+            users: [{ id: 1, active: true }],
+            settings: { theme: "dark" }
+        });
+    });
+
+    test("should parse method call with mixed argument types", () => {
+        const query = `mixedArgs(42, "text", true, null, [1, "two", false])`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("mixedArgs");
+        expect(parsedQuery.args).toHaveLength(5);
+        expect(parsedQuery.args[0]).toBe(42);
+        expect(parsedQuery.args[1]).toBe("text");
+        expect(parsedQuery.args[2]).toBe(true);
+        expect(parsedQuery.args[3]).toBeNull();
+        expect(parsedQuery.args[4]).toEqual([1, "two", false]);
+    });
+
+    test("should handle string arguments with quotes", () => {
+        const query = `stringMethod("double quotes", 'single quotes')`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("stringMethod");
+        expect(parsedQuery.args).toHaveLength(2);
+        expect(parsedQuery.args[0]).toBe("double quotes");
+        expect(parsedQuery.args[1]).toBe("single quotes");
+    });
+
+    test("should throw error for invalid query syntax", () => {
+        const query = "invalidQuery";
+
+        expect(() => {
+            jsParser.parse(query);
+        }).toThrow("Invalid query");
+    });
+
+    test("should throw error for malformed arguments", () => {
+        const query = "method({unclosed: object";
+
+        expect(() => {
+            jsParser.parse(query);
+        }).toThrow();
+    });
+
+    test("should parse floating point numbers correctly", () => {
+        const query = `numberMethod(3.14, -2.5, 0.001)`;
+        const parsedQuery = jsParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("numberMethod");
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe(3.14);
+        expect(parsedQuery.args[1]).toBe(-2.5);
+        expect(parsedQuery.args[2]).toBe(0.001);
+    });
+});

package/test/sql/delete.test.ts

@@ -0,0 +1,95 @@
+import SQLParser from "#sql";
+import { describe, expect, test } from "bun:test";
+
+const sqlParser = new SQLParser();
+
+describe("SQL Parser - DELETE", () => {
+	test("should parse a simple DELETE query", () => {
+		const query = "DELETE FROM users WHERE id = 1";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove"); // DELETE maps to "remove" method
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+	});
+
+	test("should parse DELETE query without WHERE clause", () => {
+		const query = "DELETE FROM users";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({}); // empty where clause
+	});
+
+	test("should parse DELETE with complex WHERE conditions", () => {
+		const query = "DELETE FROM users WHERE age > 65 AND status = 'inactive'";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ $gt: { age: 65 }, status: "inactive" }); // where clause
+	});
+
+	test("should parse DELETE with string values", () => {
+		const query = "DELETE FROM posts WHERE title = 'Unwanted Post'";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("posts"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ title: "Unwanted Post" }); // where clause
+	});
+
+	test("should parse DELETE with numeric values", () => {
+		const query = "DELETE FROM products WHERE price = 0";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("products"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ price: 0 }); // where clause
+	});
+
+	test("should throw error for invalid DELETE syntax", () => {
+		const query = "DELETE users WHERE id = 1"; // missing FROM keyword
+
+		expect(() => {
+			sqlParser.parse(query);
+		}).toThrow("Invalid DELETE syntax");
+	});
+
+	test("should parse DELETE with quoted string values", () => {
+		const query = "DELETE FROM users WHERE name = 'John Doe'";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ name: "John Doe" }); // where clause
+	});
+
+	test("should handle DELETE with multiple condition types", () => {
+		const query = "DELETE FROM orders WHERE total > 1000 AND status = 'cancelled' AND user_id != 5";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("remove");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("orders"); // collection name
+		expect(parsedQuery.args[1]).toEqual({
+			$gt: { total: 1000 },
+			status: "cancelled",
+			$not: { user_id: 5 }
+		}); // where clause with multiple operators
+	});
+});

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/test/sql/insert.test.ts

@@ -0,0 +1,95 @@
+import SQLParser from "#sql";
+import { describe, expect, test } from "bun:test";
+
+const sqlParser = new SQLParser();
+
+describe("SQL Parser - INSERT", () => {
+	test("should parse a simple INSERT query", () => {
+		const query = "INSERT INTO users (name, email) VALUES ('John', 'john@example.com')";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add"); // INSERT maps to "add" method
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ name: "John", email: "john@example.com" }); // data
+	});
+
+	test("should parse INSERT with numeric values", () => {
+		const query = "INSERT INTO products (id, name, price) VALUES (1, 'Laptop', 999.99)";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("products"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ id: 1, name: "Laptop", price: 999.99 }); // data with numeric values
+	});
+
+	test("should parse INSERT with mixed data types", () => {
+		const query = "INSERT INTO users (id, name, active, score) VALUES (1, 'Jane', true, 95.5)";
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ id: 1, name: "Jane", active: "true", score: 95.5 });
+	});
+
+	test("should handle INSERT with quoted values containing commas", () => {
+		const query = `INSERT INTO posts (title, content) VALUES ('Hello, World!', 'This is a post, with commas.')`;
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("posts"); // collection name
+		expect(parsedQuery.args[1]).toEqual({
+			title: "Hello, World!",
+			content: "This is a post, with commas."
+		});
+	});
+
+	test("should throw error for mismatched columns and values", () => {
+		const query = "INSERT INTO users (name, email) VALUES ('John')"; // missing value
+
+		expect(() => {
+			sqlParser.parse(query);
+		}).toThrow("Number of columns and values does not match");
+	});
+
+	test("should throw error for invalid INSERT syntax", () => {
+		const query = "INSERT users (name) VALUES ('John')"; // missing INTO
+
+		expect(() => {
+			sqlParser.parse(query);
+		}).toThrow("Invalid INSERT syntax");
+	});
+
+	test("should handle INSERT with double quotes", () => {
+		const query = 'INSERT INTO users (name, email) VALUES ("Jane", "jane@example.com")';
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({ name: "Jane", email: "jane@example.com" });
+	});
+
+	test("should handle INSERT with mixed quote types", () => {
+		const query = `INSERT INTO users (name, email, description) VALUES ("Jane", 'jane@example.com', "User, with 'special' chars")`;
+		const parsedQuery = sqlParser.parse(query);
+
+		expect(parsedQuery).toBeDefined();
+		expect(parsedQuery.method).toBe("add");
+		expect(parsedQuery.args).toHaveLength(2);
+		expect(parsedQuery.args[0]).toBe("users"); // collection name
+		expect(parsedQuery.args[1]).toEqual({
+			name: "Jane",
+			email: "jane@example.com",
+			description: "User, with 'special' chars"
+		});
+	});
+});

package/test/sql/select.test.ts

@@ -0,0 +1,92 @@
+import SQLParser from "#sql";
+import { describe, expect, test } from "bun:test";
+
+const sqlParser = new SQLParser();
+
+describe("SQL Parser - SELECT", () => {
+    test("should parse a simple SELECT query", () => {
+        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
+    });
+
+    test("should parse a SELECT query with specific columns", () => {
+        const query = "SELECT name, email FROM users WHERE active = 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({ active: 1 }); // where clause
+        expect(parsedQuery.args[3]).toEqual({ select: ["name", "email"] }); // select options
+    });
+
+    test("should parse a SELECT query without WHERE clause", () => {
+        const query = "SELECT * FROM users";
+        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({}); // empty where clause
+    });
+
+    test("should parse a SELECT query with EXCLUDE clause", () => {
+        const query = "SELECT * EXCLUDE password, createdAt FROM users WHERE active = 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({ active: 1 }); // where clause
+        expect(parsedQuery.args[3]).toEqual({ exclude: ["password", "createdAt"] }); // exclude options
+    });
+
+    test("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);
+
+        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({ $gt: { age: 18 }, status: "active" }); // where clause
+    });
+
+    test("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', 'posts'],
+                pk: 'id',
+                fk: 'userId',
+                as: 'users'
+            }
+        }); // relations
+        expect(parsedQuery.args[3]).toEqual({ select: ["posts.*", "users.name"] }); // select options
+    });
+
+    test("should throw error for invalid SELECT syntax", () => {
+        const query = "SELECT FROM users";
+
+        expect(() => {
+            sqlParser.parse(query);
+        }).toThrow();
+    });
+});

package/test/sql/update.test.ts

@@ -0,0 +1,85 @@
+import SQLParser from "#sql";
+import { describe, expect, test } from "bun:test";
+
+const sqlParser = new SQLParser();
+
+describe("SQL Parser - UPDATE", () => {
+    test("should parse a simple UPDATE query", () => {
+        const query = "UPDATE users SET name = 'John' WHERE id = 1";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("update"); // UPDATE maps to "update" method
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe("users"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({ name: "John" }); // set clause
+    });
+
+    test("should parse UPDATE with multiple SET fields", () => {
+        const query = "UPDATE users SET name = 'Jane', email = 'jane@example.com' WHERE id = 2";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("update");
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe("users"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ id: 2 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({ name: "Jane", email: "jane@example.com" }); // set clause
+    });
+
+    test("should parse UPDATE with numeric values", () => {
+        const query = "UPDATE products SET price = 29.99, stock = 100 WHERE id = 1";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("update");
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe("products"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({ price: 29.99, stock: 100 }); // set clause
+    });
+
+    test("should parse UPDATE with string values containing spaces", () => {
+        const query = "UPDATE posts SET title = 'Hello World Post', content = 'This is the content' WHERE id = 1";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("update");
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe("posts"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ id: 1 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({
+            title: "Hello World Post",
+            content: "This is the content"
+        }); // set clause
+    });
+
+    test("should throw error for invalid UPDATE syntax", () => {
+        const query = "UPDATE users name = 'John' WHERE id = 1"; // missing SET keyword
+
+        expect(() => {
+            sqlParser.parse(query);
+        }).toThrow("Invalid UPDATE syntax");
+    });
+
+    test("should handle UPDATE with complex WHERE conditions", () => {
+        const query = "UPDATE users SET status = 'inactive' WHERE age > 65 AND active = 1";
+        const parsedQuery = sqlParser.parse(query);
+
+        expect(parsedQuery).toBeDefined();
+        expect(parsedQuery.method).toBe("update");
+        expect(parsedQuery.args).toHaveLength(3);
+        expect(parsedQuery.args[0]).toBe("users"); // collection name
+        expect(parsedQuery.args[1]).toEqual({ $gt: { age: 65 }, active: 1 }); // where clause
+        expect(parsedQuery.args[2]).toEqual({ status: "inactive" }); // set clause
+    });
+
+    test("should throw error when there is no WHERE clause", () => {
+        const query = "UPDATE users SET name = 'John'"; // missing WHERE
+
+        expect(() => {
+            sqlParser.parse(query);
+        }).toThrow("Invalid UPDATE syntax");
+    });
+});