maazdb-js 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+
+# MaazDB-JS 🟩
+
+**The Official Node.js Driver for MaazDB**
+
+![Node](https://img.shields.io/badge/node-%3E%3D14.0-green)
+![License](https://img.shields.io/badge/license-MIT-blue)
+
+`maazdb-js` is a high-performance, asynchronous Node.js client for MaazDB. It uses native Promises and Buffers to handle the binary protocol securely over TLS.
+
+## 📦 Installation
+
+```bash
+npm install maazdb-js
+```
+
+## 🛠 Usage
+
+```javascript
+const MaazDB = require('maazdb-js');
+
+async function run() {
+    const db = new MaazDB();
+
+    try {
+        // Connect securely
+        await db.connect("127.0.0.1", 8888, "admin", "password");
+        
+        // Run SQL
+        await db.query("CREATE DATABASE web_app;");
+        await db.query("USE web_app;");
+        
+        const users = await db.query("SELECT * FROM users;");
+        console.log(users);
+
+    } catch (e) {
+        console.error(e);
+    } finally {
+        db.close();
+    }
+}
+
+run();
+```
+
+## 🧪 Testing
+
+1. Start your Rust Server.
+2. Run the example:
+
+```bash
+node examples/basic.js
+```
+---
+
+
+
+Created for the MaazDB Ecosystem.

package/examples/basic.js

@@ -0,0 +1,40 @@
+// FILE PATH: examples/basic.js   
+//npm link maazdb-js
+const MaazDB = require('maazdb-js');
+
+async function main() {
+    console.log("--- MaazDB Node.js Client ---");
+
+    const db = new MaazDB();
+
+    try {
+        // 1. Connect
+        console.log("Connecting...");
+        await db.connect("127.0.0.1", 8888, "admin", "admin");
+        console.log("✓ Connected via TLS 1.3");
+
+        // 2. Run Queries
+        const queries = [
+            "CREATE DATABASE node_test;",
+            "USE node_test;",
+            "CREATE TABLE js_users (id SERIAL PRIMARY KEY, name TEXT);",
+            "INSERT INTO js_users (name) VALUES ('Maaz');",
+            "INSERT INTO js_users (name) VALUES ('Waheed');",
+            "SELECT * FROM js_users;"
+        ];
+
+        for (const sql of queries) {
+            console.log(`\nExecuting: ${sql}`);
+            const result = await db.query(sql);
+            console.log(`Server: ${result.trim()}`);
+        }
+
+    } catch (err) {
+        console.error("❌ Error:", err.message);
+    } finally {
+        db.close();
+        console.log("\nConnection closed.");
+    }
+}
+
+main();

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "maazdb-js",
+  "version": "1.0.0",
+  "description": "Official Node.js Driver for MaazDB",
+  "main": "src/client.js",
+  "scripts": {
+    "test": "node examples/basic.js"
+  },
+  "keywords": [
+    "database",
+    "driver",
+    "maazdb",
+    "sql",
+    "tls"
+  ],
+  "author": "Maaz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/42Wor/maazdb-js.git"
+  }
+}
+

package/src/client.js

@@ -0,0 +1,147 @@
+const tls = require('tls');
+const { 
+    PACKET_HANDSHAKE, PACKET_AUTH_OK, PACKET_AUTH_ERR, 
+    PACKET_QUERY, PACKET_MSG, PACKET_DATA, DRIVER_SIG 
+} = require('./protocol');
+const { AuthError, ProtocolError, MaazDBError } = require('./errors');
+
+class MaazDB {
+    constructor() {
+        this.socket = null;
+        this.connected = false;
+        this.buffer = Buffer.alloc(0); // Store incoming data chunks
+        this.currentResolve = null;    // Promise resolver for the current query
+        this.currentReject = null;     // Promise rejector for the current query
+    }
+
+    /**
+     * Connects to the MaazDB server securely via TLS.
+     */
+    connect(host, port, user, password) {
+        return new Promise((resolve, reject) => {
+            const options = {
+                host: host,
+                port: port,
+                rejectUnauthorized: false, // Allow self-signed certs (Dev Mode)
+            };
+
+            this.socket = tls.connect(options, () => {
+                // 1. Send Handshake immediately upon connection
+                const payload = `${user}\0${password}\0${DRIVER_SIG}`;
+                this._sendPacket(PACKET_HANDSHAKE, payload);
+            });
+
+            this.socket.on('data', (data) => {
+                this._handleData(data);
+            });
+
+            this.socket.on('error', (err) => {
+                this.connected = false;
+                if (this.currentReject) this.currentReject(err);
+                else reject(err);
+            });
+
+            this.socket.on('close', () => {
+                this.connected = false;
+            });
+
+            // We hijack the first request to handle Auth
+            this.currentResolve = () => {
+                this.connected = true;
+                resolve(this);
+            };
+            this.currentReject = (err) => {
+                this.close();
+                reject(err);
+            };
+        });
+    }
+
+    /**
+     * Sends a SQL query and returns the result string.
+     */
+    query(sql) {
+        return new Promise((resolve, reject) => {
+            if (!this.connected) {
+                return reject(new MaazDBError("Not connected to server"));
+            }
+
+            // Set the callbacks for when data arrives
+            this.currentResolve = resolve;
+            this.currentReject = reject;
+
+            this._sendPacket(PACKET_QUERY, sql);
+        });
+    }
+
+    close() {
+        if (this.socket) {
+            this.socket.end();
+            this.socket.destroy();
+        }
+        this.connected = false;
+    }
+
+    // --- Internal Helpers ---
+
+    _sendPacket(type, payloadStr) {
+        const payload = Buffer.from(payloadStr, 'utf8');
+        const length = payload.length;
+
+        // Header: [Type (1B)] [Length (4B Big Endian)]
+        const header = Buffer.alloc(5);
+        header.writeUInt8(type, 0);
+        header.writeUInt32BE(length, 1);
+
+        const packet = Buffer.concat([header, payload]);
+        this.socket.write(packet);
+    }
+
+    _handleData(chunk) {
+        // Append new chunk to our buffer
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+
+        // Try to parse packets from the buffer
+        while (true) {
+            if (this.buffer.length < 5) return; // Wait for more data
+
+            // Read Header
+            const type = this.buffer.readUInt8(0);
+            const length = this.buffer.readUInt32BE(1);
+
+            // Check if we have the full payload
+            if (this.buffer.length < 5 + length) return; // Wait for more data
+
+            // Extract Payload
+            const payloadBuffer = this.buffer.subarray(5, 5 + length);
+            const payloadStr = payloadBuffer.toString('utf8');
+
+            // Remove this packet from the buffer
+            this.buffer = this.buffer.subarray(5 + length);
+
+            // Handle the packet
+            this._processPacket(type, payloadStr);
+        }
+    }
+
+    _processPacket(type, msg) {
+        if (type === PACKET_AUTH_OK) {
+            if (this.currentResolve) this.currentResolve("Authenticated");
+        } 
+        else if (type === PACKET_AUTH_ERR) {
+            if (this.currentReject) this.currentReject(new AuthError(msg));
+        } 
+        else if (type === PACKET_MSG || type === PACKET_DATA) {
+            if (this.currentResolve) this.currentResolve(msg);
+        } 
+        else {
+            if (this.currentReject) this.currentReject(new ProtocolError(`Unknown Packet: ${type}`));
+        }
+
+        // Reset callbacks
+        this.currentResolve = null;
+        this.currentReject = null;
+    }
+}
+
+module.exports = MaazDB;

package/src/errors.js

@@ -0,0 +1,22 @@
+class MaazDBError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MaazDBError";
+    }
+}
+
+class AuthError extends MaazDBError {
+    constructor(message) {
+        super(message);
+        this.name = "AuthError";
+    }
+}
+
+class ProtocolError extends MaazDBError {
+    constructor(message) {
+        super(message);
+        this.name = "ProtocolError";
+    }
+}
+
+module.exports = { MaazDBError, AuthError, ProtocolError };

package/src/protocol.js

@@ -0,0 +1,20 @@
+// Protocol Constants
+const PACKET_HANDSHAKE = 0x10;
+const PACKET_AUTH_OK   = 0x11;
+const PACKET_AUTH_ERR  = 0x12;
+const PACKET_QUERY     = 0x20;
+const PACKET_MSG       = 0x02;
+const PACKET_DATA      = 0x03;
+
+// Driver Signature
+const DRIVER_SIG = "maazdb-nodejs-driver-v1";
+
+module.exports = {
+    PACKET_HANDSHAKE,
+    PACKET_AUTH_OK,
+    PACKET_AUTH_ERR,
+    PACKET_QUERY,
+    PACKET_MSG,
+    PACKET_DATA,
+    DRIVER_SIG
+};