@wowoengine/sawitdb 2.4.0 → 2.6.0

package/package.json

@@ -3,16 +3,19 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "2.4.0",
-  "description": "A networked document database with Indonesian Agricultural Query Language (AQL) - Network Edition",
+  "version": "2.6.0",
+  "description": "A high-performance hybrid paged database with Agricultural Query Language (AQL) and Generic SQL support. Features single-file storage (.sawit), object caching, worker-thread parallelism, and crash recovery.",
   "main": "src/WowoEngine.js",
   "scripts": {
     "start": "node bin/sawit-server.js",
+    "start:cluster": "set SAWIT_CLUSTER_MODE=true && node bin/sawit-server.js",
     "server": "node bin/sawit-server.js",
-    "test": "node tests/test_server_injection.js",
+    "test": "node cli/test.js",
     "example": "node examples/example_client.js",
     "cli": "node cli/remote.js sawitdb://localhost:7878/default",
-    "dev": "SAWIT_LOG_LEVEL=debug node bin/sawit-server.js"
+    "dev": "set SAWIT_LOG_LEVEL=debug && node bin/sawit-server.js",
+    "bench": "node cli/benchmark.js --spawn --workers=1 --clients=1",
+    "bench:cluster": "node cli/benchmark.js --spawn --cluster --workers=4 --clients=10"
   },
   "keywords": [
     "database",
@@ -44,14 +47,14 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/WowoEngine/SawitDB.git"
+    "url": "git+https://github.com/WowoEngine/SawitDB.git"
   },
   "engines": {
     "node": ">=12.0.0"
   },
   "bin": {
-    "sawitdb-server": "./bin/sawit-server.js",
-    "sawitdb-cli": "./cli/remote.js"
+    "sawitdb-server": "bin/sawit-server.js",
+    "sawitdb-cli": "cli/remote.js"
   },
   "files": [
     "src/",

package/src/SawitClient.js

@@ -16,10 +16,10 @@ class SawitClient {
         this.pendingRequests = [];
         this.requestId = 0;
 
-        this._parseConnectionString(connectionString);
+        this.#parseConnectionString(connectionString);
     }
 
-    _parseConnectionString(connStr) {
+    #parseConnectionString(connStr) {
         // Parse sawitdb://[user:pass@]host:port/database
         const url = connStr.replace('sawitdb://', 'http://'); // Trick to use URL parser
         const parsed = new URL(url);
@@ -33,13 +33,16 @@ class SawitClient {
 
     async connect() {
         return new Promise((resolve, reject) => {
-            this.socket = net.createConnection({ host: this.host, port: this.port }, () => {
-                console.log(`[Client] Connected to ${this.host}:${this.port}`);
-                this.connected = true;
-            });
+            this.socket = net.createConnection(
+                { host: this.host, port: this.port },
+                () => {
+                    console.log(`[Client] Connected to ${this.host}:${this.port}`);
+                    this.connected = true;
+                }
+            );
 
             this.socket.on('data', (data) => {
-                this._handleData(data);
+                this.#handleData(data);
             });
 
             this.socket.on('end', () => {
@@ -79,40 +82,46 @@ class SawitClient {
 
     async _authenticate() {
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'auth',
-                payload: {
-                    username: this.username,
-                    password: this.password
-                }
-            }, (response) => {
-                if (response.type === 'auth_success') {
-                    this.authenticated = true;
-                    console.log('[Client] Authenticated successfully');
-                    resolve();
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
+            this.#sendRequest(
+                {
+                    type: 'auth',
+                    payload: {
+                        username: this.username,
+                        password: this.password
+                    }
+                },
+                (response) => {
+                    if (response.type === 'auth_success') {
+                        this.authenticated = true;
+                        console.log('[Client] Authenticated successfully');
+                        resolve();
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    }
                 }
-            });
+            );
         });
     }
 
     async use(database) {
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'use',
-                payload: { database }
-            }, (response) => {
-                if (response.type === 'use_success') {
-                    this.currentDatabase = database;
-                    console.log(`[Client] Using database '${database}'`);
-                    resolve(response);
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
-                } else {
-                    resolve(response);
+            this.#sendRequest(
+                {
+                    type: 'use',
+                    payload: { database }
+                },
+                (response) => {
+                    if (response.type === 'use_success') {
+                        this.currentDatabase = database;
+                        console.log(`[Client] Using database '${database}'`);
+                        resolve(response);
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    } else {
+                        resolve(response);
+                    }
                 }
-            });
+            );
         });
     }
 
@@ -122,96 +131,111 @@ class SawitClient {
         }
 
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'query',
-                payload: {
-                    query: queryString,
-                    params: params
-                }
-            }, (response) => {
-                if (response.type === 'query_result') {
-                    resolve(response.result);
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
-                } else {
-                    resolve(response);
+            this.#sendRequest(
+                {
+                    type: 'query',
+                    payload: {
+                        query: queryString,
+                        params: params
+                    }
+                },
+                (response) => {
+                    if (response.type === 'query_result') {
+                        resolve(response.result);
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    } else {
+                        resolve(response);
+                    }
                 }
-            });
+            );
         });
     }
 
     async listDatabases() {
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'list_databases',
-                payload: {}
-            }, (response) => {
-                if (response.type === 'database_list') {
-                    resolve(response.databases);
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
-                } else {
-                    resolve(response);
+            this.#sendRequest(
+                {
+                    type: 'list_databases',
+                    payload: {}
+                },
+                (response) => {
+                    if (response.type === 'database_list') {
+                        resolve(response.databases);
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    } else {
+                        resolve(response);
+                    }
                 }
-            });
+            );
         });
     }
 
     async dropDatabase(database) {
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'drop_database',
-                payload: { database }
-            }, (response) => {
-                if (response.type === 'drop_success') {
-                    if (this.currentDatabase === database) {
-                        this.currentDatabase = null;
+            this.#sendRequest(
+                {
+                    type: 'drop_database',
+                    payload: { database }
+                },
+                (response) => {
+                    if (response.type === 'drop_success') {
+                        if (this.currentDatabase === database) {
+                            this.currentDatabase = null;
+                        }
+                        resolve(response.message);
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    } else {
+                        resolve(response);
                     }
-                    resolve(response.message);
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
-                } else {
-                    resolve(response);
                 }
-            });
+            );
         });
     }
 
     async ping() {
         return new Promise((resolve, reject) => {
             const start = Date.now();
-            this._sendRequest({
-                type: 'ping',
-                payload: {}
-            }, (response) => {
-                if (response.type === 'pong') {
-                    const latency = Date.now() - start;
-                    resolve({ latency, serverTime: response.timestamp });
-                } else {
-                    resolve(response);
+            this.#sendRequest(
+                {
+                    type: 'ping',
+                    payload: {}
+                },
+                (response) => {
+                    if (response.type === 'pong') {
+                        const latency = Date.now() - start;
+                        resolve({ latency, serverTime: response.timestamp });
+                    } else {
+                        resolve(response);
+                    }
                 }
-            });
+            );
         });
     }
 
     async stats() {
         return new Promise((resolve, reject) => {
-            this._sendRequest({
-                type: 'stats',
-                payload: {}
-            }, (response) => {
-                if (response.type === 'stats') {
-                    resolve(response.stats);
-                } else if (response.type === 'error') {
-                    reject(new Error(response.error));
-                } else {
-                    resolve(response);
+            this.#sendRequest(
+                {
+                    type: 'stats',
+                    payload: {}
+                },
+                (response) => {
+                    if (response.type === 'stats') {
+                        resolve(response.stats);
+                    } else if (response.type === 'error') {
+                        reject(new Error(response.error));
+                    } else {
+                        resolve(response);
+                    }
                 }
-            });
+            );
         });
     }
 
-    _sendRequest(request, callback) {
+    #sendRequest(request, callback) {
         const id = ++this.requestId;
         this.pendingRequests.push({ id, handler: callback });
 
@@ -219,7 +243,7 @@ class SawitClient {
             this.socket.write(JSON.stringify(request) + '\n');
         } catch (err) {
             console.error('[Client] Failed to send request:', err.message);
-            const idx = this.pendingRequests.findIndex(r => r.id === id);
+            const idx = this.pendingRequests.findIndex((r) => r.id === id);
             if (idx !== -1) {
                 this.pendingRequests.splice(idx, 1);
             }
@@ -227,7 +251,7 @@ class SawitClient {
         }
     }
 
-    _handleData(data) {
+    #handleData(data) {
         this.buffer += data.toString();
 
         let newlineIndex;
@@ -237,14 +261,14 @@ class SawitClient {
 
             try {
                 const response = JSON.parse(message);
-                this._handleResponse(response);
+                this.#handleResponse(response);
             } catch (err) {
                 console.error('[Client] Failed to parse response:', err.message);
             }
         }
     }
 
-    _handleResponse(response) {
+    #handleResponse(response) {
         if (this.pendingRequests.length > 0) {
             const request = this.pendingRequests.shift();
             if (request.handler) {