@onurege3467/zerohelper 7.0.0 → 7.2.0

package/database/cacheWrapper.js

@@ -1,120 +1,233 @@
+// cacheWrapper.js - Redis@4 ve Memory Cache Uyumlu
 const { LRUCache } = require('lru-cache');
+const { createClient } = require('redis');
 
 class CacheWrapper {
   constructor(databaseInstance, options = {}) {
     this.db = databaseInstance;
+    this.cacheType = options.type || 'memory'; // 'memory' or 'redis'
+    this.tableCaches = {};
+
+    if (this.cacheType === 'redis') {
+      this._initRedisCache(options);
+    } else {
+      this._initMemoryCache(options);
+    }
+  }
+
+  _initMemoryCache(options) {
     this.cache = new LRUCache({
-      max: options.max || 500, // Maximum number of items in cache
-      ttl: options.ttl || 1000 * 60 * 5, // Time to live in ms (5 minutes)
-      updateAgeOnGet: options.updateAgeOnGet !== undefined ? options.updateAgeOnGet : false, // Update item age on get
+      max: options.max || 500,
+      ttl: options.ttl || 1000 * 60 * 5,
+      updateAgeOnGet: options.updateAgeOnGet || false,
+    });
+    this.redisAvailable = false;
+    this.redisClient = null;
+  }
+
+  async _initRedisCache(options) {
+    const redisConfig = {
+      socket: {
+        host: options.host || '127.0.0.1',
+        port: options.port || 6379,
+        connectTimeout: options.connectTimeout || 5000,
+      },
+      password: options.password,
+      database: options.db || 0,
+    };
+
+    this.redisClient = createClient(redisConfig);
+    this.ttl = options.ttl || 300; // 5 dakika (saniye cinsinden)
+    this.keyPrefix = options.keyPrefix || 'db_cache:';
+    this.redisAvailable = false;
+
+    this.redisClient.on('error', (err) => {
+      console.warn('Redis Cache Error, memory cache fallback:', err.message);
+      this.redisAvailable = false;
+    });
+
+    this.redisClient.on('connect', () => {
+      console.log('Redis Cache Connected');
+    });
+
+    this.redisClient.on('ready', () => {
+      console.log('Redis Cache Ready');
+      this.redisAvailable = true;
     });
-    this.tableCaches = {}; // Cache for each table
+
+    this.redisClient.on('end', () => {
+      console.log('Redis Cache Disconnected');
+      this.redisAvailable = false;
+    });
+
+    try {
+      await Promise.race([
+        this.redisClient.connect(),
+                         new Promise((_, reject) =>
+                         setTimeout(() => reject(new Error('Redis connection timeout')), 5000)
+                         ),
+      ]);
+      this.redisAvailable = true;
+    } catch (error) {
+      console.warn('Redis bağlantısı başarısız, memory cache kullanılacak:', error.message);
+      this._initMemoryCache(options);
+      this.redisClient.removeAllListeners();
+      this.redisClient = null;
+      this.redisAvailable = false;
+    }
   }
 
   _getCache(table) {
+    if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+      return this.redisClient;
+    }
+
+    // Memory fallback
     if (!this.tableCaches[table]) {
       this.tableCaches[table] = new LRUCache({
-        max: this.cache.max,
-        ttl: this.cache.ttl,
-        updateAgeOnGet: this.cache.updateAgeOnGet,
+        max: this.cache ? this.cache.max : 500,
+        ttl: this.cache ? this.cache.ttl : 300000,
+        updateAgeOnGet: this.cache ? this.cache.updateAgeOnGet : false,
       });
     }
     return this.tableCaches[table];
   }
 
   _generateKey(table, where) {
-    return `${table}:${JSON.stringify(where || {})}`;
+    const key = `${table}:${JSON.stringify(where || {})}`;
+    return this.cacheType === 'redis' ? `${this.keyPrefix}${key}` : key;
   }
 
-  // Read operations
+  async _getCacheValue(cache, key) {
+    if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+      try {
+        const value = await cache.get(key);
+        return value ? JSON.parse(value) : null;
+      } catch (err) {
+        console.warn('Redis get error, memory fallback:', err.message);
+        this.redisAvailable = false;
+        return this._getCache(key.split(':')[1]).get(key);
+      }
+    } else {
+      return cache.get(key);
+    }
+  }
+
+  async _setCacheValue(cache, key, value) {
+    if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+      try {
+        await cache.setEx(key, this.ttl, JSON.stringify(value));
+      } catch (err) {
+        console.warn('Redis set error, memory fallback:', err.message);
+        this.redisAvailable = false;
+        this._getCache(key.split(':')[1]).set(key, value);
+      }
+    } else {
+      cache.set(key, value);
+    }
+  }
+
+  async _clearCache(table) {
+    const cache = this._getCache(table);
+    if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+      try {
+        const keys = await this.redisClient.keys(`${this.keyPrefix}${table}:*`);
+        if (keys.length) await this.redisClient.del(keys);
+      } catch (err) {
+        console.warn('Redis clear error, memory fallback:', err.message);
+        this.redisAvailable = false;
+        cache.clear();
+      }
+    } else {
+      cache.clear();
+    }
+  }
+
+  // Read
   async select(table, where) {
     const cache = this._getCache(table);
     const key = this._generateKey(table, where);
-    let data = cache.get(key);
-
-    if (data) {
-      // console.log(`Cache hit for select: ${key}`);
-      return data;
-    }
+    let data = await this._getCacheValue(cache, key);
+    if (data) return data;
 
-    // console.log(`Cache miss for select: ${key}`);
     data = await this.db.select(table, where);
-    cache.set(key, data);
+    await this._setCacheValue(cache, key, data);
     return data;
   }
 
   async selectOne(table, where) {
     const cache = this._getCache(table);
     const key = this._generateKey(table, where);
-    let data = cache.get(key);
+    let data = await this._getCacheValue(cache, key);
+    if (data) return data;
 
-    if (data) {
-      // console.log(`Cache hit for selectOne: ${key}`);
-      return data;
-    }
-
-    // console.log(`Cache miss for selectOne: ${key}`);
     data = await this.db.selectOne(table, where);
-    cache.set(key, data);
+    await this._setCacheValue(cache, key, data);
     return data;
   }
 
-  // Write operations (invalidate cache)
+  // Write (invalidate)
   async insert(table, data) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.insert(table, data);
   }
 
   async update(table, data, where) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.update(table, data, where);
   }
 
   async set(table, data, where) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.set(table, data, where);
   }
 
   async delete(table, where) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.delete(table, where);
   }
 
-  async bulkInsert(table, dataArray) {
-    this._getCache(table).clear();
-    return this.db.bulkInsert(table, dataArray);
-  }
-
   async deleteOne(table, where) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.deleteOne(table, where);
   }
 
   async updateOne(table, data, where) {
-    this._getCache(table).clear();
+    await this._clearCache(table);
     return this.db.updateOne(table, data, where);
   }
 
-  // Pass-through for other methods (e.g., close, ensureTable, query for MySQL/SQLite)
+  async bulkInsert(table, dataArray) {
+    await this._clearCache(table);
+    return this.db.bulkInsert(table, dataArray);
+  }
+
+  async clearAllCache() {
+    if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+      try {
+        const keys = await this.redisClient.keys(`${this.keyPrefix}*`);
+        if (keys.length) await this.redisClient.del(keys);
+      } catch (err) {
+        console.warn('Redis clearAll error, memory fallback:', err.message);
+        this.redisAvailable = false;
+      }
+    }
+    Object.values(this.tableCaches).forEach(c => c.clear());
+    if (this.cache) this.cache.clear();
+  }
+
   async close() {
-    // Clear all caches before closing
-    Object.values(this.tableCaches).forEach(cache => cache.clear());
-    this.cache.clear();
-    return this.db.close();
-  }
-
-  // Dynamically pass through any other methods not explicitly defined here
-  // This ensures compatibility with specific adapter methods (e.g., MySQL's connect, ping)
-  // Note: This is a simplified approach. A more robust solution might involve checking
-  // if the underlying db instance has the method before calling.
-  get(target, prop) {
-    if (typeof this[prop] !== 'undefined') {
-      return this[prop];
-    } else if (typeof this.db[prop] === 'function') {
-      return this.db[prop].bind(this.db);
-    } else {
-      return this.db[prop];
+    await this.clearAllCache();
+    if (this.cacheType === 'redis' && this.redisClient) {
+      try {
+        this.redisClient.removeAllListeners();
+        if (this.redisAvailable) await this.redisClient.quit();
+        else await this.redisClient.disconnect();
+      } catch {}
+      this.redisClient = null;
+      this.redisAvailable = false;
     }
+    return this.db.close ? this.db.close() : null;
   }
 }
 

package/database/index.js

@@ -1,9 +1,11 @@
+// database-factory.js
 const IDatabase = require('./IDatabase');
 const MySQLDatabase = require('./mysql');
 const SQLiteDatabase = require('./sqlite');
 const MongoDBDatabase = require('./mongodb');
 const JsonDatabase = require('./json');
 const PostgreSQLDatabase = require('./pg');
+const RedisDatabase = require('./redis'); // Yeni Redis adapter
 const CacheWrapper = require('./cacheWrapper');
 
 const adapters = {
@@ -12,6 +14,7 @@ const adapters = {
   mongodb: MongoDBDatabase,
   postgres: PostgreSQLDatabase,
   json: JsonDatabase,
+  redis: RedisDatabase, // Redis adapter eklendi
 };
 
 /**
@@ -19,7 +22,7 @@ const adapters = {
  * Bu bir "Fabrika Fonksiyonu"dur.
  *
  * @param {object} options - Yapılandırma seçenekleri.
- * @param {keyof adapters} options.adapter - Kullanılacak adaptör ('mysql', 'sqlite', vb.).
+ * @param {keyof adapters} options.adapter - Kullanılacak adaptör ('mysql', 'sqlite', 'redis', vb.).
  * @param {object} options.config - Seçilen adaptöre özel yapılandırma.
  * @returns {IDatabase} - IDatabase arayüzünü uygulayan bir örnek döndürür.
  */
@@ -62,4 +65,4 @@ function createDatabase(options) {
 module.exports = createDatabase;
 
 // Eğer hem fonksiyonu hem de tipleri export etmek isterseniz:
-// module.exports = { createDatabase };
+// module.exports = { createDatabase };

package/database/mysql.js

@@ -169,6 +169,25 @@ class MySQLDatabase extends IDatabase{
     return bestType;
   }
 
+  /**
+   * Eksik kolonları kontrol eder ve ekler
+   */
+  async _ensureMissingColumns(table, data) {
+    const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
+    if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
+
+    const existingColumnNames = existingColumns.map(col => col.Field);
+    
+    for (const key of Object.keys(data)) {
+      if (!existingColumnNames.includes(key)) {
+        const columnType = this._getColumnType(data[key]);
+        const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`;
+        await this.query(alterSQL);
+        console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
+      }
+    }
+  }
+
   async _queueRequest(operation) {
     if (this._connected) {
       return operation();
@@ -231,10 +250,11 @@ class MySQLDatabase extends IDatabase{
     return this._queueRequest(async () => {
       const copy = { ...data };
       await this.ensureTable(table, copy);
-      const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-      if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
+      
+      // Eksik kolonları ekle
+      await this._ensureMissingColumns(table, copy);
 
-      const existingNames = existingColumns.map(col => col.Field);
+      const existingColumns = await this.query(`DESCRIBE \`${table}\``);
       const primaryKeyColumn = existingColumns.find(col => col.Key === 'PRI' && col.Extra.includes('auto_increment'));
 
       const insertData = { ...copy };
@@ -243,13 +263,6 @@ class MySQLDatabase extends IDatabase{
         delete insertData[primaryKeyColumn.Field];
       }
 
-      for (const key of Object.keys(insertData)) {
-        if (!existingNames.includes(key)) {
-          const columnType = this._getColumnType(insertData[key]);
-          await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`);
-        }
-      }
-
       const keys = Object.keys(insertData);
       const placeholders = keys.map(() => "?").join(",");
       const values = Object.values(insertData).map(value => this._serializeValue(value));
@@ -263,22 +276,14 @@ class MySQLDatabase extends IDatabase{
   async update(table, data, where) {
     return this._queueRequest(async () => {
       await this.ensureTable(table, { ...data, ...where });
-      const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-      if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-      const existingColumnNames = existingColumns.map(col => col.Field);
-      for (const key of Object.keys(data)) {
-        if (!existingColumnNames.includes(key)) {
-          const columnType = this._getColumnType(data[key]);
-          const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`;
-          await this.query(alterSQL);
-          console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
-        }
-      }
+      
+      // Eksik kolonları ekle
+      await this._ensureMissingColumns(table, { ...data, ...where });
+      
       const setString = Object.keys(data).map(k => `\`${k}\` = ?`).join(", ");
       const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
       const sql = `UPDATE \`${table}\` SET ${setString} WHERE ${whereString}`;
-      const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
+      const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
       return result.affectedRows;
     });
   }
@@ -287,9 +292,13 @@ class MySQLDatabase extends IDatabase{
     return this._queueRequest(async () => {
       if (!where || Object.keys(where).length === 0) return 0;
       await this.ensureTable(table, { ...where });
+      
+      // Eksik kolonları ekle (where koşulları için)
+      await this._ensureMissingColumns(table, where);
+      
       const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
       const sql = `DELETE FROM \`${table}\` WHERE ${whereString}`;
-      const result = await this.query(sql, Object.values(where));
+      const result = await this.query(sql, Object.values(where).map(v => this._serializeValue(v)));
       return result.affectedRows;
     });
   }
@@ -297,13 +306,19 @@ class MySQLDatabase extends IDatabase{
   async select(table, where = null) {
     return this._queueRequest(async () => {
       await this.ensureTable(table, where || {});
+      
+      // Eğer where koşulu varsa, eksik kolonları ekle
+      if (where && Object.keys(where).length > 0) {
+        await this._ensureMissingColumns(table, where);
+      }
+      
       let sql = `SELECT * FROM \`${table}\``;
       let params = [];
 
       if (where && Object.keys(where).length > 0) {
         const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
         sql += ` WHERE ${whereString}`;
-        params = Object.values(where);
+        params = Object.values(where).map(v => this._serializeValue(v));
       }
 
       return (await this.query(sql, params)).map(row => {
@@ -319,18 +334,10 @@ class MySQLDatabase extends IDatabase{
   async set(table, data, where) {
     return this._queueRequest(async () => {
       await this.ensureTable(table, { ...data, ...where });
-      const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-      if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-      const existingColumnNames = existingColumns.map(col => col.Field);
-      for (const key of Object.keys(data)) {
-        if (!existingColumnNames.includes(key)) {
-          const columnType = this._getColumnType(data[key]);
-          const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`;
-          await this.query(alterSQL);
-          console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
-        }
-      }
+      
+      // Eksik kolonları ekle
+      await this._ensureMissingColumns(table, { ...data, ...where });
+      
       const existing = await this.select(table, where);
       if (existing.length === 0) {
         return await this.insert(table, { ...where, ...data });
@@ -356,11 +363,16 @@ class MySQLDatabase extends IDatabase{
 
   async deleteOne(table, where) {
     return this._queueRequest(async () => {
+      await this.ensureTable(table, where);
+      
+      // Eksik kolonları ekle (where koşulları için)
+      await this._ensureMissingColumns(table, where);
+      
       const row = await this.selectOne(table, where);
       if (!row) return 0;
       const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
       const sql = `DELETE FROM \`${table}\` WHERE ${whereString} LIMIT 1`;
-      const result = await this.query(sql, Object.values(where));
+      const result = await this.query(sql, Object.values(where).map(v => this._serializeValue(v)));
       return result.affectedRows;
     });
   }
@@ -368,22 +380,14 @@ class MySQLDatabase extends IDatabase{
   async updateOne(table, data, where) {
     return this._queueRequest(async () => {
       await this.ensureTable(table, { ...data, ...where });
-      const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-      if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-      const existingColumnNames = existingColumns.map(col => col.Field);
-      for (const key of Object.keys(data)) {
-        if (!existingColumnNames.includes(key)) {
-          const columnType = this._getColumnType(data[key]);
-          const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`;
-          await this.query(alterSQL);
-          console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
-        }
-      }
+      
+      // Eksik kolonları ekle
+      await this._ensureMissingColumns(table, { ...data, ...where });
+      
       const setString = Object.keys(data).map(k => `\`${k}\` = ?`).join(", ");
       const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
       const sql = `UPDATE \`${table}\` SET ${setString} WHERE ${whereString} LIMIT 1`;
-      const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
+      const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
       return result.affectedRows;
     });
   }
@@ -395,18 +399,27 @@ class MySQLDatabase extends IDatabase{
 
       const existingColumns = await this.query(`DESCRIBE \`${table}\``);
       const existingColumnNames = existingColumns.map(col => col.Field);
-      const keys = Object.keys(dataArray[0]);
+      
+      // Tüm datalardan gelen tüm anahtarları topla
+      const allKeys = new Set();
+      dataArray.forEach(obj => {
+        Object.keys(obj).forEach(key => allKeys.add(key));
+      });
 
       // Eksik kolonları kontrol et ve ekle
-      for (const key of keys) {
+      for (const key of allKeys) {
         if (!existingColumnNames.includes(key)) {
           // Tüm değerleri kontrol ederek en uygun türü belirle
-          const columnValues = dataArray.map(obj => obj[key]).filter(val => val !== undefined && val !== null);
+          const columnValues = dataArray
+            .map(obj => obj[key])
+            .filter(val => val !== undefined && val !== null);
           const columnType = columnValues.length > 0 ? this._getBestColumnType(columnValues) : 'TEXT';
           await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`);
+          console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
         }
       }
 
+      const keys = Array.from(allKeys);
       const placeholders = dataArray.map(() => `(${keys.map(() => '?').join(',')})`).join(',');
       const values = dataArray.flatMap(obj => keys.map(k => this._serializeValue(obj[k])));
       const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(",")}) VALUES ${placeholders}`;