@onurege3467/zerohelper 5.0.3 → 6.0.1

package/data/test_db.json

@@ -0,0 +1,3 @@
+{
+  "users": []
+}

package/database/cacheWrapper.js

@@ -0,0 +1,121 @@
+const { LRUCache } = require('lru-cache');
+
+class CacheWrapper {
+  constructor(databaseInstance, options = {}) {
+    this.db = databaseInstance;
+    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
+    });
+    this.tableCaches = {}; // Cache for each table
+  }
+
+  _getCache(table) {
+    if (!this.tableCaches[table]) {
+      this.tableCaches[table] = new LRUCache({
+        max: this.cache.max,
+        ttl: this.cache.ttl,
+        updateAgeOnGet: this.cache.updateAgeOnGet,
+      });
+    }
+    return this.tableCaches[table];
+  }
+
+  _generateKey(table, where) {
+    return `${table}:${JSON.stringify(where || {})}`;
+  }
+
+  // Read operations
+  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;
+    }
+
+    // console.log(`Cache miss for select: ${key}`);
+    data = await this.db.select(table, where);
+    cache.set(key, data);
+    return data;
+  }
+
+  async selectOne(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 selectOne: ${key}`);
+      return data;
+    }
+
+    // console.log(`Cache miss for selectOne: ${key}`);
+    data = await this.db.selectOne(table, where);
+    cache.set(key, data);
+    return data;
+  }
+
+  // Write operations (invalidate cache)
+  async insert(table, data) {
+    this._getCache(table).clear();
+    return this.db.insert(table, data);
+  }
+
+  async update(table, data, where) {
+    this._getCache(table).clear();
+    return this.db.update(table, data, where);
+  }
+
+  async set(table, data, where) {
+    this._getCache(table).clear();
+    return this.db.set(table, data, where);
+  }
+
+  async delete(table, where) {
+    this._getCache(table).clear();
+    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();
+    return this.db.deleteOne(table, where);
+  }
+
+  async updateOne(table, data, where) {
+    this._getCache(table).clear();
+    return this.db.updateOne(table, data, where);
+  }
+
+  // Pass-through for other methods (e.g., close, ensureTable, query for MySQL/SQLite)
+  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];
+    }
+  }
+}
+
+module.exports = CacheWrapper;

package/database/index.js

@@ -1,8 +1,9 @@
-const IDatabase = require('./adapters/IDatabase');
-const MySQLDatabase = require('./adapters/mysql');
-const SQLiteDatabase = require('./adapters/sqlite');
-const MongoDBDatabase = require('./adapters/mongodb');
-const JsonDatabase = require('./adapters/json');
+const IDatabase = require('./IDatabase');
+const MySQLDatabase = require('./mysql');
+const SQLiteDatabase = require('./sqlite');
+const MongoDBDatabase = require('./mongodb');
+const JsonDatabase = require('./json');
+const CacheWrapper = require('./cacheWrapper');
 
 const adapters = {
   mysql: MySQLDatabase,
@@ -35,7 +36,24 @@ function createDatabase(options) {
   const DatabaseClass = adapters[adapter];
 
   // Sınıfın bir örneğini oluştur ve doğrudan döndür
-  return new DatabaseClass(config);
+  const dbInstance = new DatabaseClass(config);
+
+  // Eğer cache etkinse, veritabanı örneğini CacheWrapper ile sarmala
+  if (config.cache) {
+    return new Proxy(new CacheWrapper(dbInstance, config.cache), {
+      get: (target, prop) => {
+        if (typeof target[prop] !== 'undefined') {
+          return target[prop];
+        } else if (typeof target.db[prop] === 'function') {
+          return target.db[prop].bind(target.db);
+        } else {
+          return target.db[prop];
+        }
+      }
+    });
+  }
+
+  return dbInstance;
 }
 
 // Artık varsayılan olarak bu fonksiyonu export ediyoruz.

package/database/{adapters/json.js → json.js}

@@ -111,7 +111,7 @@ class JsonDatabase extends IDatabase{
   async ensureTable(table) {
     await this.initPromise;
     if (!this.db[table]) {
-      return this._enqueueWrite(() => {
+      return this._queueRequest(() => {
         this.db[table] = [];
       });
     }
@@ -119,7 +119,7 @@ class JsonDatabase extends IDatabase{
 
   async insert(table, data) {
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    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 };
@@ -130,7 +130,7 @@ class JsonDatabase extends IDatabase{
 
   async update(table, data, where) {
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    return this._queueRequest(() => {
       let affectedRows = 0;
       this.db[table].forEach(row => {
         if (this._matches(row, where)) {
@@ -144,7 +144,7 @@ class JsonDatabase extends IDatabase{
 
   async delete(table, where) {
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    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;
@@ -179,32 +179,32 @@ class JsonDatabase extends IDatabase{
 
   async deleteOne(table, where) {
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    return this._queueRequest(() => {
       const index = this.db[table].findIndex(row => this._matches(row, where));
       if (index > -1) {
         this.db[table].splice(index, 1);
         return 1; // 1 satır etkilendi
       }
-      return 0; // Hiçbir satır etkilenmedi
+      return 0; // Hiçbir satır etkilendi
     });
   }
 
   async updateOne(table, data, where) {
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    return this._queueRequest(() => {
       const row = this.db[table].find(row => this._matches(row, where));
       if (row) {
         Object.assign(row, data);
         return 1; // 1 satır etkilendi
       }
-      return 0; // Hiçbir satır etkilenmedi
+      return 0; // Hiçbir satır etkilendi
     });
   }
 
   async bulkInsert(table, dataArray) {
     if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
     await this.ensureTable(table);
-    return this._enqueueWrite(() => {
+    return this._queueRequest(() => {
       let maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
       dataArray.forEach(data => {
         maxId++;

package/database/{adapters/mongodb.js → mongodb.js}

@@ -7,6 +7,7 @@ const { MongoClient, ObjectId } = require("mongodb");
 
 class MongoDBDatabase extends IDatabase{
   constructor(config) {
+    super();
     this.config = config;
     this.client = new MongoClient(config.url, {
       useNewUrlParser: true,

package/database/{adapters/mysql.js → mysql.js}

@@ -80,7 +80,7 @@ class MySQLDatabase extends IDatabase{
 
   async ensureTable(table, data = {}) {
     return this._queueRequest(async () => {
-      if (!data || Object.keys(data).length === 0) return;
+      
 
       const escapedTable = mysql.escape(table);
       const tables = await this.query(`SHOW TABLES LIKE ${escapedTable}`);
@@ -124,20 +124,20 @@ 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);
+      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 alterSQL = `ALTER TABLE `${table}` ADD COLUMN `${key}` VARCHAR(255)`;
+          const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`;
           await this.query(alterSQL);
           console.log(`Added missing column '${key}' to table '${table}'`);
         }
       }
-      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 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)]);
       return result.affectedRows;
     });
@@ -157,11 +157,11 @@ class MySQLDatabase extends IDatabase{
   async select(table, where = null) {
     return this._queueRequest(async () => {
       await this.ensureTable(table, where || {});
-      let sql = `SELECT * FROM `${table}``;
+      let sql = `SELECT * FROM \`${table}\``;
       let params = [];
 
       if (where && Object.keys(where).length > 0) {
-        const whereString = Object.keys(where).map(k => ``${k}`` = ?`).join(" AND ");
+        const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
         sql += ` WHERE ${whereString}`;
         params = Object.values(where);
       }
@@ -238,20 +238,20 @@ class MySQLDatabase extends IDatabase{
       if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
       await this.ensureTable(table, dataArray[0]);
 
-      const existingColumns = await this.query(`DESCRIBE `${table}``);
+      const existingColumns = await this.query(`DESCRIBE \`${table}\``);
       const existingColumnNames = existingColumns.map(col => col.Field);
       const keys = Object.keys(dataArray[0]);
 
       // Eksik kolonları sadece ilk elemana göre kontrol et
       for (const key of keys) {
         if (!existingColumnNames.includes(key)) {
-          await this.query(`ALTER TABLE `${table}` ADD COLUMN `${key}` VARCHAR(255)`);
+          await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`);
         }
       }
 
       const placeholders = dataArray.map(() => `(${keys.map(() => '?').join(',')})`).join(',');
       const values = dataArray.flatMap(obj => keys.map(k => obj[k]));
-      const sql = `INSERT INTO `${table}` (${keys.map(k => ``${k}``).join(",")}) VALUES ${placeholders}`;
+      const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(",")}) VALUES ${placeholders}`;
 
       const result = await this.query(sql, values);
       return result.affectedRows;
@@ -263,4 +263,4 @@ class MySQLDatabase extends IDatabase{
   }
 }
 
-module.exports = MySQLDatabase;
+module.exports = MySQLDatabase;

package/database/{adapters/sqlite.js → sqlite.js}

@@ -3,7 +3,7 @@ const IDatabase = require('./IDatabase'); // Arayüzü import et
 /**
  * @implements {IDatabase}
  */
-const Database = require('better-sqlite3');
+const sqlite3 = require('sqlite3').verbose();
 const fs = require('fs');
 const path = require('path');
 
@@ -24,28 +24,36 @@ class SQLiteDatabase extends IDatabase{
       fs.mkdirSync(dir, { recursive: true });
     }
 
-    // better-sqlite3 senkron çalıştığı için bağlantı anında kurulur.
-    this.db = new Database(config.filePath);
+    this.db = new sqlite3.Database(config.filePath, (err) => {
+      if (err) {
+        console.error("SQLite connection error:", err.message);
+      } else {
+        console.log('Connected to the SQLite database.');
+      }
+    });
   }
 
   /**
-   * SQL sorgusu çalıştırır. SELECT için satırları, diğerleri için bilgiyi döndürür.
+   * SQL sorgusu çalıştırır. Promise döndürür.
    * @param {string} sql - Çalıştırılacak SQL sorgusu.
    * @param {Array} params - Sorgu parametreleri.
    */
   query(sql, params = []) {
-    try {
-      // SELECT sorguları için .all() kullanılır ve bir dizi döndürür.
-      return this.db.prepare(sql).all(params);
-    } catch (error) {
-      // INSERT, UPDATE, DELETE gibi sorgular .all() ile çalışmaz, .run() kullanılır.
-      // Bu sorgular bir bilgi nesnesi döndürür (örn: { changes: 1, lastInsertRowid: 5 })
-      if (error.message.includes('This statement does not return data')) {
-        return this.db.prepare(sql).run(params);
+    return new Promise((resolve, reject) => {
+      // SELECT sorguları için .all() kullanılır
+      if (sql.trim().toUpperCase().startsWith('SELECT') || sql.trim().toUpperCase().startsWith('PRAGMA')) {
+        this.db.all(sql, params, (err, rows) => {
+          if (err) reject(err);
+          else resolve(rows);
+        });
+      } else {
+        // INSERT, UPDATE, DELETE gibi sorgular için .run() kullanılır
+        this.db.run(sql, params, function (err) {
+          if (err) reject(err);
+          else resolve({ changes: this.changes, lastInsertRowid: this.lastID });
+        });
       }
-      // Başka bir hata varsa fırlat
-      throw error;
-    }
+    });
   }
 
   /**
@@ -53,16 +61,13 @@ class SQLiteDatabase extends IDatabase{
    * @param {string} table - Tablo adı.
    * @param {object} data - Tablo oluşturulurken sütunları belirlemek için örnek veri.
    */
-  ensureTable(table, data = {}) {
-    if (!data || Object.keys(data).length === 0) return;
+  async ensureTable(table, data = {}) {
+    
 
     try {
-      // Tablonun varlığını kontrol etmenin en hızlı yolu bir sorgu denemektir.
-      this.db.prepare(`SELECT 1 FROM \`${table}\` LIMIT 1`).get();
+      await this.query(`SELECT 1 FROM \`${table}\` LIMIT 1`);
     } catch (error) {
-      // "no such table" hatası alırsak, tabloyu oluştur.
       if (error.message.includes('no such table')) {
-        // SQLite tipleri esnek olduğu için TEXT çoğu veri tipi için yeterlidir.
         const columns = Object.keys(data).map(col => `\`${col}\` TEXT`).join(', ');
         const createTableSQL = `
           CREATE TABLE \`${table}\` (
@@ -70,7 +75,7 @@ class SQLiteDatabase extends IDatabase{
             ${columns}
           )
         `;
-        this.query(createTableSQL);
+        await this.query(createTableSQL);
       } else {
         throw error;
       }
@@ -81,69 +86,69 @@ class SQLiteDatabase extends IDatabase{
    * Verilen verideki anahtarların tabloda sütun olarak var olduğundan emin olur.
    * @private
    */
-  _ensureColumns(table, data) {
-    const columnsInfo = this.db.prepare(`PRAGMA table_info(\`${table}\`)`).all();
+  async _ensureColumns(table, data) {
+    const columnsInfo = await this.query(`PRAGMA table_info(\`${table}\`)`);
     const existingNames = columnsInfo.map(col => col.name);
 
     for (const key of Object.keys(data)) {
       if (!existingNames.includes(key)) {
-        this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` TEXT`);
+        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` TEXT`);
       }
     }
   }
 
   /**
    * Bir tabloya yeni veri ekler.
-   * @returns {number} Eklenen satırın ID'si.
+   * @returns {Promise<number>} Eklenen satırın ID'si.
    */
-  insert(table, data) {
+  async insert(table, data) {
     const copy = { ...data };
-    this.ensureTable(table, copy);
-    this._ensureColumns(table, copy);
+    await this.ensureTable(table, copy);
+    await this._ensureColumns(table, copy);
 
     const keys = Object.keys(copy);
     const placeholders = keys.map(() => '?').join(',');
     const values = Object.values(copy);
     const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(',')}) VALUES (${placeholders})`;
 
-    const result = this.query(sql, values);
-    return result.lastInsertRowid; // SQLite'ta `insertId` yerine `lastInsertRowid` kullanılır.
+    const result = await this.query(sql, values);
+    return result.lastInsertRowid;
   }
 
   /**
    * Tablodaki verileri günceller.
-   * @returns {number} Etkilenen satır sayısı.
+   * @returns {Promise<number>} Etkilenen satır sayısı.
    */
-  update(table, data, where) {
-    this.ensureTable(table, { ...data, ...where });
-    this._ensureColumns(table, data);
+  async update(table, data, where) {
+    await this.ensureTable(table, { ...data, ...where });
+    await this._ensureColumns(table, data);
 
     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 = this.query(sql, [...Object.values(data), ...Object.values(where)]);
-    return result.changes; // SQLite'ta `affectedRows` yerine `changes` kullanılır.
+    const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
+    return result.changes;
   }
 
   /**
    * Tablodan veri siler.
-   * @returns {number} Etkilenen satır sayısı.
+   * @returns {Promise<number>} Etkilenen satır sayısı.
    */
-  delete(table, where) {
+  async delete(table, where) {
     if (!where || Object.keys(where).length === 0) return 0;
-    this.ensureTable(table, { ...where });
+    await this.ensureTable(table, { ...where });
     const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(' AND ');
     const sql = `DELETE FROM \`${table}\` WHERE ${whereString}`;
-    const result = this.query(sql, Object.values(where));
+    const result = await this.query(sql, Object.values(where));
     return result.changes;
   }
 
   /**
    * Tablodan veri seçer.
-   * @returns {Array<object>} Sonuç satırları.
+   * @returns {Promise<Array<object>>} Sonuç satırları.
    */
-  select(table, where = null) {
-    this.ensureTable(table, where || {});
+  async select(table, where = null) {
+    await this.ensureTable(table, where || {});
     let sql = `SELECT * FROM \`${table}\``;
     let params = [];
 
@@ -153,92 +158,96 @@ class SQLiteDatabase extends IDatabase{
       params = Object.values(where);
     }
 
-    return this.query(sql, params);
+    return await this.query(sql, params);
   }
 
   /**
    * Veri varsa günceller, yoksa ekler (upsert).
    */
-  set(table, data, where) {
-    this.ensureTable(table, { ...data, ...where });
-    this._ensureColumns(table, data);
-    const existing = this.select(table, where);
+  async set(table, data, where) {
+    await this.ensureTable(table, { ...data, ...where });
+    await this._ensureColumns(table, data);
+    const existing = await this.select(table, where);
     if (existing.length === 0) {
-      return this.insert(table, { ...where, ...data });
+      return await this.insert(table, { ...where, ...data });
     } else {
-      return this.update(table, data, where);
+      return await this.update(table, data, where);
     }
   }
 
   /**
    * Koşula uyan ilk veriyi seçer.
-   * @returns {object|null} Bulunan satır veya null.
+   * @returns {Promise<object|null>} Bulunan satır veya null.
    */
-  selectOne(table, where = null) {
-    const results = this.select(table, where);
+  async selectOne(table, where = null) {
+    const results = await this.select(table, where);
     return results[0] || null;
   }
 
   /**
    * Koşula uyan ilk veriyi siler.
-   * @returns {number} Etkilenen satır sayısı (0 veya 1).
+   * @returns {Promise<number>} Etkilenen satır sayısı (0 veya 1).
    */
-  deleteOne(table, where) {
+  async deleteOne(table, where) {
     if (!where || Object.keys(where).length === 0) return 0;
-    this.ensureTable(table, where);
+    await this.ensureTable(table, where);
     const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(' AND ');
     const sql = `DELETE FROM \`${table}\` WHERE rowid IN (SELECT rowid FROM \`${table}\` WHERE ${whereString} LIMIT 1)`;
-    const result = this.query(sql, Object.values(where));
+    const result = await this.query(sql, Object.values(where));
     return result.changes;
   }
 
   /**
    * Koşula uyan ilk veriyi günceller.
-   * @returns {number} Etkilenen satır sayısı (0 veya 1).
+   * @returns {Promise<number>} Etkilenen satır sayısı (0 veya 1).
    */
-  updateOne(table, data, where) {
-    this.ensureTable(table, { ...data, ...where });
-    this._ensureColumns(table, data);
+  async updateOne(table, data, where) {
+    await this.ensureTable(table, { ...data, ...where });
+    await this._ensureColumns(table, data);
     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 rowid IN (SELECT rowid FROM \`${table}\` WHERE ${whereString} LIMIT 1)`;
-    const result = this.query(sql, [...Object.values(data), ...Object.values(where)]);
+    const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
     return result.changes;
   }
 
   /**
    * Toplu veri ekleme.
-   * @returns {number} Eklenen satır sayısı.
+   * @returns {Promise<number>} Eklenen satır sayısı.
    */
-  bulkInsert(table, dataArray) {
+  async bulkInsert(table, dataArray) {
     if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
-    this.ensureTable(table, dataArray[0]);
-    this._ensureColumns(table, dataArray[0]);
+    await this.ensureTable(table, dataArray[0]);
+    await this._ensureColumns(table, dataArray[0]);
 
     const keys = Object.keys(dataArray[0]);
     const placeholders = keys.map(() => '?').join(',');
     const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(',')}) VALUES (${placeholders})`;
     
-    // better-sqlite3'nin transaction özelliği toplu işlemlerde çok yüksek performans sağlar.
-    const insertMany = this.db.transaction((items) => {
-      const stmt = this.db.prepare(sql);
-      for (const item of items) {
+    // sqlite3'te toplu ekleme için transaction kullanabiliriz
+    const stmt = this.db.prepare(sql);
+    this.db.serialize(() => {
+      this.db.run("BEGIN TRANSACTION;");
+      for (const item of dataArray) {
         stmt.run(Object.values(item));
       }
+      this.db.run("COMMIT;");
     });
 
-    insertMany(dataArray);
     return dataArray.length;
   }
 
   /**
    * Veritabanı bağlantısını kapatır.
    */
-  close() {
-    if (this.db) {
-      this.db.close();
-    }
+  async close() {
+    return new Promise((resolve, reject) => {
+      this.db.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
   }
 }
 
-module.exports = SQLiteDatabase;
+module.exports = SQLiteDatabase;

package/functions/index.js

@@ -124,15 +124,25 @@ function deepMerge(obj1, obj2) {
 }
 
 // Şifreleme ve Güvenlik
+function getKeyFromSecret(secret) {
+  // Use a fixed salt for simplicity in testing. In production, use a unique salt per encryption.
+  const salt = Buffer.from('some_fixed_salt_for_testing_only', 'utf8');
+  return crypto.pbkdf2Sync(secret, salt, 100000, 32, 'sha512'); // 32 bytes for AES-256
+}
+
 function encryptText(text, secret) {
-  const cipher = crypto.createCipher("aes-256-cbc", secret);
+  const key = getKeyFromSecret(secret);
+  const iv = crypto.randomBytes(16); // Initialization vector
+  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
   let encrypted = cipher.update(text, "utf8", "hex");
   encrypted += cipher.final("hex");
-  return encrypted;
+  return { encryptedText: encrypted, iv: iv.toString('hex') };
 }
 
-function decryptText(encryptedText, secret) {
-  const decipher = crypto.createDecipher("aes-256-cbc", secret);
+function decryptText(encryptedText, secret, ivHex) {
+  const key = getKeyFromSecret(secret);
+  const iv = Buffer.from(ivHex, 'hex');
+  const decipher = crypto.createDecipheriv("aes-256-cbc", key, iv);
   let decrypted = decipher.update(encryptedText, "hex", "utf8");
   decrypted += decipher.final("utf8");
   return decrypted;