@wxn0brp/db-string-query 0.0.7 → 0.0.8

package/dist/test/sql/select.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "../../index.js";
+const sqlParser = new ValtheraDbParsers.sql();
+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 throw error for invalid SELECT syntax", () => {
+        const query = "SELECT FROM users";
+        expect(() => {
+            sqlParser.parse(query);
+        }).toThrow();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/sql/update.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/sql/update.test.js

@@ -0,0 +1,71 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "../../index.js";
+const sqlParser = new ValtheraDbParsers.sql();
+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");
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,44 +1,41 @@
 {
-    "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
-        }
+  "name": "@wxn0brp/db-string-query",
+  "version": "0.0.8",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wxn0brP/ValtheraDB-string-query.git"
+  },
+  "homepage": "https://github.com/wxn0brP/ValtheraDB-string-query",
+  "author": "wxn0brP",
+  "license": "MIT",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "^1.3.2",
+    "@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"
     },
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js",
-            "import": "./dist/index.js"
-        },
-        "./*": {
-            "types": "./dist/*.d.ts",
-            "default": "./dist/*.js",
-            "import": "./dist/*.js"
-        }
+    "./*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js",
+      "import": "./dist/*.js"
     }
+  }
 }

package/src/sql/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,11 @@ export function parseWhere(where: string): QueryObject {
             }
 
             let key = token;
-            let op = tokens[++i]?.trim();
+            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 +127,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 +140,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/test/js.test.ts

@@ -0,0 +1,103 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "..";
+
+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/src/test/sql/delete.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "../..";
+
+const sqlParser = new ValtheraDbParsers.sql();
+
+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/src/test/sql/insert.test.ts

@@ -0,0 +1,95 @@
+import { describe, expect, test } from "bun:test";
+import { ValtheraDbParsers } from "../..";
+
+const sqlParser = new ValtheraDbParsers.sql();
+
+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"
+		});
+	});
+});