@onurege3467/zerohelper 9.2.0 → 10.0.0

package/README.md

@@ -75,7 +75,7 @@ import { database } from '@onurege3467/zerohelper';
 const db = database.createDatabase({
   adapter: 'zpack',
   config: {
-    filePath: './data.zpack',
+    path: './data.zpack',
     indexFields: { 'users': ['email'] }, // Intelligent autocomplete for ZPack
     autoFlush: true
   }
@@ -136,7 +136,7 @@ await db.decrement('inventory', { stock: 1 }, { sku: 'PRO-123' });
 ```typescript
 const zpack = database.createDatabase({
   adapter: 'zpack',
-  config: { filePath: './storage/engine.zpack', autoFlush: true }
+  config: { path: './storage/engine.zpack', autoFlush: true }
 });
 ```
 
@@ -151,7 +151,7 @@ The **world's first native TOON database**. It stores data in a YAML-like compac
 const toonDb = database.createDatabase({
   adapter: 'toon',
   config: {
-    filePath: './data.toon',
+    path: './data.toon',
     saveInterval: 1000 // Debounced disk write for high performance
   }
 });

package/dist/database/IDatabase.d.ts

@@ -1,12 +1,12 @@
 export type HookType = 'beforeInsert' | 'afterInsert' | 'beforeUpdate' | 'afterUpdate' | 'beforeDelete' | 'afterDelete';
 export type HookFunction = (table: string, data: any) => Promise<void> | void;
 /**
- * Tüm veritabanı adaptörlerinin uyması gereken ortak arayüzü tanımlar.
+ * Defines the common interface that all database adapters must implement.
  */
 export declare abstract class IDatabase {
     protected hooks: Record<HookType, HookFunction[]>;
     /**
-     * Bir lifecycle hook kaydeder.
+     * Registers a lifecycle hook.
      */
     on(hook: HookType, fn: HookFunction): void;
     protected runHooks(hook: HookType, table: string, data: any): Promise<void>;
@@ -28,43 +28,43 @@ export declare abstract class IDatabase {
     };
     protected recordMetric(operation: string, table: string, duration: number): void;
     /**
-     * Belirtilen koşullara göre birden çok kayıt seçer.
+     * Selects multiple records based on the specified conditions.
      */
     abstract select<T = any>(table: string, where?: Record<string, any> | null): Promise<T[]>;
     /**
-     * Belirtilen koşullara göre tek bir kayıt seçer.
+     * Selects a single record based on the specified conditions.
      */
     abstract selectOne<T = any>(table: string, where?: Record<string, any> | null): Promise<T | null>;
     /**
-     * Yeni bir kayıt ekler.
+     * Inserts a new record.
      */
     abstract insert(table: string, data: Record<string, any>): Promise<number | string | any>;
     /**
-     * Belirtilen koşullara uyan kayıtları günceller.
+     * Updates records matching the specified conditions.
      */
     abstract update(table: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
     /**
-     * Bir kaydı günceller veya yoksa yeni bir kayıt olarak ekler (Upsert).
+     * Updates a record or inserts it as a new record if it doesn't exist (Upsert).
      */
     abstract set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
     /**
-     * Belirtilen koşullara uyan kayıtları siler.
+     * Deletes records matching the specified conditions.
      */
     abstract delete(table: string, where: Record<string, any>): Promise<number>;
     /**
-     * Birden çok kaydı toplu olarak ekler.
+     * Inserts multiple records in bulk.
      */
     abstract bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
     /**
-     * Numerik alanları artırır (increment).
+     * Increments numeric fields.
      */
     abstract increment(table: string, increments: Record<string, number>, where: Record<string, any>): Promise<number>;
     /**
-     * Numerik alanları azaltır (decrement).
+     * Decrements numeric fields.
      */
     abstract decrement(table: string, decrements: Record<string, number>, where: Record<string, any>): Promise<number>;
     /**
-     * Veritabanı bağlantısını güvenli bir şekilde sonlandırır.
+     * Safely closes the database connection.
      */
     abstract close(): Promise<void>;
 }

package/dist/database/IDatabase.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.IDatabase = void 0;
 const telemetry_1 = require("./telemetry");
 /**
- * Tüm veritabanı adaptörlerinin uyması gereken ortak arayüzü tanımlar.
+ * Defines the common interface that all database adapters must implement.
  */
 class IDatabase {
     constructor() {
@@ -17,7 +17,7 @@ class IDatabase {
         };
     }
     /**
-     * Bir lifecycle hook kaydeder.
+     * Registers a lifecycle hook.
      */
     on(hook, fn) {
         if (this.hooks[hook]) {

package/dist/database/index.d.ts

@@ -8,5 +8,5 @@ import { DataSeeder } from './seeder';
  * Belirtilen adaptör tipine göre bir veritabanı örneği oluşturur ve döndürür.
  */
 export declare function createDatabase(options: DatabaseOptions): IDatabase;
-export { MigrationManager, ZPackDatabase, ZPackAdapter, DataSeeder, ToonDatabase };
+export { IDatabase, MigrationManager, ZPackDatabase, ZPackAdapter, DataSeeder, ToonDatabase };
 export default createDatabase;

package/dist/database/index.js

@@ -36,8 +36,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToonDatabase = exports.DataSeeder = exports.ZPackAdapter = exports.ZPackDatabase = exports.MigrationManager = void 0;
+exports.ToonDatabase = exports.DataSeeder = exports.ZPackAdapter = exports.ZPackDatabase = exports.MigrationManager = exports.IDatabase = void 0;
 exports.createDatabase = createDatabase;
+const IDatabase_1 = require("./IDatabase");
+Object.defineProperty(exports, "IDatabase", { enumerable: true, get: function () { return IDatabase_1.IDatabase; } });
 const mysql_1 = __importDefault(require("./mysql"));
 const sqlite_1 = __importDefault(require("./sqlite"));
 const mongodb_1 = __importDefault(require("./mongodb"));

package/dist/database/mongodb.d.ts

@@ -1,16 +1,16 @@
 import { IDatabase } from './IDatabase';
 import { MongoDBConfig } from './types';
 export declare class MongoDBDatabase extends IDatabase {
-    private config;
     private client;
     private db;
+    private _isConnected;
     private _queue;
-    private _connected;
-    private _connectionPromise;
     constructor(config: MongoDBConfig);
+    private _connect;
+    private _flushQueue;
+    private _flushQueueWithError;
     private _execute;
-    private _processQueue;
-    insert(collection: string, data: any): Promise<any>;
+    insert(collection: string, data: any): Promise<string>;
     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[]>;
@@ -20,5 +20,7 @@ export declare class MongoDBDatabase extends IDatabase {
     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>;
+    private _formatQuery;
+    private _serialize;
 }
 export default MongoDBDatabase;

package/dist/database/mongodb.js

@@ -7,85 +7,90 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
         this.db = null;
+        this._isConnected = false;
         this._queue = [];
-        this._connected = false;
-        this.config = config;
-        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 || 'test');
-                this._connected = true;
-                resolve(this.db);
-                this._processQueue();
-            }
-            catch (error) {
-                reject(error);
-            }
+        const uri = config.url || (config.uri ?? `mongodb://${config.host || 'localhost'}:${config.port || 27017}`);
+        this.client = new mongodb_1.MongoClient(uri, {
+            serverSelectionTimeoutMS: 5000, // Fail fast if no server
+            connectTimeoutMS: 5000
         });
+        this._connect(config.database || 'test');
+    }
+    async _connect(dbName) {
+        try {
+            await this.client.connect();
+            this.db = this.client.db(dbName);
+            this._isConnected = true;
+            this._flushQueue();
+        }
+        catch (error) {
+            this._flushQueueWithError(error);
+            // Opsiyonel: Yeniden bağlanma mantığı buraya eklenebilir,
+            // ama testler için fail-fast daha iyidir.
+        }
     }
-    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)
-            return;
+    _flushQueue() {
         while (this._queue.length > 0) {
             const item = this._queue.shift();
             if (item) {
-                try {
-                    item.resolve(await item.operation());
-                }
-                catch (error) {
-                    item.reject(error);
-                }
+                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(fn) {
+        if (this._isConnected) {
+            return fn();
+        }
+        return new Promise((resolve, reject) => {
+            this._queue.push({ operation: fn, resolve, reject });
+        });
+    }
+    // --- Implementations ---
     async insert(collection, data) {
         await this.runHooks('beforeInsert', collection, data);
-        return this._execute('insert', collection, async () => {
-            const db = await this._connectionPromise;
-            const res = await db.collection(collection).insertOne(data);
-            const finalData = { _id: res.insertedId, ...data };
+        return this._execute(async () => {
+            const res = await this.db.collection(collection).insertOne(data);
+            const newId = res.insertedId.toString();
+            const finalData = { _id: newId, ...data };
             await this.runHooks('afterInsert', collection, finalData);
-            return res.insertedId;
+            return newId;
         });
     }
     async update(collection, data, where) {
         await this.runHooks('beforeUpdate', collection, { data, where });
-        return this._execute('update', collection, async () => {
-            const db = await this._connectionPromise;
-            const res = await db.collection(collection).updateMany(where, { $set: data });
-            return Number(res.modifiedCount);
+        const formattedWhere = this._formatQuery(where);
+        return this._execute(async () => {
+            const res = await this.db.collection(collection).updateMany(formattedWhere, { $set: data });
+            return res.modifiedCount;
         });
     }
     async delete(collection, where) {
         await this.runHooks('beforeDelete', collection, where);
-        return this._execute('delete', collection, async () => {
-            const db = await this._connectionPromise;
-            const res = await db.collection(collection).deleteMany(where);
+        const formattedWhere = this._formatQuery(where);
+        return this._execute(async () => {
+            const res = await this.db.collection(collection).deleteMany(formattedWhere);
             return res.deletedCount;
         });
     }
     async select(collection, where = {}) {
-        return this._execute('select', collection, async () => {
-            const db = await this._connectionPromise;
-            return await db.collection(collection).find(where).toArray();
+        const formattedWhere = this._formatQuery(where);
+        return this._execute(async () => {
+            const docs = await this.db.collection(collection).find(formattedWhere).toArray();
+            return docs.map(doc => this._serialize(doc));
         });
     }
     async selectOne(collection, where = {}) {
-        return this._execute('selectOne', collection, async () => {
-            const db = await this._connectionPromise;
-            return await db.collection(collection).findOne(where);
+        const formattedWhere = this._formatQuery(where);
+        return this._execute(async () => {
+            const doc = await this.db.collection(collection).findOne(formattedWhere);
+            return doc ? this._serialize(doc) : null;
         });
     }
     async set(collection, data, where) {
@@ -93,19 +98,18 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
         return ex ? this.update(collection, data, where) : this.insert(collection, { ...where, ...data });
     }
     async bulkInsert(collection, dataArray) {
-        return this._execute('bulkInsert', collection, async () => {
-            if (!dataArray.length)
-                return 0;
-            const db = await this._connectionPromise;
-            const res = await db.collection(collection).insertMany(dataArray);
+        if (!dataArray.length)
+            return 0;
+        return this._execute(async () => {
+            const res = await this.db.collection(collection).insertMany(dataArray);
             return res.insertedCount;
         });
     }
     async increment(collection, incs, where = {}) {
-        return this._execute('increment', collection, async () => {
-            const db = await this._connectionPromise;
-            const res = await db.collection(collection).updateMany(where, { $inc: incs });
-            return Number(res.modifiedCount);
+        const formattedWhere = this._formatQuery(where);
+        return this._execute(async () => {
+            const res = await this.db.collection(collection).updateMany(formattedWhere, { $inc: incs });
+            return res.modifiedCount;
         });
     }
     async decrement(collection, decs, where = {}) {
@@ -114,7 +118,28 @@ class MongoDBDatabase extends IDatabase_1.IDatabase {
             incs[k] = -decs[k];
         return this.increment(collection, incs, where);
     }
-    async close() { await this.client.close(); }
+    async close() {
+        if (this.client)
+            await this.client.close();
+        this._isConnected = false;
+    }
+    // Helper: _id handling and query formatting
+    _formatQuery(where) {
+        if (!where)
+            return {};
+        const query = { ...where };
+        if (query._id && typeof query._id === 'string' && mongodb_1.ObjectId.isValid(query._id)) {
+            query._id = new mongodb_1.ObjectId(query._id);
+        }
+        return query;
+    }
+    _serialize(doc) {
+        if (!doc)
+            return doc;
+        const { _id, ...rest } = doc;
+        // _id'yi string olarak döndür, ZeroHelper standardı
+        return { _id: _id.toString(), ...rest };
+    }
 }
 exports.MongoDBDatabase = MongoDBDatabase;
 exports.default = MongoDBDatabase;

package/dist/database/mysql.js

@@ -32,14 +32,18 @@ ${config.database}
                     password: config.password,
                     database: config.database,
                     waitForConnections: true,
-                    connectionLimit: config.poolSize || 10,
+                    connectionLimit: config.poolSize || 15, // Balanced limit
                     queueLimit: 0,
+                    enableKeepAlive: true,
+                    keepAliveInitialDelay: 10000
                 });
                 this._connected = true;
                 resolve(this.pool);
                 this._processQueue();
             }
             catch (error) {
+                this._queue.forEach(q => q.reject(error));
+                this._queue = [];
                 reject(error);
             }
         });
@@ -72,8 +76,21 @@ ${config.database}
     }
     async query(sql, params = []) {
         const pool = await this._connectionPromise;
-        const [rows] = await pool.execute(sql, params);
-        return rows;
+        let retries = 3;
+        while (retries > 0) {
+            try {
+                const [rows] = await pool.execute(sql, params);
+                return rows;
+            }
+            catch (error) {
+                if ((error.code === 'ER_CON_COUNT_ERROR' || error.message.includes('Too many connections')) && retries > 1) {
+                    retries--;
+                    await new Promise(r => setTimeout(r, 1000)); // Wait 1s and retry
+                    continue;
+                }
+                throw error;
+            }
+        }
     }
     async _ensureMissingColumns(table, data) {
         const existingColumns = await this.query(`DESCRIBE
@@ -144,11 +161,12 @@ ${k}
         return this._execute('delete', table, async () => {
             await this.ensureTable(table, where);
             const keys = Object.keys(where);
+            const whereClause = keys.length > 0 ? `WHERE ${keys.map(k => `
+${k}
+ = ?`).join(" AND ")}` : '';
             const sql = `DELETE FROM
 ${table}
- WHERE ${keys.map(k => `
-${k}
- = ?`).join(" AND ")}`;
+ ${whereClause}`;
             const result = await this.query(sql, Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
             return result.affectedRows;
         });

package/dist/database/pg.js

@@ -27,6 +27,8 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
                 this._processQueue();
             }
             catch (error) {
+                this._queue.forEach(q => q.reject(error));
+                this._queue = [];
                 reject(error);
             }
         });
@@ -61,7 +63,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
     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}" TEXT`);
+            const defs = Object.keys(data).map(k => `"${k}" ${this._getColumnType(data[k])}`);
             await this.query(`CREATE TABLE "${table}" ("_id" SERIAL PRIMARY KEY ${defs.length ? ', ' + defs.join(",") : ''})`);
         }
         else {
@@ -69,7 +71,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
             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`);
+                    await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${this._getColumnType(data[key])}`);
                 }
             }
         }
@@ -90,8 +92,9 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         await this.runHooks('beforeUpdate', table, { data, where });
         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 { whereClause, values: whereValues } = this._buildWhereClause(where);
+            const dataKeys = Object.keys(data);
+            const set = dataKeys.map((k, i) => `"${k}" = $${i + 1}`).join(",");
+            const { whereClause, values: whereValues } = this._buildWhereClause(where, dataKeys.length);
             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)), ...whereValues]);
@@ -116,8 +119,13 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
             const rows = await this.query(`SELECT * FROM "${table}" ${whereClause}`, values);
             return rows.map((r) => {
                 const nr = {};
-                for (const k in r)
+                for (const k in r) {
+                    // Postgres returns numbers as strings for safety sometimes,
+                    // but since we used correct types now, driver might handle it better.
+                    // If not, we can cast if it looks like a number.
+                    // For now, let's trust the driver + schema.
                     nr[k] = r[k];
+                }
                 return nr;
             });
         });
@@ -140,8 +148,9 @@ class PostgreSQLDatabase 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, i) => `"${f}" = "${f}" + $${i + 1}`).join(',');
-            const { whereClause, values } = this._buildWhereClause(where);
+            const incKeys = Object.keys(incs);
+            const set = incKeys.map((f, i) => `"${f}" = "${f}" + $${i + 1}`).join(',');
+            const { whereClause, values } = this._buildWhereClause(where, incKeys.length);
             const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
             const pool = await this._connectionPromise;
             const res = await pool.query(sql, [...Object.values(incs), ...values]);
@@ -174,7 +183,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
             return v.toISOString();
         return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
     }
-    _buildWhereClause(where) {
+    _buildWhereClause(where, offset = 0) {
         if (!where)
             return { whereClause: '', values: [] };
         const safeWhere = where;
@@ -182,7 +191,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         if (!keys.length)
             return { whereClause: '', values: [] };
         return {
-            whereClause: 'WHERE ' + keys.map((k, i) => `"${k}" = $${i + 1}`).join(' AND '),
+            whereClause: 'WHERE ' + keys.map((k, i) => `"${k}" = $${i + 1 + offset}`).join(' AND '),
             values: keys.map(k => this._serializeValue(safeWhere[k]))
         };
     }

package/dist/database/redis.d.ts

@@ -1,14 +1,17 @@
 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;
+    private _queue;
+    private _isReady;
+    private _connectionPromise;
     constructor(config: RedisConfig);
+    private _ensureConnection;
+    private _flushQueue;
+    private _flushQueueWithError;
     private _execute;
-    connect(): Promise<RedisClientType>;
     private _getKey;
     private _getTableKey;
     select<T = any>(table: string, where?: Record<string, any>): Promise<T[]>;
@@ -18,6 +21,9 @@ export declare class RedisDatabase 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>;
+    /**
+     * Atomic Increment using Lua for Redis
+     */
     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>;