@onurege3467/zerohelper 9.2.0 → 10.0.0

package/dist/database/redis.js

@@ -7,49 +7,74 @@ class RedisDatabase extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
         this.client = null;
-        this.isConnecting = false;
+        this._queue = [];
+        this._isReady = false;
+        this._connectionPromise = null;
         this.config = config;
         this.keyPrefix = config.keyPrefix || 'app:';
+        this._ensureConnection();
     }
-    async _execute(op, table, fn) {
-        const start = Date.now();
-        const res = await fn();
-        this.recordMetric(op, table, Date.now() - start);
-        return res;
+    async _ensureConnection() {
+        if (this._connectionPromise)
+            return this._connectionPromise;
+        this._connectionPromise = (async () => {
+            try {
+                this.client = (0, redis_1.createClient)({
+                    url: this.config.url,
+                    socket: {
+                        host: this.config.host || '127.0.0.1',
+                        port: this.config.port || 6379,
+                        connectTimeout: 5000,
+                        reconnectStrategy: false
+                    },
+                    password: this.config.password,
+                    database: Number(this.config.database) || 0,
+                });
+                await this.client.connect();
+                this._isReady = true;
+                this._flushQueue();
+            }
+            catch (error) {
+                this._flushQueueWithError(error);
+            }
+        })();
+        return this._connectionPromise;
     }
-    ;
-    async connect() {
-        if (this.client && this.client.isReady)
-            return this.client;
-        if (this.isConnecting) {
-            while (this.isConnecting)
-                await new Promise(r => setTimeout(r, 100));
-            return this.client;
+    _flushQueue() {
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (item)
+                item.operation().then(item.resolve).catch(item.reject);
         }
-        this.isConnecting = true;
-        try {
-            this.client = (0, redis_1.createClient)({
-                url: this.config.url,
-                socket: { host: this.config.host || '127.0.0.1', port: this.config.port || 6379 },
-                password: this.config.password,
-                database: Number(this.config.database) || 0,
-            });
-            await this.client.connect();
-            return this.client;
-        }
-        finally {
-            this.isConnecting = false;
+    }
+    _flushQueueWithError(error) {
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (item)
+                item.reject(error);
         }
     }
+    async _execute(op, table, fn) {
+        const operation = async () => {
+            const start = Date.now();
+            const res = await fn();
+            this.recordMetric(op, table, Date.now() - start);
+            return res;
+        };
+        if (this._isReady)
+            return operation();
+        return new Promise((resolve, reject) => {
+            this._queue.push({ operation, resolve, reject });
+        });
+    }
     _getKey(table, id) { return `${this.keyPrefix}${table}:${id}`; }
     _getTableKey(table) { return `${this.keyPrefix}${table}:*`; }
     async select(table, where = {}) {
         return this._execute('select', table, async () => {
-            const client = await this.connect();
-            const keys = await client.keys(this._getTableKey(table));
+            const keys = await this.client.keys(this._getTableKey(table));
             if (!keys.length)
                 return [];
-            const vals = await client.mGet(keys);
+            const vals = await this.client.mGet(keys);
             return vals.map(v => v ? JSON.parse(v) : null).filter(Boolean)
                 .filter(item => Object.entries(where).every(([k, v]) => String(item[k]) === String(v)));
         });
@@ -61,12 +86,11 @@ class RedisDatabase extends IDatabase_1.IDatabase {
     async insert(table, data) {
         await this.runHooks('beforeInsert', table, data);
         return this._execute('insert', table, async () => {
-            const client = await this.connect();
             const d = { ...data };
             if (!d._id && !d.id)
                 d._id = Date.now().toString() + Math.random().toString(36).slice(2, 9);
             const id = String(d._id || d.id);
-            await client.set(this._getKey(table, id), JSON.stringify(d));
+            await this.client.set(this._getKey(table, id), JSON.stringify(d));
             await this.runHooks('afterInsert', table, d);
             return d._id || d.id;
         });
@@ -75,10 +99,9 @@ class RedisDatabase extends IDatabase_1.IDatabase {
         await this.runHooks('beforeUpdate', table, { data, where });
         return this._execute('update', table, async () => {
             const existing = await this.select(table, where);
-            const client = await this.connect();
             for (const item of existing) {
                 const merged = { ...item, ...data };
-                await client.set(this._getKey(table, item._id || item.id), JSON.stringify(merged));
+                await this.client.set(this._getKey(table, item._id || item.id), JSON.stringify(merged));
             }
             return existing.length;
         });
@@ -87,10 +110,9 @@ class RedisDatabase extends IDatabase_1.IDatabase {
         await this.runHooks('beforeDelete', table, where);
         return this._execute('delete', table, async () => {
             const existing = await this.select(table, where);
-            const client = await this.connect();
             if (existing.length) {
                 const keys = existing.map(i => this._getKey(table, String(i._id || i.id)));
-                await client.del(keys);
+                await this.client.del(keys);
             }
             return existing.length;
         });
@@ -104,14 +126,33 @@ class RedisDatabase extends IDatabase_1.IDatabase {
             await this.insert(table, d);
         return dataArray.length;
     }
+    /**
+     * Atomic Increment using Lua for Redis
+     */
     async increment(table, incs, where = {}) {
         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));
+                const id = String(r._id || r.id);
+                const key = this._getKey(table, id);
+                // Redis'te JSON sakladığımız için her alanı ayrı artırmak yerine 
+                // objeyi okuyup, güncelleyip tekrar yazmalıyız. 
+                // Bunu Lua script ile Redis tarafında atomik yapalım.
+                const lua = `
+            local val = redis.call('get', KEYS[1])
+            if not val then return 0 end
+            local data = cjson.decode(val)
+            local incs = cjson.decode(ARGV[1])
+            for k, v in pairs(incs) do
+                data[k] = (tonumber(data[k]) or 0) + v
+            end
+            redis.call('set', KEYS[1], cjson.encode(data))
+            return 1
+        `;
+                await this.client.eval(lua, {
+                    keys: [key],
+                    arguments: [JSON.stringify(incs)]
+                });
             }
             return recs.length;
         });
@@ -122,10 +163,14 @@ class RedisDatabase extends IDatabase_1.IDatabase {
             incs[k] = -decs[k];
         return this.increment(table, incs, where);
     }
-    async close() { if (this.client) {
-        await this.client.quit();
-        this.client = null;
-    } }
+    async close() {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+            this._isReady = false;
+            this._connectionPromise = null;
+        }
+    }
 }
 exports.RedisDatabase = RedisDatabase;
 exports.default = RedisDatabase;

package/dist/database/sqlite.d.ts

@@ -2,7 +2,11 @@ import { IDatabase } from './IDatabase';
 import { SQLiteConfig } from './types';
 export declare class SQLiteDatabase extends IDatabase {
     private db;
+    private _queue;
+    private _isOpen;
     constructor(config: SQLiteConfig);
+    private _flushQueue;
+    private _flushQueueWithError;
     private _execute;
     query(sql: string, params?: any[]): Promise<any>;
     ensureTable(table: string, data?: any): Promise<void>;

package/dist/database/sqlite.js

@@ -11,20 +11,52 @@ const path_1 = __importDefault(require("path"));
 class SQLiteDatabase extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
+        this._queue = [];
+        this._isOpen = false;
         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.path);
+        // SQLite open is technically async but the object is returned immediately.
+        // However, we simulate a queue to serialize operations strictly.
+        this.db = new sqlite3_1.default.Database(config.path, (err) => {
+            if (err) {
+                this._flushQueueWithError(err);
+            }
+            else {
+                this._isOpen = true;
+                this._flushQueue();
+            }
+        });
+    }
+    _flushQueue() {
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (item)
+                item.operation().then(item.resolve).catch(item.reject);
+        }
+    }
+    _flushQueueWithError(error) {
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (item)
+                item.reject(error);
+        }
     }
     async _execute(op, table, fn) {
-        const start = Date.now();
-        const res = await fn();
-        this.recordMetric(op, table, Date.now() - start);
-        return res;
+        const operation = async () => {
+            const start = Date.now();
+            const res = await fn();
+            this.recordMetric(op, table, Date.now() - start);
+            return res;
+        };
+        if (this._isOpen)
+            return operation();
+        return new Promise((resolve, reject) => {
+            this._queue.push({ operation, resolve, reject });
+        });
     }
-    ;
     async query(sql, params = []) {
         return new Promise((resolve, reject) => {
             const s = sql.trim().toUpperCase();
@@ -115,9 +147,23 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
     async bulkInsert(table, dataArray) {
         if (!dataArray.length)
             return 0;
-        for (const d of dataArray)
-            await this.insert(table, d);
-        return dataArray.length;
+        return this._execute('bulkInsert', table, async () => {
+            await this.ensureTable(table, dataArray[0]);
+            await this.query('BEGIN TRANSACTION');
+            try {
+                const keys = Object.keys(dataArray[0]);
+                const sql = `INSERT INTO "${table}" (${keys.map(k => `"${k}"`).join(',')}) VALUES (${keys.map(() => '?').join(',')})`;
+                for (const d of dataArray) {
+                    await this.query(sql, Object.values(d).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
+                }
+                await this.query('COMMIT');
+                return dataArray.length;
+            }
+            catch (error) {
+                await this.query('ROLLBACK');
+                throw error;
+            }
+        });
     }
     async increment(table, incs, where) {
         return this._execute('increment', table, async () => {
@@ -135,7 +181,14 @@ class SQLiteDatabase extends IDatabase_1.IDatabase {
             incs[k] = -decs[k];
         return this.increment(table, incs, where);
     }
-    async close() { return new Promise((resolve, reject) => this.db.close(err => err ? reject(err) : resolve())); }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close(err => {
+                this._isOpen = false;
+                err ? reject(err) : resolve();
+            });
+        });
+    }
     _serializeValue(v) {
         if (v instanceof Date)
             return v.toISOString().slice(0, 19).replace('T', ' ');

package/dist/database/toon.d.ts

@@ -12,6 +12,7 @@ export declare class ToonDatabase extends IDatabase {
     constructor(config: ToonConfig);
     private _execute;
     private _load;
+    private _getTable;
     private _queueRequest;
     private _processQueue;
     private _scheduleSave;

package/dist/database/toon.js

@@ -41,12 +41,29 @@ class ToonDatabase extends IDatabase_1.IDatabase {
                 return;
             }
             const content = await promises_1.default.readFile(this.filePath, 'utf-8');
-            this.db = (0, toon_1.parse)(content);
+            const parsed = (0, toon_1.parse)(content);
+            // ✅ Parse sonucunu doğrula
+            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+                this.db = {};
+            }
+            else {
+                this.db = {};
+                // Her tablonun array olduğundan emin ol
+                for (const [key, value] of Object.entries(parsed)) {
+                    this.db[key] = Array.isArray(value) ? value : [];
+                }
+            }
         }
         catch (error) {
+            console.error("ToonDB load error:", error);
             this.db = {};
         }
     }
+    _getTable(table) {
+        // ✅ Her zaman array döndüren yardımcı fonksiyon
+        const data = this.db[table];
+        return Array.isArray(data) ? data : [];
+    }
     _queueRequest(operation) {
         return new Promise((resolve, reject) => {
             this.writeQueue.push({ operation, resolve, reject });
@@ -104,8 +121,11 @@ class ToonDatabase extends IDatabase_1.IDatabase {
     }
     async ensureTable(table) {
         await this.initPromise;
-        if (!this.db[table]) {
-            return this._queueRequest(() => { this.db[table] = []; });
+        // ✅ Tablonun array olduğundan emin ol
+        if (!Array.isArray(this.db[table])) {
+            return this._queueRequest(() => {
+                this.db[table] = [];
+            });
         }
     }
     async insert(table, data) {
@@ -113,7 +133,8 @@ class ToonDatabase extends IDatabase_1.IDatabase {
         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 tableData = this._getTable(table);
+                const maxId = tableData.reduce((max, row) => (row._id > max ? row._id : max), 0);
                 const newId = maxId + 1;
                 const newRow = { _id: newId, ...data };
                 this.db[table].push(newRow);
@@ -128,7 +149,8 @@ class ToonDatabase extends IDatabase_1.IDatabase {
             await this.ensureTable(table);
             return this._queueRequest(() => {
                 let affected = 0;
-                this.db[table].forEach(row => {
+                const tableData = this._getTable(table);
+                tableData.forEach(row => {
                     if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
                         Object.assign(row, data);
                         affected++;
@@ -144,8 +166,9 @@ class ToonDatabase extends IDatabase_1.IDatabase {
         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 tableData = this._getTable(table);
+                const initial = tableData.length;
+                this.db[table] = tableData.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,9 +178,11 @@ class ToonDatabase extends IDatabase_1.IDatabase {
     async select(table, where = null) {
         return this._execute('select', table, async () => {
             await this.initPromise;
+            // ✅ _getTable kullanarak array garantisi
+            const tableData = this._getTable(table);
             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] || []);
+                ? tableData.filter(row => Object.keys(where).every(k => String(row[k]) === String(where[k])))
+                : tableData;
             return JSON.parse(JSON.stringify(results));
         });
     }
@@ -166,6 +191,7 @@ class ToonDatabase extends IDatabase_1.IDatabase {
         return res[0] || null;
     }
     async set(table, data, where) {
+        await this.ensureTable(table); // ✅ Önce tabloyu garantile
         const ex = await this.selectOne(table, where);
         return ex ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
@@ -175,8 +201,12 @@ class ToonDatabase extends IDatabase_1.IDatabase {
                 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 }); });
+                const tableData = this._getTable(table);
+                let maxId = tableData.reduce((max, row) => (row._id > max ? row._id : max), 0);
+                dataArray.forEach(data => {
+                    maxId++;
+                    this.db[table].push({ _id: maxId, ...data });
+                });
                 return dataArray.length;
             });
         });
@@ -186,7 +216,8 @@ class ToonDatabase extends IDatabase_1.IDatabase {
             await this.ensureTable(table);
             return this._queueRequest(() => {
                 let affected = 0;
-                this.db[table].forEach(row => {
+                const tableData = this._getTable(table);
+                tableData.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;

package/dist/database/types.d.ts

@@ -8,6 +8,7 @@ export interface NetworkConfig extends BaseConfig {
     password?: string;
     database?: string;
     url?: string;
+    uri?: string;
     poolSize?: number;
 }
 export interface FileConfig extends BaseConfig {

package/dist/database/zpack.d.ts

@@ -1,5 +1,8 @@
 import { IDatabase } from './IDatabase';
 import { ZPackConfig } from './types';
+/**
+ * ZPackDatabase: Low-level Binary Storage
+ */
 export declare class ZPackDatabase {
     filePath: string;
     private fd;
@@ -36,6 +39,9 @@ export declare class ZPackDatabase {
     private _tryLoadIndexFromFooter;
     private _scanAndRebuildIndex;
 }
+/**
+ * ZPackAdapter: IDatabase Implementation
+ */
 export declare class ZPackAdapter extends IDatabase {
     private db;
     private initPromise;
@@ -44,8 +50,12 @@ export declare class ZPackAdapter extends IDatabase {
     private rowCache;
     private secondary;
     private indexedFields;
+    private _isClosing;
+    private _executing;
     constructor(config: ZPackConfig);
     private _init;
+    private _execute;
+    private _rawSelect;
     ensureTable(table: string): Promise<void>;
     private _updateSecondaryIndex;
     private _coerce;