@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/json.js

@@ -16,13 +16,19 @@ 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();
     }
+    async _execute(op, table, fn) {
+        const start = Date.now();
+        const res = await fn();
+        this.recordMetric(op, table, Date.now() - start);
+        return res;
+    }
     async _load() {
         try {
             const dir = path_1.default.dirname(this.filePath);
@@ -83,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() {
@@ -95,116 +101,108 @@ class JsonDatabase extends IDatabase_1.IDatabase {
             catch (error) { }
         }
     }
-    _matches(row, where) {
-        return Object.keys(where).every(key => row[key] === where[key]);
-    }
     async ensureTable(table) {
         await this.initPromise;
         if (!this.db[table]) {
-            return this._queueRequest(() => {
-                this.db[table] = [];
-            });
+            return this._queueRequest(() => { this.db[table] = []; });
         }
     }
     async insert(table, data) {
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            const maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
-            const newId = maxId + 1;
-            const newRow = { _id: newId, ...data };
-            this.db[table].push(newRow);
-            return newId;
+        await this.runHooks('beforeInsert', table, data);
+        return this._execute('insert', table, async () => {
+            await this.ensureTable(table);
+            return this._queueRequest(() => {
+                const maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
+                const newId = maxId + 1;
+                const newRow = { _id: newId, ...data };
+                this.db[table].push(newRow);
+                this.runHooks('afterInsert', table, newRow);
+                return newId;
+            });
         });
     }
     async update(table, data, where) {
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            let affectedRows = 0;
-            this.db[table].forEach(row => {
-                if (this._matches(row, where)) {
-                    Object.assign(row, data);
-                    affectedRows++;
-                }
+        await this.runHooks('beforeUpdate', table, { data, where });
+        return this._execute('update', table, async () => {
+            await this.ensureTable(table);
+            return this._queueRequest(() => {
+                let affected = 0;
+                this.db[table].forEach(row => {
+                    if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
+                        Object.assign(row, data);
+                        affected++;
+                    }
+                });
+                this.runHooks('afterUpdate', table, { affected });
+                return affected;
             });
-            return affectedRows;
         });
     }
     async delete(table, where) {
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            const initialLength = this.db[table].length;
-            this.db[table] = this.db[table].filter(row => !this._matches(row, where));
-            return initialLength - this.db[table].length;
+        await this.runHooks('beforeDelete', table, where);
+        return this._execute('delete', table, async () => {
+            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 => String(row[k]) === String(where[k])));
+                const affected = initial - this.db[table].length;
+                this.runHooks('afterDelete', table, { affected });
+                return affected;
+            });
         });
     }
     async select(table, where = null) {
-        await this.initPromise;
-        const tableData = this.db[table] || [];
-        let results = tableData;
-        if (where && Object.keys(where).length > 0) {
-            results = results.filter(row => this._matches(row, where));
-        }
-        return JSON.parse(JSON.stringify(results));
-    }
-    async set(table, data, where) {
-        const existing = await this.select(table, where);
-        if (existing.length === 0) {
-            return this.insert(table, { ...where, ...data });
-        }
-        else {
-            return this.update(table, data, where);
-        }
+        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 => String(row[k]) === String(where[k])))
+                : (this.db[table] || []);
+            return JSON.parse(JSON.stringify(results));
+        });
     }
     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 bulkInsert(table, dataArray) {
-        if (!Array.isArray(dataArray) || dataArray.length === 0)
-            return 0;
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            let maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
-            dataArray.forEach(data => {
-                maxId++;
-                this.db[table].push({ _id: maxId, ...data });
-            });
-            return dataArray.length;
-        });
+    async set(table, data, where) {
+        const ex = await this.selectOne(table, where);
+        return ex ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
-    async increment(table, increments, where = {}) {
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            let affectedCount = 0;
-            this.db[table].forEach(row => {
-                if (this._matches(row, where)) {
-                    for (const [field, value] of Object.entries(increments)) {
-                        row[field] = (Number(row[field]) || 0) + value;
-                    }
-                    affectedCount++;
-                }
+    async bulkInsert(table, dataArray) {
+        return this._execute('bulkInsert', table, async () => {
+            if (!dataArray.length)
+                return 0;
+            await this.ensureTable(table);
+            return this._queueRequest(() => {
+                let maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
+                dataArray.forEach(data => { maxId++; this.db[table].push({ _id: maxId, ...data }); });
+                return dataArray.length;
             });
-            return affectedCount;
         });
     }
-    async decrement(table, decrements, where = {}) {
-        await this.ensureTable(table);
-        return this._queueRequest(() => {
-            let affectedCount = 0;
-            this.db[table].forEach(row => {
-                if (this._matches(row, where)) {
-                    for (const [field, value] of Object.entries(decrements)) {
-                        row[field] = (Number(row[field]) || 0) - value;
+    async increment(table, incs, where = {}) {
+        return this._execute('increment', table, async () => {
+            await this.ensureTable(table);
+            return this._queueRequest(() => {
+                let affected = 0;
+                this.db[table].forEach(row => {
+                    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++;
                     }
-                    affectedCount++;
-                }
+                });
+                return affected;
             });
-            return affectedCount;
         });
     }
-    async close() {
-        await this._saveNow();
+    async decrement(table, decs, where = {}) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
     }
+    async close() { await this._saveNow(); }
 }
 exports.JsonDatabase = JsonDatabase;
 exports.default = JsonDatabase;

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,19 +7,18 @@ export declare class MongoDBDatabase extends IDatabase {
     private _queue;
     private _connected;
     private _connectionPromise;
-    constructor(config: any);
-    private _queueRequest;
+    constructor(config: MongoDBConfig);
+    private _execute;
     private _processQueue;
-    ensureCollection(collection: string): Promise<void>;
-    insert(collection: string, data: Record<string, any>): Promise<any>;
-    bulkInsert(collection: string, dataArray: Record<string, any>[]): Promise<number>;
-    update(collection: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
-    delete(collection: string, where: Record<string, any>): Promise<number>;
-    select<T = any>(collection: string, where?: Record<string, any>): Promise<T[]>;
-    selectOne<T = any>(collection: string, where?: Record<string, any>): Promise<T | null>;
-    set(collection: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
-    increment(collection: string, increments: Record<string, number>, where?: Record<string, any>): Promise<number>;
-    decrement(collection: string, decrements: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    insert(collection: string, data: any): Promise<any>;
+    update(collection: string, data: any, where: any): Promise<number>;
+    delete(collection: string, where: any): Promise<number>;
+    select<T = any>(collection: string, where?: any): Promise<T[]>;
+    selectOne<T = any>(collection: string, where?: any): Promise<T | null>;
+    set(collection: string, data: any, where: any): Promise<any>;
+    bulkInsert(collection: string, dataArray: any[]): Promise<number>;
+    increment(collection: string, incs: Record<string, number>, where?: any): Promise<number>;
+    decrement(collection: string, decs: Record<string, number>, where?: any): Promise<number>;
     close(): Promise<void>;
 }
 export default MongoDBDatabase;

package/dist/database/mongodb.js

@@ -10,30 +10,30 @@ 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();
             }
             catch (error) {
-                console.error("MongoDB connection error:", error);
                 reject(error);
             }
         });
     }
-    async _queueRequest(operation) {
-        if (this._connected) {
-            return operation();
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this._queue.push({ operation, resolve, reject });
-            });
-        }
+    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 }));
     }
     async _processQueue() {
         if (!this._connected)
@@ -42,8 +42,7 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
             const item = this._queue.shift();
             if (item) {
                 try {
-                    const result = await item.operation();
-                    item.resolve(result);
+                    item.resolve(await item.operation());
                 }
                 catch (error) {
                     item.reject(error);
@@ -51,103 +50,71 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
             }
         }
     }
-    async ensureCollection(collection) {
-        return this._queueRequest(async () => {
-            const db = await this._connectionPromise;
-            const collections = await db.listCollections({ name: collection }).toArray();
-            if (collections.length === 0) {
-                await db.createCollection(collection);
-            }
-        });
-    }
     async insert(collection, data) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
-            const db = await this._connectionPromise;
-            const result = await db.collection(collection).insertOne(data);
-            return result.insertedId;
-        });
-    }
-    async bulkInsert(collection, dataArray) {
-        return this._queueRequest(async () => {
-            if (!Array.isArray(dataArray) || dataArray.length === 0)
-                return 0;
-            await this.ensureCollection(collection);
+        await this.runHooks('beforeInsert', collection, data);
+        return this._execute('insert', collection, async () => {
             const db = await this._connectionPromise;
-            const result = await db.collection(collection).insertMany(dataArray);
-            return result.insertedCount;
+            const res = await db.collection(collection).insertOne(data);
+            const finalData = { _id: res.insertedId, ...data };
+            await this.runHooks('afterInsert', collection, finalData);
+            return res.insertedId;
         });
     }
     async update(collection, data, where) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+        await this.runHooks('beforeUpdate', collection, { data, where });
+        return this._execute('update', collection, async () => {
             const db = await this._connectionPromise;
-            const result = await db.collection(collection).updateMany(where, { $set: data });
-            return Number(result.modifiedCount);
+            const res = await db.collection(collection).updateMany(where, { $set: data });
+            return Number(res.modifiedCount);
         });
     }
     async delete(collection, where) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+        await this.runHooks('beforeDelete', collection, where);
+        return this._execute('delete', collection, async () => {
             const db = await this._connectionPromise;
-            const result = await db.collection(collection).deleteMany(where);
-            return result.deletedCount;
+            const res = await db.collection(collection).deleteMany(where);
+            return res.deletedCount;
         });
     }
     async select(collection, where = {}) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+        return this._execute('select', collection, async () => {
             const db = await this._connectionPromise;
-            const results = await db.collection(collection).find(where).toArray();
-            return results;
+            return await db.collection(collection).find(where).toArray();
         });
     }
     async selectOne(collection, where = {}) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+        return this._execute('selectOne', collection, async () => {
             const db = await this._connectionPromise;
-            const result = await db.collection(collection).findOne(where);
-            return result;
+            return await db.collection(collection).findOne(where);
         });
     }
     async set(collection, data, where) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
-            const db = await this._connectionPromise;
-            const existing = await db.collection(collection).findOne(where);
-            if (!existing) {
-                const result = await db.collection(collection).insertOne({ ...where, ...data });
-                return result.insertedId;
-            }
-            else {
-                const result = await db.collection(collection).updateOne(where, { $set: data });
-                return result.modifiedCount;
-            }
-        });
+        const ex = await this.selectOne(collection, where);
+        return ex ? this.update(collection, data, where) : this.insert(collection, { ...where, ...data });
     }
-    async increment(collection, increments, where = {}) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+    async bulkInsert(collection, dataArray) {
+        return this._execute('bulkInsert', collection, async () => {
+            if (!dataArray.length)
+                return 0;
             const db = await this._connectionPromise;
-            const result = await db.collection(collection).updateMany(where, { $inc: increments });
-            return Number(result.modifiedCount);
+            const res = await db.collection(collection).insertMany(dataArray);
+            return res.insertedCount;
         });
     }
-    async decrement(collection, decrements, where = {}) {
-        return this._queueRequest(async () => {
-            await this.ensureCollection(collection);
+    async increment(collection, incs, where = {}) {
+        return this._execute('increment', collection, async () => {
             const db = await this._connectionPromise;
-            const negativeIncrements = {};
-            for (const [key, value] of Object.entries(decrements)) {
-                negativeIncrements[key] = -value;
-            }
-            const result = await db.collection(collection).updateMany(where, { $inc: negativeIncrements });
-            return Number(result.modifiedCount);
+            const res = await db.collection(collection).updateMany(where, { $inc: incs });
+            return Number(res.modifiedCount);
         });
     }
-    async close() {
-        await this.client.close();
+    async decrement(collection, decs, where = {}) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(collection, incs, where);
     }
+    async close() { await this.client.close(); }
 }
 exports.MongoDBDatabase = MongoDBDatabase;
 exports.default = MongoDBDatabase;

package/dist/database/mysql.d.ts

@@ -7,25 +7,23 @@ export declare class MySQLDatabase extends IDatabase {
     private _connected;
     private _connectionPromise;
     constructor(config: MySQLConfig);
-    private _getColumnType;
-    private _getBestColumnType;
-    private _ensureMissingColumns;
-    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>;
     select<T = any>(table: string, where?: Record<string, any> | null): Promise<T[]>;
-    set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
     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, 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;
-    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>;
     private _buildWhereClause;
 }
 export default MySQLDatabase;