toge-db 1.0.0

package/.env.example

@@ -0,0 +1,2 @@
+Toge_DB_ADMIN_USER=admin-env
+Toge_DB_ADMIN_PASSWORD=password

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2026 M Iqbal Revantama
+
+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,197 @@
+# Toge-DB ORM Documentation
+
+Toge-DB is a lightweight JSON-based database with a simple ORM (Object-Relational Mapping) layer. It is specifically designed to be highly suitable for rapid prototyping and offline applications, such as those built with Electron or other JavaScript frameworks. This documentation explains how to define models, perform queries, and manage data using the TogeORM.
+
+> [**WARNING**]
+> **Disclaimer: AI-Generated Software**
+> This library is approximately 99.99% generated by artificial intelligence (AI). While it is designed to provide a lightweight database and ORM solution, we cannot guarantee its reliability or performance in all scenarios. Use this library at your own risk. We are not responsible for any issues or damages that may arise from its use in your application.
+
+## Table of Contents
+- [CLI Usage](#cli-usage)
+- [Initialization](#initialization)
+- [Defining Models](#defining-models)
+- [Creating Data](#creating-data)
+- [Querying Data](#querying-data)
+- [Updating Data](#updating-data)
+- [Deleting Data](#deleting-data)
+
+
+---
+## CLI Usage
+
+TogeDB comes with a raw CLI that supports SQL-like queries. You can start the CLI by running `npm run toge-start`.
+
+### Authentication
+Please set the in .env file with the following credentials:
+```
+TOGE_DB_ADMIN_USER=your-username
+TOGE_DB_ADMIN_PASSWORD=your-password
+```
+
+### Supported SQL Commands
+
+The CLI supports the following raw commands:
+
+#### CREATE TABLE
+```sql
+CREATE TABLE users (username string PRIMARY KEY, email string, age int)
+```
+
+#### INSERT INTO
+```sql
+INSERT INTO users VALUES ('johndoe', 'john@example.com', 30)
+```
+
+#### SELECT
+Supports column selection, `WHERE` clause (simple `col=val`), and `LIMIT`.
+```sql
+SELECT * FROM users
+SELECT username, email FROM users WHERE age=30
+SELECT * FROM users LIMIT 5
+```
+
+#### UPDATE
+```sql
+UPDATE users SET age=31 WHERE username='johndoe'
+```
+
+#### DELETE
+```sql
+DELETE FROM users WHERE username='johndoe'
+```
+
+#### DROP TABLE
+```sql
+DROP TABLE users
+```
+
+#### ALTER TABLE
+```sql
+ALTER TABLE users ADD bio string
+```
+
+---
+
+## Initialization
+
+To start using TogeDB ORM, initialize the `TogeORM` with a directory path where your data will be stored.
+
+```javascript
+import { TogeORM } from 'toge-db';
+const orm = new TogeORM('./data');
+```
+
+## Defining Models
+
+Use `orm.define(modelName, schema)` to create a new model. If no primary key is defined in the schema, an auto-incrementing `id` field will be added automatically.
+
+### Schema Options
+- `type`: Data type (e.g., 'string', 'int').
+- `primaryKey`: Boolean, marks the column as a primary key.
+- `autoIncrement`: Boolean, enables auto-increment for the column.
+
+```javascript
+const User = orm.define('user', {
+    username: { type: 'string', primaryKey: true },
+    email: { type: 'string' },
+    age: { type: 'int' }
+});
+
+const Post = orm.define('post', {
+    title: { type: 'string' },
+    content: { type: 'string' }
+}); // Automatically adds an 'id' primary key
+```
+
+---
+
+## Creating Data
+
+There are two ways to create and persist data:
+
+### 1. Using `Model.create()`
+Directly creates and saves a new record.
+
+```javascript
+const newUser = User.create({
+    username: 'johndoe',
+    email: 'john@example.com',
+    age: 30
+});
+```
+
+### 2. Using `new Model()` and `save()`
+Instantiate a model and save it later.
+
+```javascript
+const post = new Post({
+    title: 'Hello TogeDB',
+    content: 'This is my first post.'
+});
+post.save();
+```
+
+---
+
+## Querying Data
+
+TogeDB uses JavaScript functions as conditions for querying.
+
+### Find All
+`Model.find(condition)` returns an array of model instances. If no condition is provided, it returns all records.
+
+```javascript
+// Find all users
+const allUsers = User.find();
+
+// Find users older than 25
+const seniors = User.find(user => user.age > 25);
+```
+
+### Find One
+`Model.findOne(condition)` returns the first matching model instance or `null`.
+
+```javascript
+const user = User.findOne(u => u.username === 'johndoe');
+```
+
+---
+
+## Updating Data
+
+### 1. Static Update
+Update multiple records matching a condition.
+
+```javascript
+User.update(
+    user => user.username === 'johndoe',
+    { age: 31 }
+);
+```
+
+### 2. Instance Update
+Modify an instance and call `save()`. This requires the model to have a primary key.
+
+```javascript
+const user = User.findOne(u => u.username === 'johndoe');
+if (user) {
+    user.email = 'newjohn@example.com';
+    user.save();
+}
+```
+
+---
+
+## Deleting Data
+
+Use `Model.delete(condition)` to remove records from the database.
+
+```javascript
+// Delete a specific user
+User.delete(user => user.username === 'johndoe');
+
+// Delete all posts
+Post.delete(() => true);
+```
+
+---

package/example-app/.env.example

@@ -0,0 +1,2 @@
+Toge_DB_ADMIN_USER=admin-env
+Toge_DB_ADMIN_PASSWORD=password

package/example-app/index.js

@@ -0,0 +1,17 @@
+import { TogeORM } from 'toge-db';
+const orm = new TogeORM('./data');
+
+const User = orm.define('user', {
+    username: { type: 'string', primaryKey: true },
+    email: { type: 'string' },
+    age: { type: 'int' }
+});
+
+const newUser = User.create({
+    username: 'johntest',
+    email: 'john@example.com',
+    age: 30
+});
+
+const allUsers = User.find();
+console.log('New user:', allUsers);

package/example-app/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "example-app",
+  "version": "1.0.0",
+  "description": "",
+  "license": "MIT",
+  "author": "",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/index.js

@@ -0,0 +1,20 @@
+import Storage from './src/engine/storage.js';
+import Parser from './src/parser/parser.js';
+import CLI from './src/cli/repl.js';
+import TogeORM from './src/orm/orm.js';
+import { fileURLToPath } from 'url';
+
+export {
+    Storage,
+    Parser,
+    CLI,
+    TogeORM
+};
+
+// Only start CLI if this file is run directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    const storage = new Storage();
+    const parser = new Parser(storage);
+    const cli = new CLI(parser);
+    cli.start();
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "toge-db",
+  "version": "1.0.0",
+  "description": "Toge-DB is a lightweight JSON-based database with a simple ORM (Object-Relational Mapping) layer. It is specifically designed to be highly suitable for rapid prototyping and offline applications, such as those built with Electron or other JavaScript frameworks. This documentation explains how to define models, perform queries, and manage data using the TogeORM.\n",
+  "keywords": [
+    "database",
+    "sql"
+  ],
+  "license": "MIT",
+  "author": "Revtm",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "toge-start": "node index.js",
+    "toge-test": "node test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Revtm/toge-db"
+  },
+  "dependencies": {
+    "dotenv": "^17.2.3"
+  }
+}

package/src/cli/repl.js

@@ -0,0 +1,69 @@
+import readline from 'readline';
+import dotenv from 'dotenv';
+dotenv.config();
+
+class CLI {
+    constructor(parser) {
+        this.parser = parser;
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: 'Toge-DB> '
+        });
+        this.authenticated = false;
+        
+        const adminUser = process.env.Toge_DB_ADMIN_USER;
+        const adminPass = process.env.Toge_DB_ADMIN_PASSWORD;
+        this.credentials = { [adminUser]: adminPass };
+    }
+
+    start() {
+        console.log('Welcome to Toge-DB');
+        this.login();
+    }
+
+    login() {
+        this.rl.question('Username: ', (username) => {
+            this.rl.question('Password: ', (password) => {
+                if (this.credentials[username] && this.credentials[username] === password) {
+                    this.authenticated = true;
+                    console.log('Login successful.');
+                    this.runREPL();
+                } else {
+                    console.log('Invalid credentials.');
+                    this.login();
+                }
+            });
+        });
+    }
+
+    runREPL() {
+        this.rl.prompt();
+        this.rl.on('line', (line) => {
+            const query = line.trim();
+            if (query.toLowerCase() === 'exit' || query.toLowerCase() === 'quit') {
+                this.rl.close();
+                return;
+            }
+
+            if (query) {
+                try {
+                    const result = this.parser.execute(query);
+                    if (Array.isArray(result)) {
+                        console.table(result);
+                    } else {
+                        console.log(result);
+                    }
+                } catch (err) {
+                    console.error(`Error: ${err.message}`);
+                }
+            }
+            this.rl.prompt();
+        }).on('close', () => {
+            console.log('Goodbye!');
+            process.exit(0);
+        });
+    }
+}
+
+export default CLI;

package/src/engine/storage.js

@@ -0,0 +1,163 @@
+import fs from 'fs';
+import path from 'path';
+
+class Storage {
+    constructor(dataDir = 'data') {
+        this.dataDir = path.resolve(dataDir);
+        if (!fs.existsSync(this.dataDir)) {
+            fs.mkdirSync(this.dataDir);
+        }
+        this.metadataPath = path.join(this.dataDir, 'metadata.json');
+        this.metadata = this.loadMetadata();
+    }
+
+    loadMetadata() {
+        if (fs.existsSync(this.metadataPath)) {
+            return JSON.parse(fs.readFileSync(this.metadataPath, 'utf8'));
+        }
+        return { tables: {} };
+    }
+
+    saveMetadata() {
+        fs.writeFileSync(this.metadataPath, JSON.stringify(this.metadata, null, 2));
+    }
+
+    getTablePath(tableName) {
+        return path.join(this.dataDir, `${tableName}.json`);
+    }
+
+    createTable(tableName, schema) {
+        if (this.metadata.tables[tableName]) {
+            throw new Error(`Table "${tableName}" already exists.`);
+        }
+
+        // Check for primary key, if not exists add auto-incrementing 'id'
+        let hasPK = Object.values(schema).some(col => col.primaryKey);
+        if (!hasPK) {
+            schema = { id: { type: 'int', primaryKey: true, autoIncrement: true }, ...schema };
+        }
+
+        this.metadata.tables[tableName] = {
+            schema,
+            nextId: 1
+        };
+        this.saveMetadata();
+        fs.writeFileSync(this.getTablePath(tableName), JSON.stringify([], null, 2));
+    }
+
+    dropTable(tableName) {
+        if (!this.metadata.tables[tableName]) {
+            throw new Error(`Table "${tableName}" does not exist.`);
+        }
+        delete this.metadata.tables[tableName];
+        this.saveMetadata();
+        const tablePath = this.getTablePath(tableName);
+        if (fs.existsSync(tablePath)) {
+            fs.unlinkSync(tablePath);
+        }
+    }
+
+    loadRows(tableName) {
+        if (!this.metadata.tables[tableName]) {
+            throw new Error(`Table "${tableName}" does not exist.`);
+        }
+        const tablePath = this.getTablePath(tableName);
+        return JSON.parse(fs.readFileSync(tablePath, 'utf8'));
+    }
+
+    saveRows(tableName, rows) {
+        fs.writeFileSync(this.getTablePath(tableName), JSON.stringify(rows, null, 2));
+    }
+
+    insert(tableName, rowData) {
+        const tableMeta = this.metadata.tables[tableName];
+        if (!tableMeta) throw new Error(`Table "${tableName}" does not exist.`);
+
+        const rows = this.loadRows(tableName);
+        const newRow = {};
+
+        // Prepare new row and handle auto-increment
+        for (const [colName, colSpec] of Object.entries(tableMeta.schema)) {
+            if (colSpec.autoIncrement) {
+                newRow[colName] = tableMeta.nextId++;
+            } else {
+                newRow[colName] = rowData[colName] !== undefined ? rowData[colName] : null;
+            }
+        }
+
+        // Enforce primary key uniqueness
+        const pkColumns = Object.entries(tableMeta.schema)
+            .filter(([_, spec]) => spec.primaryKey)
+            .map(([name, _]) => name);
+
+        if (pkColumns.length > 0) {
+            const isDuplicate = rows.some(row => 
+                pkColumns.every(col => String(row[col]) === String(newRow[col]))
+            );
+            if (isDuplicate) {
+                throw new Error(`Duplicate entry for primary key.`);
+            }
+        }
+
+        rows.push(newRow);
+        this.saveRows(tableName, rows);
+        this.saveMetadata();
+        return newRow;
+    }
+
+    update(tableName, condition, newData) {
+        const tableMeta = this.metadata.tables[tableName];
+        if (!tableMeta) throw new Error(`Table "${tableName}" does not exist.`);
+
+        let rows = this.loadRows(tableName);
+        let updatedCount = 0;
+
+        rows = rows.map(row => {
+            if (condition(row)) {
+                updatedCount++;
+                return { ...row, ...newData };
+            }
+            return row;
+        });
+
+        this.saveRows(tableName, rows);
+        return updatedCount;
+    }
+
+    delete(tableName, condition) {
+        if (!this.metadata.tables[tableName]) throw new Error(`Table "${tableName}" does not exist.`);
+
+        let rows = this.loadRows(tableName);
+        const initialCount = rows.length;
+        rows = rows.filter(row => !condition(row));
+        
+        this.saveRows(tableName, rows);
+        return initialCount - rows.length;
+    }
+
+    select(tableName, condition = () => true) {
+        const rows = this.loadRows(tableName);
+        return rows.filter(condition);
+    }
+    
+    alterTable(tableName, action, details) {
+        const tableMeta = this.metadata.tables[tableName];
+        if (!tableMeta) throw new Error(`Table "${tableName}" does not exist.`);
+
+        if (action === 'ADD_COLUMN') {
+            const { colName, colSpec } = details;
+            if (tableMeta.schema[colName]) throw new Error(`Column "${colName}" already exists.`);
+            
+            tableMeta.schema[colName] = colSpec;
+            this.saveMetadata();
+            
+            const rows = this.loadRows(tableName);
+            const updatedRows = rows.map(row => ({ ...row, [colName]: null }));
+            this.saveRows(tableName, updatedRows);
+        } else {
+            throw new Error(`Action "${action}" not supported for ALTER TABLE.`);
+        }
+    }
+}
+
+export default Storage;

package/src/orm/model.js

@@ -0,0 +1,74 @@
+class Model {
+    constructor(data = {}) {
+        Object.assign(this, data);
+    }
+
+    static init(tableName, schema, storage) {
+        this.tableName = tableName;
+        this.schema = schema;
+        this.storage = storage;
+
+        // Create table if it doesn't exist
+        try {
+            this.storage.createTable(this.tableName, this.schema);
+        } catch (e) {
+            // Ignore if table already exists
+            if (!e.message.includes('already exists')) {
+                throw e;
+            }
+        }
+    }
+
+    static create(data) {
+        const result = this.storage.insert(this.tableName, data);
+        return new this(result);
+    }
+
+    static find(condition = () => true) {
+        const results = this.storage.select(this.tableName, condition);
+        return results.map(row => new this(row));
+    }
+
+    static findOne(condition) {
+        const results = this.find(condition);
+        return results.length > 0 ? results[0] : null;
+    }
+
+    save() {
+        const tableMeta = this.constructor.storage.metadata.tables[this.constructor.tableName];
+        const pkColumns = Object.entries(tableMeta.schema)
+            .filter(([_, spec]) => spec.primaryKey)
+            .map(([name, _]) => name);
+
+        if (pkColumns.length === 0) {
+            throw new Error('Cannot save model without primary key');
+        }
+
+        // Check if all primary keys are present
+        const condition = (row) => pkColumns.every(col => row[col] === this[col]);
+        
+        // Try to find if it exists
+        const existing = this.constructor.storage.select(this.constructor.tableName, condition);
+        
+        if (existing.length > 0) {
+            // Update
+            const dataToUpdate = { ...this };
+            // Remove storage and metadata from data if they were somehow attached
+            this.constructor.storage.update(this.constructor.tableName, condition, dataToUpdate);
+        } else {
+            // Insert
+            const result = this.constructor.storage.insert(this.constructor.tableName, this);
+            Object.assign(this, result);
+        }
+    }
+
+    static update(condition, newData) {
+        return this.storage.update(this.tableName, condition, newData);
+    }
+
+    static delete(condition) {
+        return this.storage.delete(this.tableName, condition);
+    }
+}
+
+export default Model;

package/src/orm/orm.js

@@ -0,0 +1,18 @@
+import Storage from '../engine/storage.js';
+import Model from './model.js';
+
+class TogeORM {
+    constructor(dataDir) {
+        this.storage = new Storage(dataDir);
+        this.models = {};
+    }
+
+    define(modelName, schema) {
+        const NewModel = class extends Model {};
+        NewModel.init(modelName, schema, this.storage);
+        this.models[modelName] = NewModel;
+        return NewModel;
+    }
+}
+
+export default TogeORM;

package/src/parser/parser.js

@@ -0,0 +1,215 @@
+class Parser {
+    constructor(storage) {
+        this.storage = storage;
+    }
+
+    execute(query) {
+        query = query.trim();
+        if (query.toUpperCase().startsWith('CREATE TABLE')) {
+            return this.handleCreateTable(query);
+        } else if (query.toUpperCase().startsWith('INSERT INTO')) {
+            return this.handleInsert(query);
+        } else if (query.toUpperCase().startsWith('SELECT')) {
+            return this.handleSelect(query);
+        } else if (query.toUpperCase().startsWith('UPDATE')) {
+            return this.handleUpdate(query);
+        } else if (query.toUpperCase().startsWith('DELETE FROM')) {
+            return this.handleDelete(query);
+        } else if (query.toUpperCase().startsWith('DROP TABLE')) {
+            return this.handleDropTable(query);
+        } else if (query.toUpperCase().startsWith('ALTER TABLE')) {
+            return this.handleAlterTable(query);
+        } else {
+            throw new Error('Unsupported command.');
+        }
+    }
+
+    handleCreateTable(query) {
+        // CREATE TABLE <table_name> (<col1> <type> [PRIMARY KEY], ..., [PRIMARY KEY (<col1>, <col2>)])
+        const match = query.match(/CREATE TABLE (\w+) \((.*)\)/i);
+        if (!match) throw new Error('Invalid CREATE TABLE syntax.');
+
+        const tableName = match[1];
+        const columnsStr = match[2];
+        const schema = {};
+        let compositePK = null;
+
+        // Split by comma but ignore commas inside parentheses (for composite PK)
+        const parts = [];
+        let currentPart = '';
+        let bracketLevel = 0;
+        for (let i = 0; i < columnsStr.length; i++) {
+            const char = columnsStr[i];
+            if (char === '(') bracketLevel++;
+            if (char === ')') bracketLevel--;
+            if (char === ',' && bracketLevel === 0) {
+                parts.push(currentPart.trim());
+                currentPart = '';
+            } else {
+                currentPart += char;
+            }
+        }
+        parts.push(currentPart.trim());
+
+        parts.forEach(part => {
+            if (part.toUpperCase().startsWith('PRIMARY KEY')) {
+                const pkMatch = part.match(/PRIMARY KEY\s*\((.*)\)/i);
+                if (pkMatch) {
+                    compositePK = pkMatch[1].split(',').map(c => c.trim());
+                }
+            } else {
+                const segments = part.split(/\s+/);
+                const name = segments[0];
+                const type = segments[1];
+                const isPK = part.toUpperCase().includes('PRIMARY KEY');
+                schema[name] = { type: type.toLowerCase() };
+                if (isPK) {
+                    schema[name].primaryKey = true;
+                }
+            }
+        });
+
+        if (compositePK) {
+            compositePK.forEach(colName => {
+                if (schema[colName]) {
+                    schema[colName].primaryKey = true;
+                } else {
+                    throw new Error(`Primary key column "${colName}" not found in schema.`);
+                }
+            });
+        }
+
+        this.storage.createTable(tableName, schema);
+        return `Table "${tableName}" created successfully.`;
+    }
+
+    handleInsert(query) {
+        // INSERT INTO <table_name> VALUES (...)
+        // Simplified: assuming values are in same order as schema (excluding auto-increment)
+        const match = query.match(/INSERT INTO (\w+) VALUES \((.*)\)/i);
+        if (!match) throw new Error('Invalid INSERT INTO syntax.');
+
+        const tableName = match[1];
+        const valuesStr = match[2];
+        const values = valuesStr.split(',').map(v => v.trim().replace(/^'|'$/g, ''));
+
+        const tableMeta = this.storage.metadata.tables[tableName];
+        if (!tableMeta) throw new Error(`Table "${tableName}" does not exist.`);
+
+        const rowData = {};
+        const colNames = Object.keys(tableMeta.schema).filter(name => !tableMeta.schema[name].autoIncrement);
+
+        colNames.forEach((name, index) => {
+            rowData[name] = values[index];
+        });
+
+        const newRow = this.storage.insert(tableName, rowData);
+        return `Row inserted into "${tableName}": ${JSON.stringify(newRow)}`;
+    }
+
+    handleSelect(query) {
+        // SELECT <columns> FROM <table_name> [WHERE <condition>] [LIMIT <number>]
+        const match = query.match(/SELECT\s+(.*?)\s+FROM\s+(\w+)(?:\s+WHERE\s+(.*?))?(?:\s+LIMIT\s+(\d+))?$/i);
+        if (!match) throw new Error('Invalid SELECT syntax.');
+
+        const columnsStr = match[1].trim();
+        const tableName = match[2];
+        const whereClause = match[3];
+        const limit = match[4] ? parseInt(match[4], 10) : null;
+
+        let condition = () => true;
+        if (whereClause) {
+            condition = this.parseCondition(whereClause);
+        }
+
+        let rows = this.storage.select(tableName, condition);
+
+        // Handle columns
+        if (columnsStr !== '*') {
+            const columns = columnsStr.split(',').map(c => c.trim());
+            rows = rows.map(row => {
+                const filteredRow = {};
+                columns.forEach(col => {
+                    filteredRow[col] = row[col];
+                });
+                return filteredRow;
+            });
+        }
+
+        // Handle limit
+        if (limit !== null) {
+            rows = rows.slice(0, limit);
+        }
+
+        return rows;
+    }
+
+    handleUpdate(query) {
+        // UPDATE <table_name> SET <col>=<val> WHERE <condition>
+        const match = query.match(/UPDATE (\w+) SET (\w+)=['"]?(.*?)['"]? WHERE (.*)/i);
+        if (!match) throw new Error('Invalid UPDATE syntax.');
+
+        const tableName = match[1];
+        const colName = match[2];
+        const newVal = match[3];
+        const whereClause = match[4];
+
+        const condition = this.parseCondition(whereClause);
+        const count = this.storage.update(tableName, condition, { [colName]: newVal });
+
+        return `${count} row(s) updated in "${tableName}".`;
+    }
+
+    handleDelete(query) {
+        // DELETE FROM <table_name> WHERE <condition>
+        const match = query.match(/DELETE FROM (\w+) WHERE (.*)/i);
+        if (!match) throw new Error('Invalid DELETE syntax.');
+
+        const tableName = match[1];
+        const whereClause = match[2];
+
+        const condition = this.parseCondition(whereClause);
+        const count = this.storage.delete(tableName, condition);
+
+        return `${count} row(s) deleted from "${tableName}".`;
+    }
+
+    handleDropTable(query) {
+        // DROP TABLE <table_name>
+        const match = query.match(/DROP TABLE (\w+)/i);
+        if (!match) throw new Error('Invalid DROP TABLE syntax.');
+
+        const tableName = match[1];
+        this.storage.dropTable(tableName);
+        return `Table "${tableName}" dropped.`;
+    }
+
+    handleAlterTable(query) {
+        // ALTER TABLE <table_name> ADD <col> <type>
+        const match = query.match(/ALTER TABLE (\w+) ADD (\w+) (\w+)/i);
+        if (!match) throw new Error('Invalid ALTER TABLE syntax.');
+
+        const tableName = match[1];
+        const colName = match[2];
+        const colType = match[3];
+
+        this.storage.alterTable(tableName, 'ADD_COLUMN', { colName, colSpec: { type: colType.toLowerCase() } });
+        return `Table "${tableName}" altered: column "${colName}" added.`;
+    }
+
+    parseCondition(whereClause) {
+        // Simple condition parser: col=val
+        const match = whereClause.match(/(\w+)\s*=\s*(.*)$/);
+        if (!match) throw new Error('Invalid WHERE clause syntax (only col=val supported).');
+
+        const col = match[1];
+        let val = match[2].trim();
+
+        // Remove surrounding quotes if any
+        val = val.replace(/^['"](.*)['"]$/, '$1');
+
+        return (row) => String(row[col]) === String(val);
+    }
+}
+
+export default Parser;

package/test.js

@@ -0,0 +1,177 @@
+import Storage from './src/engine/storage.js';
+import Parser from './src/parser/parser.js';
+import fs from 'fs';
+import path from 'path';
+
+async function runTests() {
+    console.log('Running All Tests...');
+    const testDataDir = 'test_data';
+    
+    function cleanup() {
+        if (fs.existsSync(testDataDir)) {
+            fs.rmSync(testDataDir, { recursive: true, force: true });
+        }
+    }
+
+    cleanup();
+    
+    const storage = new Storage(testDataDir);
+    const parser = new Parser(storage);
+
+    try {
+        // --- Core Functionality Tests (from original test.js) ---
+        console.log('\n--- Core Functionality Tests ---');
+        
+        // Test CREATE TABLE
+        console.log('Testing CREATE TABLE...');
+        parser.execute('CREATE TABLE users (name string, age int)');
+        if (!storage.metadata.tables.users) throw new Error('Table users not created');
+        if (!storage.metadata.tables.users.schema.id) throw new Error('Auto-increment ID not added');
+        console.log('✓ CREATE TABLE passed');
+
+        // Test INSERT
+        console.log('Testing INSERT...');
+        parser.execute("INSERT INTO users VALUES ('Alice', 30)");
+        parser.execute("INSERT INTO users VALUES ('Bob', 25)");
+        const users = storage.loadRows('users');
+        if (users.length !== 2) throw new Error('Rows not inserted correctly');
+        if (users[0].id !== 1 || users[1].id !== 2) throw new Error('Auto-increment ID mismatch');
+        console.log('✓ INSERT passed');
+
+        // Test SELECT (Simple)
+        console.log('Testing SELECT...');
+        const result = parser.execute('SELECT * FROM users WHERE name=Alice');
+        if (result.length !== 1 || result[0].name !== 'Alice') throw new Error('SELECT failed');
+        console.log('✓ SELECT passed');
+
+        // Test UPDATE
+        console.log('Testing UPDATE...');
+        parser.execute("UPDATE users SET age=31 WHERE name=Alice");
+        const alice = storage.select('users', (r) => r.name === 'Alice')[0];
+        if (alice.age !== '31') throw new Error('UPDATE failed'); // Parser converts to string currently
+        console.log('✓ UPDATE passed');
+
+        // Test ALTER TABLE
+        console.log('Testing ALTER TABLE...');
+        parser.execute("ALTER TABLE users ADD email string");
+        if (!storage.metadata.tables.users.schema.email) throw new Error('ALTER TABLE failed');
+        const updatedUsers = storage.loadRows('users');
+        if (updatedUsers[0].email !== null) throw new Error('ALTER TABLE did not update existing rows');
+        console.log('✓ ALTER TABLE passed');
+
+        // Test DELETE
+        console.log('Testing DELETE...');
+        parser.execute("DELETE FROM users WHERE name=Bob");
+        if (storage.loadRows('users').length !== 1) throw new Error('DELETE failed');
+        console.log('✓ DELETE passed');
+
+        // Test DROP TABLE
+        console.log('Testing DROP TABLE...');
+        parser.execute("DROP TABLE users");
+        if (storage.metadata.tables.users) throw new Error('DROP TABLE failed');
+        console.log('✓ DROP TABLE passed');
+
+
+        // --- Primary Key Tests (from test_pk.js) ---
+        console.log('\n--- Primary Key Tests ---');
+
+        console.log("Test: Auto-increment primary key when none specified");
+        parser.execute("CREATE TABLE test1 (name TEXT)");
+        parser.execute("INSERT INTO test1 VALUES ('Alice')");
+        parser.execute("INSERT INTO test1 VALUES ('Bob')");
+        const rows1 = parser.execute("SELECT * FROM test1");
+        if (rows1[0].id === 1 && rows1[1].id === 2) {
+            console.log("✓ Auto-increment id added");
+        } else {
+            throw new Error("Auto-increment id missing or incorrect");
+        }
+
+        console.log("Test: Single column primary key");
+        parser.execute("CREATE TABLE test2 (email TEXT PRIMARY KEY, name TEXT)");
+        parser.execute("INSERT INTO test2 VALUES ('alice@example.com', 'Alice')");
+        try {
+            parser.execute("INSERT INTO test2 VALUES ('alice@example.com', 'Alice Duplicate')");
+            throw new Error("Duplicate primary key allowed");
+        } catch (e) {
+            console.log("✓ Duplicate primary key rejected: " + e.message);
+        }
+
+        console.log("Test: Composite primary key");
+        parser.execute("CREATE TABLE test3 (order_id INT, item_id INT, PRIMARY KEY (order_id, item_id))");
+        parser.execute("INSERT INTO test3 VALUES (1, 101)");
+        parser.execute("INSERT INTO test3 VALUES (1, 102)");
+        parser.execute("INSERT INTO test3 VALUES (2, 101)");
+        try {
+            parser.execute("INSERT INTO test3 VALUES (1, 101)");
+            throw new Error("Duplicate composite primary key allowed");
+        } catch (e) {
+            console.log("✓ Duplicate composite primary key rejected: " + e.message);
+        }
+
+        console.log("Test: Mixed case and inline PRIMARY KEY");
+        parser.execute("CREATE TABLE test4 (id INT primary key, code TEXT)");
+        parser.execute("INSERT INTO test4 VALUES (10, 'A1')");
+        try {
+            parser.execute("INSERT INTO test4 VALUES (10, 'A2')");
+            throw new Error("Duplicate primary key allowed (mixed case)");
+        } catch (e) {
+            console.log("✓ Duplicate primary key rejected: " + e.message);
+        }
+
+
+        // --- SELECT Advanced Tests (from test_select.js) ---
+        console.log('\n--- SELECT Advanced Tests ---');
+        
+        parser.execute('CREATE TABLE sel_users (name string, age int, country string)');
+        parser.execute("INSERT INTO sel_users VALUES ('Alice', 30, 'USA')");
+        parser.execute("INSERT INTO sel_users VALUES ('Bob', 25, 'UK')");
+        parser.execute("INSERT INTO sel_users VALUES ('Charlie', 35, 'USA')");
+        parser.execute("INSERT INTO sel_users VALUES ('David', 40, 'Canada')");
+
+        // 1. asterisk (*)
+        console.log('Testing SELECT * ...');
+        const all = parser.execute('SELECT * FROM sel_users');
+        if (all.length !== 4) throw new Error(`Expected 4 rows, got ${all.length}`);
+        if (!all[0].id || !all[0].name || !all[0].age || !all[0].country) throw new Error('Missing columns in SELECT *');
+        console.log('✓ SELECT * passed');
+
+        // 2. select some columns
+        console.log('Testing SELECT name, age ...');
+        const some = parser.execute('SELECT name, age FROM sel_users');
+        if (some.length !== 4) throw new Error(`Expected 4 rows, got ${some.length}`);
+        if (some[0].name === undefined || some[0].age === undefined) throw new Error('Selected columns missing');
+        if (some[0].id !== undefined || some[0].country !== undefined) throw new Error('Unselected columns present');
+        console.log('✓ SELECT columns passed');
+
+        // 3. WHERE clause
+        console.log('Testing SELECT * WHERE country=USA ...');
+        const usa = parser.execute('SELECT * FROM sel_users WHERE country=USA');
+        if (usa.length !== 2) throw new Error(`Expected 2 rows for USA, got ${usa.length}`);
+        
+        console.log('Testing SELECT name WHERE id=1 ...');
+        const id1 = parser.execute('SELECT name FROM sel_users WHERE id=1');
+        if (id1.length !== 1 || id1[0].name !== 'Alice') throw new Error('SELECT WHERE id=1 failed');
+        console.log('✓ SELECT WHERE passed');
+
+        // 5. LIMIT
+        console.log('Testing SELECT * LIMIT 2 ...');
+        const limited = parser.execute('SELECT * FROM sel_users LIMIT 2');
+        if (limited.length !== 2) throw new Error(`Expected 2 rows, got ${limited.length}`);
+        
+        console.log('Testing SELECT name FROM sel_users WHERE country=USA LIMIT 1 ...');
+        const limitedUsa = parser.execute('SELECT name FROM sel_users WHERE country=USA LIMIT 1');
+        if (limitedUsa.length !== 1) throw new Error(`Expected 1 row, got ${limitedUsa.length}`);
+        if (limitedUsa[0].name !== 'Alice') throw new Error(`Expected Alice, got ${limitedUsa[0].name}`);
+        console.log('✓ SELECT LIMIT passed');
+
+        console.log('\nAll tests passed successfully!');
+    } catch (err) {
+        console.error('\nTest failed!');
+        console.error(err);
+        process.exit(1);
+    } finally {
+        cleanup();
+    }
+}
+
+runTests();

package/test_es6_orm.js

@@ -0,0 +1,44 @@
+import { TogeORM } from './index.js';
+import path from 'path';
+import fs from 'fs';
+
+async function testORM() {
+    console.log('Testing TogeORM with ES6 Import...');
+    const dataDir = './test_orm_data';
+    
+    if (fs.existsSync(dataDir)) {
+        fs.rmSync(dataDir, { recursive: true, force: true });
+    }
+
+    try {
+        const orm = new TogeORM(dataDir);
+        
+        const User = orm.define('users', {
+            username: { type: 'string', primaryKey: true },
+            email: { type: 'string' }
+        });
+
+        console.log('Creating user...');
+        const user = User.create({ username: 'revtm', email: 'revtm@example.com' });
+        console.log('User created:', user);
+
+        console.log('Finding user...');
+        const found = User.findOne(u => u.username === 'revtm');
+        if (found && found.username === 'revtm') {
+            console.log('✓ Found user');
+        } else {
+            throw new Error('User not found');
+        }
+
+        console.log('✓ TogeORM ES6 test passed');
+    } catch (err) {
+        console.error('TogeORM ES6 test failed:', err);
+        process.exit(1);
+    } finally {
+        if (fs.existsSync(dataDir)) {
+            fs.rmSync(dataDir, { recursive: true, force: true });
+        }
+    }
+}
+
+testORM();