@onurege3467/zerohelper 9.1.0 → 9.2.0

package/dist/bin/zero.js

@@ -101,7 +101,7 @@ program.command('zpack:vacuum')
     try {
         const db = index_1.database.createDatabase({
             adapter: 'zpack',
-            config: { filePath: file }
+            config: { path: file }
         });
         await db.vacuum();
         await db.close();

package/dist/database/json.js

@@ -16,10 +16,10 @@ class JsonDatabase extends IDatabase_1.IDatabase {
         this.isWriting = false;
         this.writeQueue = [];
         this.saveDebounceTimeout = null;
-        if (!config || !config.filePath)
-            throw new Error('Yapılandırma içinde "filePath" belirtilmelidir.');
-        this.filePath = config.filePath;
-        this.saveInterval = 500;
+        if (!config || !config.path)
+            throw new Error('JsonDB: "path" gereklidir.');
+        this.filePath = config.path;
+        this.saveInterval = config.saveInterval || 500;
         process.on('exit', () => this.flushSync());
         this.initPromise = this._load();
     }
@@ -89,7 +89,7 @@ class JsonDatabase extends IDatabase_1.IDatabase {
             this.isDirty = false;
         }
         catch (error) {
-            console.error("Veritabanı dosyasına yazılırken hata:", error);
+            console.error("JsonDB save error:", error);
         }
     }
     flushSync() {
@@ -128,7 +128,7 @@ class JsonDatabase extends IDatabase_1.IDatabase {
             return this._queueRequest(() => {
                 let affected = 0;
                 this.db[table].forEach(row => {
-                    if (Object.keys(where).every(k => row[k] === where[k])) {
+                    if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
                         Object.assign(row, data);
                         affected++;
                     }
@@ -144,7 +144,7 @@ class JsonDatabase extends IDatabase_1.IDatabase {
             await this.ensureTable(table);
             return this._queueRequest(() => {
                 const initial = this.db[table].length;
-                this.db[table] = this.db[table].filter(row => !Object.keys(where).every(k => row[k] === where[k]));
+                this.db[table] = this.db[table].filter(row => !Object.keys(where).every(k => String(row[k]) === String(where[k])));
                 const affected = initial - this.db[table].length;
                 this.runHooks('afterDelete', table, { affected });
                 return affected;
@@ -155,7 +155,7 @@ class JsonDatabase extends IDatabase_1.IDatabase {
         return this._execute('select', table, async () => {
             await this.initPromise;
             const results = where && Object.keys(where).length > 0
-                ? (this.db[table] || []).filter(row => Object.keys(where).every(k => row[k] === where[k]))
+                ? (this.db[table] || []).filter(row => Object.keys(where).every(k => String(row[k]) === String(where[k])))
                 : (this.db[table] || []);
             return JSON.parse(JSON.stringify(results));
         });
@@ -186,7 +186,7 @@ class JsonDatabase extends IDatabase_1.IDatabase {
             return this._queueRequest(() => {
                 let affected = 0;
                 this.db[table].forEach(row => {
-                    if (Object.keys(where).every(k => row[k] === where[k])) {
+                    if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
                         for (const [f, v] of Object.entries(incs))
                             row[f] = (Number(row[f]) || 0) + v;
                         affected++;

package/dist/database/mongodb.d.ts

@@ -1,4 +1,5 @@
 import { IDatabase } from './IDatabase';
+import { MongoDBConfig } from './types';
 export declare class MongoDBDatabase extends IDatabase {
     private config;
     private client;
@@ -6,7 +7,7 @@ export declare class MongoDBDatabase extends IDatabase {
     private _queue;
     private _connected;
     private _connectionPromise;
-    constructor(config: any);
+    constructor(config: MongoDBConfig);
     private _execute;
     private _processQueue;
     insert(collection: string, data: any): Promise<any>;

package/dist/database/mongodb.js

@@ -10,11 +10,11 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
         this._queue = [];
         this._connected = false;
         this.config = config;
-        this.client = new mongodb_1.MongoClient(config.url || config.uri);
+        this.client = new mongodb_1.MongoClient(config.url || `mongodb://${config.host || 'localhost'}:${config.port || 27017}`);
         this._connectionPromise = new Promise(async (resolve, reject) => {
             try {
                 await this.client.connect();
-                this.db = this.client.db(config.database || config.dbName);
+                this.db = this.client.db(config.database || 'test');
                 this._connected = true;
                 resolve(this.db);
                 this._processQueue();
@@ -65,7 +65,6 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
         return this._execute('update', collection, async () => {
             const db = await this._connectionPromise;
             const res = await db.collection(collection).updateMany(where, { $set: data });
-            await this.runHooks('afterUpdate', collection, { affected: res.modifiedCount });
             return Number(res.modifiedCount);
         });
     }
@@ -74,7 +73,6 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
         return this._execute('delete', collection, async () => {
             const db = await this._connectionPromise;
             const res = await db.collection(collection).deleteMany(where);
-            await this.runHooks('afterDelete', collection, { affected: res.deletedCount });
             return res.deletedCount;
         });
     }

package/dist/database/mysql.d.ts

@@ -7,10 +7,11 @@ export declare class MySQLDatabase extends IDatabase {
     private _connected;
     private _connectionPromise;
     constructor(config: MySQLConfig);
-    private _queueRequest;
+    private _execute;
     private _processQueue;
     query(sql: string, params?: any[]): Promise<any>;
-    ensureTable(table: string, data?: Record<string, any>): Promise<void>;
+    private _ensureMissingColumns;
+    ensureTable(table: string, data?: any): Promise<void>;
     insert(table: string, data: Record<string, any>): Promise<number>;
     update(table: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
     delete(table: string, where: Record<string, any>): Promise<number>;
@@ -18,12 +19,11 @@ export declare class MySQLDatabase extends IDatabase {
     selectOne<T = any>(table: string, where?: Record<string, any> | null): Promise<T | null>;
     set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
     bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
-    increment(table: string, increments: Record<string, number>, where: Record<string, any>): Promise<number>;
-    decrement(table: string, decrements: Record<string, number>, where: Record<string, any>): Promise<number>;
+    increment(table: string, incs: Record<string, number>, where: Record<string, any>): Promise<number>;
+    decrement(table: string, decs: Record<string, number>, where: Record<string, any>): Promise<number>;
     close(): Promise<void>;
     private _getColumnType;
     private _serializeValue;
-    private _deserializeValue;
     private _buildWhereClause;
 }
 export default MySQLDatabase;

package/dist/database/mysql.js

@@ -16,32 +16,24 @@ class MySQLDatabase extends IDatabase_1.IDatabase {
         this._connectionPromise = new Promise(async (resolve, reject) => {
             try {
                 const connection = await promise_1.default.createConnection({
-                    host: config.host,
+                    host: config.host || 'localhost',
                     port: config.port || 3306,
-                    user: config.user,
+                    user: config.username,
                     password: config.password,
-                    typeCast: (field, next) => {
-                        if (field.type === 'TINY' && field.length === 1)
-                            return (field.string() === '1');
-                        if (['INT', 'DECIMAL', 'NEWDECIMAL', 'FLOAT', 'DOUBLE'].includes(field.type))
-                            return Number(field.string());
-                        return next();
-                    }
                 });
-                await connection.query(`CREATE DATABASE IF NOT EXISTS 
+                await connection.query(`CREATE DATABASE IF NOT EXISTS
 ${config.database}
 `);
                 await connection.end();
                 this.pool = promise_1.default.createPool({
-                    host: config.host, port: config.port || 3306, user: config.user, password: config.password, database: config.database,
-                    waitForConnections: true, connectionLimit: config.connectionLimit || 10, queueLimit: 0,
-                    typeCast: (field, next) => {
-                        if (field.type === 'TINY' && field.length === 1)
-                            return (field.string() === '1');
-                        if (['INT', 'DECIMAL', 'NEWDECIMAL', 'FLOAT', 'DOUBLE'].includes(field.type))
-                            return Number(field.string());
-                        return next();
-                    }
+                    host: config.host || 'localhost',
+                    port: config.port || 3306,
+                    user: config.username,
+                    password: config.password,
+                    database: config.database,
+                    waitForConnections: true,
+                    connectionLimit: config.poolSize || 10,
+                    queueLimit: 0,
                 });
                 this._connected = true;
                 resolve(this.pool);
@@ -52,18 +44,16 @@ ${config.database}
             }
         });
     }
-    async _queueRequest(operation, opName, table) {
+    async _execute(op, table, fn) {
         const start = Date.now();
         const execute = async () => {
-            const res = await operation();
-            this.recordMetric(opName, table, Date.now() - start);
+            const res = await fn();
+            this.recordMetric(op, table, Date.now() - start);
             return res;
         };
         if (this._connected)
             return execute();
-        return new Promise((resolve, reject) => {
-            this._queue.push({ operation: execute, resolve, reject });
-        });
+        return new Promise((resolve, reject) => this._queue.push({ operation: execute, resolve, reject }));
     }
     async _processQueue() {
         if (!this._connected)
@@ -85,122 +75,155 @@ ${config.database}
         const [rows] = await pool.execute(sql, params);
         return rows;
     }
+    async _ensureMissingColumns(table, data) {
+        const existingColumns = await this.query(`DESCRIBE
+${table}
+`).catch(() => []);
+        const columnNames = existingColumns.map(col => col.Field);
+        for (const key of Object.keys(data)) {
+            if (key !== '_id' && !columnNames.includes(key)) {
+                await this.query(`ALTER TABLE
+${table}
+ ADD COLUMN
+${key}
+ TEXT`);
+            }
+        }
+    }
     async ensureTable(table, data = {}) {
         const escapedTable = promise_1.default.escape(table);
         const tables = await this.query(`SHOW TABLES LIKE ${escapedTable}`);
         if (tables.length === 0) {
-            const columnDefinitions = Object.keys(data).map(col => `
-${col}
- ${this._getColumnType(data[col])}`);
-            const columnsPart = columnDefinitions.length > 0 ? ', ' + columnDefinitions.join(", ") : '';
-            await this.query(`CREATE TABLE 
+            const defs = Object.keys(data).map(k => `
+${k}
+ TEXT`);
+            const columnsPart = defs.length > 0 ? ', ' + defs.join(", ") : '';
+            await this.query(`CREATE TABLE
 ${table}
  (_id INT PRIMARY KEY AUTO_INCREMENT ${columnsPart}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`);
         }
+        else {
+            await this._ensureMissingColumns(table, data);
+        }
     }
     async insert(table, data) {
         await this.runHooks('beforeInsert', table, data);
-        return this._queueRequest(async () => {
+        return this._execute('insert', table, async () => {
             await this.ensureTable(table, data);
             const keys = Object.keys(data);
-            const placeholders = keys.map(() => "?").join(",");
-            const values = Object.values(data).map(v => this._serializeValue(v));
-            const sql = `INSERT INTO 
+            const sql = `INSERT INTO
 ${table}
  (${keys.map(k => `
 ${k}
-`).join(",")}) VALUES (${placeholders})`;
-            const result = await this.query(sql, values);
+`).join(",")}) VALUES (${keys.map(() => '?').join(",")})`;
+            const result = await this.query(sql, Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
             const finalData = { _id: result.insertId, ...data };
             await this.runHooks('afterInsert', table, finalData);
             return result.insertId;
-        }, 'insert', table);
+        });
     }
     async update(table, data, where) {
         await this.runHooks('beforeUpdate', table, { data, where });
-        return this._queueRequest(async () => {
-            const setString = Object.keys(data).map(k => `
+        return this._execute('update', table, async () => {
+            await this.ensureTable(table, { ...data, ...where });
+            const set = Object.keys(data).map(k => `
 ${k}
  = ?`).join(", ");
-            const { whereClause, values: whereValues } = this._buildWhereClause(where);
-            const sql = `UPDATE 
+            const wKeys = Object.keys(where);
+            const sql = `UPDATE
 ${table}
- SET ${setString} ${whereClause}`;
-            const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...whereValues]);
-            await this.runHooks('afterUpdate', table, { affected: result.affectedRows });
+ SET ${set} WHERE ${wKeys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, [...Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v), ...Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v)]);
             return result.affectedRows;
-        }, 'update', table);
+        });
     }
     async delete(table, where) {
         await this.runHooks('beforeDelete', table, where);
-        return this._queueRequest(async () => {
-            const { whereClause, values } = this._buildWhereClause(where);
-            const sql = `DELETE FROM 
+        return this._execute('delete', table, async () => {
+            await this.ensureTable(table, where);
+            const keys = Object.keys(where);
+            const sql = `DELETE FROM
 ${table}
- ${whereClause}`;
-            const result = await this.query(sql, values);
-            await this.runHooks('afterDelete', table, { affected: result.affectedRows });
+ WHERE ${keys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
             return result.affectedRows;
-        }, 'delete', table);
+        });
     }
     async select(table, where = null) {
-        return this._queueRequest(async () => {
-            const { whereClause, values } = this._buildWhereClause(where || {});
-            const rows = await this.query(`SELECT * FROM 
+        return this._execute('select', table, async () => {
+            await this.ensureTable(table, where || {});
+            const keys = where ? Object.keys(where) : [];
+            const sql = `SELECT * FROM
 ${table}
- ${whereClause}`, values);
+ ` + (keys.length ? ' WHERE ' + keys.map(k => `
+${k}
+ = ?`).join(" AND ") : '');
+            const rows = await this.query(sql, keys.map(k => typeof where[k] === 'object' ? JSON.stringify(where[k]) : where[k]));
             return rows.map((row) => {
-                const newRow = {};
-                for (const key in row)
-                    newRow[key] = this._deserializeValue(row[key]);
-                return newRow;
+                const nr = {};
+                for (const k in row) {
+                    try {
+                        nr[k] = JSON.parse(row[k]);
+                    }
+                    catch {
+                        nr[k] = row[k];
+                    }
+                }
+                return nr;
             });
-        }, 'select', table);
+        });
     }
     async selectOne(table, where = null) {
-        const results = await this.select(table, where);
-        return results[0] || null;
+        const res = await this.select(table, where);
+        return res[0] || null;
     }
     async set(table, data, where) {
         const existing = await this.selectOne(table, where);
         return existing ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
     async bulkInsert(table, dataArray) {
-        return this._queueRequest(async () => {
-            if (!dataArray.length)
-                return 0;
+        if (!dataArray.length)
+            return 0;
+        return this._execute('bulkInsert', table, async () => {
             await this.ensureTable(table, dataArray[0]);
             const keys = Object.keys(dataArray[0]);
             const placeholders = dataArray.map(() => `(${keys.map(() => '?').join(',')})`).join(',');
             const values = dataArray.flatMap(obj => keys.map(k => this._serializeValue(obj[k])));
-            const sql = `INSERT INTO 
+            const sql = `INSERT INTO
 ${table}
  (${keys.map(k => `
 ${k}
 `).join(",")}) VALUES ${placeholders}`;
             const result = await this.query(sql, values);
             return result.affectedRows;
-        }, 'bulkInsert', table);
+        });
     }
-    async increment(table, increments, where) {
-        return this._queueRequest(async () => {
-            const clauses = Object.keys(increments).map(f => `
+    async increment(table, incs, where) {
+        return this._execute('increment', table, async () => {
+            await this.ensureTable(table, where);
+            const set = Object.keys(incs).map(f => `
 ${f}
- = 
+ =
 ${f}
  + ?`).join(', ');
-            const { whereClause, values } = this._buildWhereClause(where);
-            const sql = `UPDATE 
+            const wKeys = Object.keys(where);
+            const sql = `UPDATE
 ${table}
- SET ${clauses} ${whereClause}`;
-            const result = await this.query(sql, [...Object.values(increments), ...values]);
+ SET ${set} WHERE ${wKeys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, [...Object.values(incs), ...Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v)]);
             return result.affectedRows;
-        }, 'increment', table);
+        });
     }
-    async decrement(table, decrements, where) {
+    async decrement(table, decs, where) {
         const incs = {};
-        for (const k in decrements)
-            incs[k] = -decrements[k];
+        for (const k in decs)
+            incs[k] = -decs[k];
         return this.increment(table, incs, where);
     }
     async close() { if (this.pool)
@@ -214,6 +237,8 @@ ${table}
             return Number.isInteger(v) ? 'INT' : 'DOUBLE';
         if (v instanceof Date)
             return 'DATETIME';
+        if (typeof v === 'object')
+            return 'JSON';
         return 'TEXT';
     }
     _serializeValue(v) {
@@ -221,24 +246,18 @@ ${table}
             return v.toISOString().slice(0, 19).replace('T', ' ');
         return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
     }
-    _deserializeValue(v) {
-        if (typeof v === 'string' && (v.startsWith('{') || v.startsWith('['))) {
-            try {
-                return JSON.parse(v);
-            }
-            catch {
-                return v;
-            }
-        }
-        return v;
-    }
     _buildWhereClause(where) {
+        if (!where)
+            return { whereClause: '', values: [] };
         const keys = Object.keys(where);
         if (!keys.length)
             return { whereClause: '', values: [] };
-        return { whereClause: 'WHERE ' + keys.map(k => `
+        return {
+            whereClause: 'WHERE ' + keys.map(k => `
 ${k}
- = ?`).join(' AND '), values: Object.values(where).map(v => this._serializeValue(v)) };
+ = ?`).join(' AND '),
+            values: Object.values(where).map(v => this._serializeValue(v))
+        };
     }
 }
 exports.MySQLDatabase = MySQLDatabase;

package/dist/database/pg.d.ts

@@ -10,7 +10,6 @@ export declare class PostgreSQLDatabase extends IDatabase {
     private _execute;
     private _processQueue;
     query(sql: string, params?: any[]): Promise<any>;
-    private _ensureMissingColumns;
     ensureTable(table: string, data?: any): Promise<void>;
     insert(table: string, data: any): Promise<any>;
     update(table: string, data: any, where: any): Promise<number>;
@@ -24,6 +23,6 @@ export declare class PostgreSQLDatabase extends IDatabase {
     close(): Promise<void>;
     private _getColumnType;
     private _serializeValue;
-    private _deserializeValue;
+    private _buildWhereClause;
 }
 export default PostgreSQLDatabase;

package/dist/database/pg.js

@@ -12,7 +12,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         this.config = config;
         this._connectionPromise = new Promise(async (resolve, reject) => {
             try {
-                const tempPool = new pg_1.Pool({ host: config.host, port: config.port || 5432, user: config.user, password: config.password, database: 'postgres' });
+                const tempPool = new pg_1.Pool({ host: config.host || 'localhost', port: config.port || 5432, user: config.username, password: config.password, database: 'postgres' });
                 try {
                     await tempPool.query(`CREATE DATABASE "${config.database}"`);
                 }
@@ -21,7 +21,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
                         console.warn(e.message);
                 }
                 await tempPool.end();
-                this.pool = new pg_1.Pool({ host: config.host, port: config.port || 5432, user: config.user, password: config.password, database: config.database, max: config.connectionLimit || 10 });
+                this.pool = new pg_1.Pool({ host: config.host || 'localhost', port: config.port || 5432, user: config.username, password: config.password, database: config.database, max: config.poolSize || 10 });
                 this._connected = true;
                 resolve(this.pool);
                 this._processQueue();
@@ -33,15 +33,11 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
     }
     async _execute(op, table, fn) {
         const start = Date.now();
-        const execute = async () => {
-            const res = await fn();
-            this.recordMetric(op, table, Date.now() - start);
-            return res;
-        };
-        if (this._connected)
-            return execute();
-        return new Promise((resolve, reject) => this._queue.push({ operation: execute, resolve, reject }));
+        const res = await fn();
+        this.recordMetric(op, table, Date.now() - start);
+        return res;
     }
+    ;
     async _processQueue() {
         if (!this._connected)
             return;
@@ -62,24 +58,20 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         const res = await pool.query(sql, params);
         return res.rows;
     }
-    async _ensureMissingColumns(table, data) {
-        const existing = await this.query(`SELECT column_name FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public'`, [table]);
-        const names = existing.map((c) => c.column_name);
-        for (const key of Object.keys(data)) {
-            if (key !== '_id' && !names.includes(key)) {
-                const type = this._getColumnType(data[key]);
-                await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${type}`);
-            }
-        }
-    }
     async ensureTable(table, data = {}) {
         const tables = await this.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1`, [table]);
         if (tables.length === 0) {
-            const defs = Object.keys(data).map(k => `"${k}" ${this._getColumnType(data[k])}`);
+            const defs = Object.keys(data).map(k => `"${k}" TEXT`);
             await this.query(`CREATE TABLE "${table}" ("_id" SERIAL PRIMARY KEY ${defs.length ? ', ' + defs.join(",") : ''})`);
         }
         else {
-            await this._ensureMissingColumns(table, data);
+            const existing = await this.query(`SELECT column_name FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public'`, [table]);
+            const names = existing.map((c) => c.column_name);
+            for (const key of Object.keys(data)) {
+                if (key !== '_id' && !names.includes(key)) {
+                    await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" TEXT`);
+                }
+            }
         }
     }
     async insert(table, data) {
@@ -99,10 +91,10 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         return this._execute('update', table, async () => {
             await this.ensureTable(table, { ...data, ...where });
             const set = Object.keys(data).map((k, i) => `"${k}" = $${i + 1}`).join(",");
-            const wKeys = Object.keys(where);
-            const sql = `UPDATE "${table}" SET ${set} WHERE ${wKeys.map((k, i) => `"${k}" = $${Object.keys(data).length + i + 1}`).join(" AND ")}`;
+            const { whereClause, values: whereValues } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
             const pool = await this._connectionPromise;
-            const res = await pool.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
+            const res = await pool.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...whereValues]);
             return res.rowCount ?? 0;
         });
     }
@@ -110,23 +102,22 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         await this.runHooks('beforeDelete', table, where);
         return this._execute('delete', table, async () => {
             await this.ensureTable(table, where);
-            const keys = Object.keys(where);
-            const sql = `DELETE FROM "${table}" WHERE ${keys.map((k, i) => `"${k}" = $${i + 1}`).join(" AND ")}`;
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `DELETE FROM "${table}" ${whereClause}`;
             const pool = await this._connectionPromise;
-            const res = await pool.query(sql, Object.values(where).map(v => this._serializeValue(v)));
+            const res = await pool.query(sql, values);
             return res.rowCount ?? 0;
         });
     }
     async select(table, where = null) {
         return this._execute('select', table, async () => {
             await this.ensureTable(table, where || {});
-            const keys = where ? Object.keys(where) : [];
-            const sql = `SELECT * FROM "${table}"` + (keys.length ? ` WHERE ${keys.map((k, i) => `"${k}" = $${i + 1}`).join(" AND ")}` : '');
-            const rows = await this.query(sql, Object.values(where || {}).map(v => this._serializeValue(v)));
+            const { whereClause, values } = this._buildWhereClause(where);
+            const rows = await this.query(`SELECT * FROM "${table}" ${whereClause}`, values);
             return rows.map((r) => {
                 const nr = {};
                 for (const k in r)
-                    nr[k] = this._deserializeValue(r[k]);
+                    nr[k] = r[k];
                 return nr;
             });
         });
@@ -142,21 +133,18 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
     async bulkInsert(table, dataArray) {
         if (!dataArray.length)
             return 0;
-        return this._execute('bulkInsert', table, async () => {
-            await this.ensureTable(table, dataArray[0]);
-            for (const d of dataArray)
-                await this.insert(table, d);
-            return dataArray.length;
-        });
+        for (const d of dataArray)
+            await this.insert(table, d);
+        return dataArray.length;
     }
     async increment(table, incs, where) {
         return this._execute('increment', table, async () => {
             await this.ensureTable(table, where);
             const set = Object.keys(incs).map((f, i) => `"${f}" = "${f}" + $${i + 1}`).join(',');
-            const wKeys = Object.keys(where);
-            const sql = `UPDATE "${table}" SET ${set} WHERE ${wKeys.map((k, i) => `"${k}" = $${Object.keys(incs).length + i + 1}`).join(" AND ")}`;
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
             const pool = await this._connectionPromise;
-            const res = await pool.query(sql, [...Object.values(incs), ...Object.values(where).map(v => this._serializeValue(v))]);
+            const res = await pool.query(sql, [...Object.values(incs), ...values]);
             return res.rowCount ?? 0;
         });
     }
@@ -186,9 +174,17 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
             return v.toISOString();
         return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
     }
-    _deserializeValue(v) {
-        // PG automatically handles JSONB, but sometimes manual parsing is safer for consistency
-        return v;
+    _buildWhereClause(where) {
+        if (!where)
+            return { whereClause: '', values: [] };
+        const safeWhere = where;
+        const keys = Object.keys(safeWhere);
+        if (!keys.length)
+            return { whereClause: '', values: [] };
+        return {
+            whereClause: 'WHERE ' + keys.map((k, i) => `"${k}" = $${i + 1}`).join(' AND '),
+            values: keys.map(k => this._serializeValue(safeWhere[k]))
+        };
     }
 }
 exports.PostgreSQLDatabase = PostgreSQLDatabase;

package/dist/database/redis.d.ts

@@ -1,11 +1,12 @@
 import { IDatabase } from './IDatabase';
 import { RedisClientType } from 'redis';
+import { RedisConfig } from './types';
 export declare class RedisDatabase extends IDatabase {
     private config;
     private client;
     private isConnecting;
     private keyPrefix;
-    constructor(config?: any);
+    constructor(config: RedisConfig);
     private _execute;
     connect(): Promise<RedisClientType>;
     private _getKey;

package/dist/database/redis.js

@@ -4,17 +4,11 @@ exports.RedisDatabase = void 0;
 const IDatabase_1 = require("./IDatabase");
 const redis_1 = require("redis");
 class RedisDatabase extends IDatabase_1.IDatabase {
-    constructor(config = {}) {
+    constructor(config) {
         super();
         this.client = null;
         this.isConnecting = false;
-        this.config = {
-            host: config.host || '127.0.0.1',
-            port: config.port || 6379,
-            password: config.password,
-            db: config.db || 0,
-            connectTimeout: config.connectTimeout || 5000,
-        };
+        this.config = config;
         this.keyPrefix = config.keyPrefix || 'app:';
     }
     async _execute(op, table, fn) {
@@ -23,6 +17,7 @@ class RedisDatabase extends IDatabase_1.IDatabase {
         this.recordMetric(op, table, Date.now() - start);
         return res;
     }
+    ;
     async connect() {
         if (this.client && this.client.isReady)
             return this.client;
@@ -34,9 +29,10 @@ class RedisDatabase extends IDatabase_1.IDatabase {
         this.isConnecting = true;
         try {
             this.client = (0, redis_1.createClient)({
-                socket: { host: this.config.host, port: this.config.port, connectTimeout: this.config.connectTimeout },
+                url: this.config.url,
+                socket: { host: this.config.host || '127.0.0.1', port: this.config.port || 6379 },
                 password: this.config.password,
-                database: this.config.db,
+                database: Number(this.config.database) || 0,
             });
             await this.client.connect();
             return this.client;
@@ -82,8 +78,7 @@ class RedisDatabase extends IDatabase_1.IDatabase {
             const client = await this.connect();
             for (const item of existing) {
                 const merged = { ...item, ...data };
-                const id = String(item._id || item.id);
-                await client.set(this._getKey(table, id), JSON.stringify(merged));
+                await client.set(this._getKey(table, item._id || item.id), JSON.stringify(merged));
             }
             return existing.length;
         });
@@ -110,15 +105,16 @@ class RedisDatabase extends IDatabase_1.IDatabase {
         return dataArray.length;
     }
     async increment(table, incs, where = {}) {
-        const recs = await this.select(table, where);
-        const client = await this.connect();
-        for (const r of recs) {
-            for (const [f, v] of Object.entries(incs))
-                r[f] = (Number(r[f]) || 0) + v;
-            const id = String(r._id || r.id);
-            await client.set(this._getKey(table, id), JSON.stringify(r));
-        }
-        return recs.length;
+        return this._execute('increment', table, async () => {
+            const recs = await this.select(table, where);
+            const client = await this.connect();
+            for (const r of recs) {
+                for (const [f, v] of Object.entries(incs))
+                    r[f] = (Number(r[f]) || 0) + v;
+                await client.set(this._getKey(table, r._id || r.id), JSON.stringify(r));
+            }
+            return recs.length;
+        });
     }
     async decrement(table, decs, where = {}) {
         const incs = {};

package/dist/database/sqlite.d.ts

@@ -5,10 +5,6 @@ export declare class SQLiteDatabase extends IDatabase {
     constructor(config: SQLiteConfig);
     private _execute;
     query(sql: string, params?: any[]): Promise<any>;
-    /**
-     * SQLite dynamically adds missing columns using ALTER TABLE.
-     */
-    private _ensureMissingColumns;
     ensureTable(table: string, data?: any): Promise<void>;
     insert(table: string, data: any): Promise<number>;
     update(table: string, data: any, where: any): Promise<number>;
@@ -20,5 +16,7 @@ export declare class SQLiteDatabase extends IDatabase {
     increment(table: string, incs: any, where: any): Promise<number>;
     decrement(table: string, decs: any, where: any): Promise<number>;
     close(): Promise<void>;
+    private _serializeValue;
+    private _buildWhereClause;
 }
 export default SQLiteDatabase;

package/dist/database/sqlite.js

@@ -11,12 +11,12 @@ const path_1 = __importDefault(require("path"));
 class SQLiteDatabase extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
-        if (!config || !config.filename)
-            throw new Error('SQLite "filename" gereklidir.');
-        const dir = path_1.default.dirname(config.filename);
+        if (!config || !config.path)
+            throw new Error('SQLite "path" gereklidir.');
+        const dir = path_1.default.dirname(config.path);
         if (!fs_1.default.existsSync(dir))
             fs_1.default.mkdirSync(dir, { recursive: true });
-        this.db = new sqlite3_1.default.Database(config.filename);
+        this.db = new sqlite3_1.default.Database(config.path);
     }
     async _execute(op, table, fn) {
         const start = Date.now();
@@ -24,6 +24,7 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
         this.recordMetric(op, table, Date.now() - start);
         return res;
     }
+    ;
     async query(sql, params = []) {
         return new Promise((resolve, reject) => {
             const s = sql.trim().toUpperCase();
@@ -35,22 +36,16 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
             }
         });
     }
-    /**
-     * SQLite dynamically adds missing columns using ALTER TABLE.
-     */
-    async _ensureMissingColumns(table, data) {
-        const info = await this.query(`PRAGMA table_info("${table}")`);
-        const names = info.map(c => c.name);
-        for (const key of Object.keys(data)) {
-            if (key !== '_id' && !names.includes(key)) {
-                await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" TEXT`);
-            }
-        }
-    }
     async ensureTable(table, data = {}) {
         try {
             await this.query(`SELECT 1 FROM "${table}" LIMIT 1`);
-            await this._ensureMissingColumns(table, data);
+            const info = await this.query(`PRAGMA table_info("${table}")`);
+            const names = info.map(c => c.name);
+            for (const key of Object.keys(data)) {
+                if (key !== '_id' && !names.includes(key)) {
+                    await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" TEXT`);
+                }
+            }
         }
         catch {
             const defs = Object.keys(data).map(k => `"${k}" TEXT`);
@@ -63,7 +58,7 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
             await this.ensureTable(table, data);
             const keys = Object.keys(data);
             const sql = `INSERT INTO "${table}" (${keys.map(k => `"${k}"`).join(',')}) VALUES (${keys.map(() => '?').join(',')})`;
-            const res = await this.query(sql, Object.values(data).map(v => JSON.stringify(v)));
+            const res = await this.query(sql, Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
             const finalData = { _id: res.lastID, ...data };
             await this.runHooks('afterInsert', table, finalData);
             return res.lastID;
@@ -74,9 +69,9 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
         return this._execute('update', table, async () => {
             await this.ensureTable(table, { ...data, ...where });
             const set = Object.keys(data).map(k => `"${k}" = ?`).join(',');
-            const keys = Object.keys(where);
-            const sql = `UPDATE "${table}" SET ${set} WHERE ${keys.map(k => `"${k}" = ?`).join(' AND ')}`;
-            const res = await this.query(sql, [...Object.values(data).map(v => JSON.stringify(v)), ...Object.values(where).map(v => JSON.stringify(v))]);
+            const { whereClause, values: whereValues } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
+            const res = await this.query(sql, [...Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v), ...whereValues]);
             return res.changes;
         });
     }
@@ -84,18 +79,17 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
         await this.runHooks('beforeDelete', table, where);
         return this._execute('delete', table, async () => {
             await this.ensureTable(table, where);
-            const keys = Object.keys(where);
-            const sql = `DELETE FROM "${table}" WHERE ${keys.map(k => `"${k}" = ?`).join(' AND ')}`;
-            const res = await this.query(sql, Object.values(where).map(v => JSON.stringify(v)));
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `DELETE FROM "${table}" ${whereClause}`;
+            const res = await this.query(sql, values);
             return res.changes;
         });
     }
     async select(table, where = null) {
         return this._execute('select', table, async () => {
             await this.ensureTable(table, where || {});
-            const keys = where ? Object.keys(where) : [];
-            const sql = `SELECT * FROM "${table}"` + (keys.length ? ` WHERE ${keys.map(k => `"${k}" = ?`).join(' AND ')}` : '');
-            const rows = await this.query(sql, keys.map(k => JSON.stringify(where[k])));
+            const { whereClause, values } = this._buildWhereClause(where);
+            const rows = await this.query(`SELECT * FROM "${table}" ${whereClause}`, values);
             return rows.map((r) => {
                 const nr = {};
                 for (const k in r) {
@@ -103,20 +97,10 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
                         nr[k] = JSON.parse(r[k]);
                     }
                     catch {
-                        nr[nr[k] = r[k]];
-                    }
-                }
-                const { _id, ...rest } = r; // Handle _id vs id
-                const finalObj = { _id };
-                for (const k in rest) {
-                    try {
-                        finalObj[k] = JSON.parse(rest[k]);
-                    }
-                    catch {
-                        finalObj[k] = rest[k];
+                        nr[k] = r[k];
                     }
                 }
-                return finalObj;
+                return nr;
             });
         });
     }
@@ -138,10 +122,10 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
     async increment(table, incs, where) {
         return this._execute('increment', table, async () => {
             await this.ensureTable(table, where);
-            const set = Object.keys(incs).map(f => `"${f}" = CAST("${f}" AS SKIP_CAST) + ?`.replace('SKIP_CAST', 'NUMERIC'));
-            const keys = Object.keys(where);
-            const sql = `UPDATE "${table}" SET ${set} WHERE ${keys.map(k => `"${k}" = ?`).join(' AND ')}`;
-            const res = await this.query(sql, [...Object.values(incs), ...Object.values(where).map(v => JSON.stringify(v))]);
+            const set = Object.keys(incs).map(f => `"${f}" = CAST("${f}" AS NUMERIC) + ?`);
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
+            const res = await this.query(sql, [...Object.values(incs), ...values]);
             return res.changes;
         });
     }
@@ -152,6 +136,23 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
         return this.increment(table, incs, where);
     }
     async close() { return new Promise((resolve, reject) => this.db.close(err => err ? reject(err) : resolve())); }
+    _serializeValue(v) {
+        if (v instanceof Date)
+            return v.toISOString().slice(0, 19).replace('T', ' ');
+        return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
+    }
+    _buildWhereClause(where) {
+        if (!where)
+            return { whereClause: '', values: [] };
+        const safeWhere = where;
+        const keys = Object.keys(safeWhere);
+        if (!keys.length)
+            return { whereClause: '', values: [] };
+        return {
+            whereClause: 'WHERE ' + keys.map(k => `"${k}" = ?`).join(' AND '),
+            values: keys.map(k => this._serializeValue(safeWhere[k]))
+        };
+    }
 }
 exports.SQLiteDatabase = SQLiteDatabase;
 exports.default = SQLiteDatabase;

package/dist/database/toon.d.ts

@@ -1,9 +1,5 @@
 import { IDatabase } from './IDatabase';
-export interface ToonConfig {
-    filePath: string;
-    saveInterval?: number;
-    cache?: any;
-}
+import { ToonConfig } from './types';
 export declare class ToonDatabase extends IDatabase {
     private filePath;
     private db;

package/dist/database/toon.js

@@ -17,9 +17,9 @@ class ToonDatabase extends IDatabase_1.IDatabase {
         this.isWriting = false;
         this.writeQueue = [];
         this.saveDebounceTimeout = null;
-        if (!config || !config.filePath)
-            throw new Error('ToonDB: "filePath" gereklidir.');
-        this.filePath = config.filePath;
+        if (!config || !config.path)
+            throw new Error('ToonDB: "path" gereklidir.');
+        this.filePath = config.path;
         this.saveInterval = config.saveInterval || 500;
         process.on('exit', () => this.flushSync());
         this.initPromise = this._load();
@@ -86,8 +86,7 @@ class ToonDatabase extends IDatabase_1.IDatabase {
             clearTimeout(this.saveDebounceTimeout);
         this.saveDebounceTimeout = null;
         try {
-            const toonContent = (0, toon_1.stringify)(this.db);
-            await promises_1.default.writeFile(this.filePath, toonContent);
+            await promises_1.default.writeFile(this.filePath, (0, toon_1.stringify)(this.db));
             this.isDirty = false;
         }
         catch (error) {

package/dist/database/types.d.ts

@@ -1,53 +1,38 @@
-export interface MySQLConfig {
-    host: string;
-    user: string;
-    password?: string;
-    database: string;
-    port?: number;
-    connectionLimit?: number;
-    cache?: CacheConfig;
-}
-export interface SQLiteConfig {
-    filename: string;
-    cache?: CacheConfig;
-}
-export interface MongoDBConfig {
-    uri: string;
-    dbName: string;
-    cache?: CacheConfig;
-}
-export interface PostgreSQLConfig {
-    host: string;
-    user: string;
-    password?: string;
-    database: string;
-    port?: number;
-    connectionLimit?: number;
+export interface BaseConfig {
     cache?: CacheConfig;
 }
-export interface RedisConfig {
+export interface NetworkConfig extends BaseConfig {
     host?: string;
     port?: number;
+    username?: string;
     password?: string;
-    db?: number;
+    database?: string;
+    url?: string;
+    poolSize?: number;
+}
+export interface FileConfig extends BaseConfig {
+    path: string;
+}
+export interface MySQLConfig extends NetworkConfig {
+}
+export interface PostgreSQLConfig extends NetworkConfig {
+}
+export interface SQLiteConfig extends FileConfig {
+}
+export interface MongoDBConfig extends NetworkConfig {
+}
+export interface RedisConfig extends NetworkConfig {
     keyPrefix?: string;
-    cache?: CacheConfig;
 }
-export interface JsonConfig {
-    filePath: string;
+export interface JsonConfig extends FileConfig {
     saveInterval?: number;
-    cache?: CacheConfig;
 }
-export interface ZPackConfig {
-    filePath: string;
+export interface ZPackConfig extends FileConfig {
     autoFlush?: boolean;
-    cache?: CacheConfig;
     indexFields?: Record<string, string[]>;
 }
-export interface ToonConfig {
-    filePath: string;
+export interface ToonConfig extends FileConfig {
     saveInterval?: number;
-    cache?: CacheConfig;
 }
 export interface CacheConfig {
     type: 'memory' | 'redis';

package/dist/database/zpack.d.ts

@@ -44,9 +44,7 @@ export declare class ZPackAdapter extends IDatabase {
     private rowCache;
     private secondary;
     private indexedFields;
-    constructor(config: ZPackConfig & {
-        indexFields?: Record<string, string[]>;
-    });
+    constructor(config: ZPackConfig);
     private _init;
     ensureTable(table: string): Promise<void>;
     private _updateSecondaryIndex;
@@ -59,8 +57,8 @@ export declare class ZPackAdapter extends IDatabase {
     delete(table: string, where: Record<string, any>): Promise<number>;
     set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
     bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
-    increment(table: string, increments: Record<string, number>, where?: Record<string, any>): Promise<number>;
-    decrement(table: string, decrements: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    increment(table: string, incs: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    decrement(table: string, decs: Record<string, number>, where?: Record<string, any>): Promise<number>;
     vacuum(): Promise<void>;
     close(): Promise<void>;
 }

package/dist/database/zpack.js

@@ -133,7 +133,7 @@ class ZPackDatabase {
                 }
                 else {
                     this.index.set(meta.docId, cur);
-                    this.deleted.delete(meta.docId);
+                    this.deleted.add(meta.docId); // Bugfix: added to deleted, should be removed
                     if (meta.docId >= this._nextId)
                         this._nextId = meta.docId + 1;
                 }
@@ -254,9 +254,7 @@ class ZPackDatabase {
                 const decompressed = zlib_1.default.inflateSync(buf.subarray(6));
                 return { docId, fieldCount: 1, document: JSON.parse(decompressed.toString()) };
             }
-            catch (e) {
-                // Fallback if not compressed or corrupted
-            }
+            catch (e) { }
         }
         let p = 6;
         const end = 2 + payloadSize;
@@ -353,10 +351,7 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         this.rowCache = new Map();
         this.secondary = new Map();
         this.indexedFields = new Map();
-        this.db = new ZPackDatabase(config.filePath, {
-            autoFlush: !!config.autoFlush,
-            compression: !!config.cache
-        });
+        this.db = new ZPackDatabase(config.path, { autoFlush: !!config.autoFlush, compression: !!config.cache });
         if (config.indexFields) {
             for (const [table, fields] of Object.entries(config.indexFields)) {
                 this.indexedFields.set(table, new Set(fields));
@@ -395,9 +390,8 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             if (!tableIndex.has(field))
                 tableIndex.set(field, new Map());
             const fieldMap = tableIndex.get(field);
-            if (oldData && oldData[field] !== undefined) {
+            if (oldData && oldData[field] !== undefined)
                 fieldMap.get(String(oldData[field]))?.delete(logicalId);
-            }
             if (data[field] !== undefined) {
                 const newVal = String(data[field]);
                 if (!fieldMap.has(newVal))
@@ -420,6 +414,7 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         return Object.entries(where).every(([k, v]) => String(row[k]) === String(v));
     }
     async select(table, where = null) {
+        const start = Date.now();
         await this.initPromise;
         await this.ensureTable(table);
         if (where && Object.keys(where).length === 1) {
@@ -437,6 +432,7 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
                                 results.push(doc);
                         }
                     }
+                    this.recordMetric('select', table, Date.now() - start);
                     return results;
                 }
                 return [];
@@ -455,6 +451,7 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             if (this._matches(row, where))
                 results.push({ ...row });
         }
+        this.recordMetric('select', table, Date.now() - start);
         return results;
     }
     async selectOne(table, where = null) {
@@ -462,23 +459,24 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
         return res[0] || null;
     }
     async insert(table, data) {
+        const start = Date.now();
         await this.initPromise;
         await this.ensureTable(table);
-        // Trigger beforeInsert BEFORE coercion
         await this.runHooks('beforeInsert', table, data);
         const nextId = (this.tableMaxId.get(table) || 0) + 1;
         const record = this._coerce(table, data, nextId);
         const physicalId = await this.db.insert(record);
         this.tableMaxId.set(table, nextId);
         this.keyIndex.get(table).set(nextId, physicalId);
-        // Recover original data structure for cache and afterInsert hook
         const fullRow = { _id: nextId, ...data };
         this.rowCache.get(table).set(nextId, fullRow);
         this._updateSecondaryIndex(table, nextId, fullRow);
         await this.runHooks('afterInsert', table, fullRow);
+        this.recordMetric('insert', table, Date.now() - start);
         return nextId;
     }
     async update(table, data, where) {
+        const start = Date.now();
         const rows = await this.select(table, where);
         for (const row of rows) {
             const logicalId = row._id;
@@ -491,9 +489,11 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             this._updateSecondaryIndex(table, logicalId, merged, row);
             await this.runHooks('afterUpdate', table, merged);
         }
+        this.recordMetric('update', table, Date.now() - start);
         return rows.length;
     }
     async delete(table, where) {
+        const start = Date.now();
         const rows = await this.select(table, where);
         for (const row of rows) {
             const logicalId = row._id;
@@ -507,36 +507,33 @@ class ZPackAdapter extends IDatabase_1.IDatabase {
             }
             await this.runHooks('afterDelete', table, row);
         }
+        this.recordMetric('delete', table, Date.now() - start);
         return rows.length;
     }
     async set(table, data, where) {
-        const existing = await this.selectOne(table, where);
-        return existing ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
+        const ex = await this.selectOne(table, where);
+        return ex ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
     async bulkInsert(table, dataArray) {
-        for (const data of dataArray)
-            await this.insert(table, data);
+        for (const d of dataArray)
+            await this.insert(table, d);
         return dataArray.length;
     }
-    async increment(table, increments, where = {}) {
+    async increment(table, incs, where = {}) {
         const rows = await this.select(table, where);
         for (const row of rows) {
             const updated = { ...row };
-            for (const [f, v] of Object.entries(increments))
+            for (const [f, v] of Object.entries(incs))
                 updated[f] = (Number(updated[f]) || 0) + v;
             await this.update(table, updated, { _id: row._id });
         }
         return rows.length;
     }
-    async decrement(table, decrements, where = {}) {
-        const rows = await this.select(table, where);
-        for (const row of rows) {
-            const updated = { ...row };
-            for (const [f, v] of Object.entries(decrements))
-                updated[f] = (Number(updated[f]) || 0) - v;
-            await this.update(table, updated, { _id: row._id });
-        }
-        return rows.length;
+    async decrement(table, decs, where = {}) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
     }
     async vacuum() { await this.db.vacuum(); }
     async close() { await this.db.close(); }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "9.1.0",
+  "version": "9.2.0",
   "description": "ZeroHelper is a versatile high-performance utility library and database framework for Node.js, fully written in TypeScript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -76,4 +76,4 @@
     "ts-jest": "^29.2.5",
     "typescript": "^5.7.2"
   }
-}
+}