@onurege3467/zerohelper 7.0.0 → 7.2.0

package/database/sqlite.js

@@ -92,6 +92,11 @@ class SQLiteDatabase extends IDatabase{
       }
     }
 
+    // Object ve Array kontrolü
+    if (typeof value === 'object') {
+      return 'TEXT'; // SQLite'da JSON olarak string halinde saklanacak
+    }
+
     // Varsayılan olarak TEXT
     return 'TEXT';
   }
@@ -120,6 +125,24 @@ class SQLiteDatabase extends IDatabase{
     return bestType || 'TEXT';
   }
 
+  /**
+   * Eksik kolonları kontrol eder ve ekler
+   * @param {string} table - Tablo adı
+   * @param {object} data - Kontrol edilecek veri
+   */
+  async _ensureMissingColumns(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)) {
+        const columnType = this._detectColumnType(data[key]);
+        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`);
+        console.log(`Added missing column '${key}' to table '${table}' with type ${columnType}`);
+      }
+    }
+  }
+
   /**
    * SQL sorgusu çalıştırır. Promise döndürür.
    * @param {string} sql - Çalıştırılacak SQL sorgusu.
@@ -179,17 +202,43 @@ class SQLiteDatabase extends IDatabase{
   /**
    * Verilen verideki anahtarların tabloda sütun olarak var olduğundan emin olur.
    * @private
+   * @deprecated Bu fonksiyon yerine _ensureMissingColumns kullanılıyor
    */
   async _ensureColumns(table, data) {
-    const columnsInfo = await this.query(`PRAGMA table_info(\`${table}\`)`);
-    const existingNames = columnsInfo.map(col => col.name);
+    return this._ensureMissingColumns(table, data);
+  }
 
-    for (const key of Object.keys(data)) {
-      if (!existingNames.includes(key)) {
-        const columnType = this._detectColumnType(data[key]);
-        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`);
+  /**
+   * Değeri serileştir (JSON objeler için)
+   */
+  _serializeValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+
+  /**
+   * Değeri deserileştir (JSON objeler için)
+   */
+  _deserializeValue(value) {
+    if (typeof value === 'string') {
+      try {
+        // JSON string olup olmadığını kontrol et
+        if (value.startsWith('[') || value.startsWith('{')) {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === 'object' && parsed !== null) {
+            return parsed;
+          }
+        }
+      } catch (e) {
+        // JSON parse hatası, orijinal değeri döndür
       }
     }
+    return value;
   }
 
   /**
@@ -199,11 +248,13 @@ class SQLiteDatabase extends IDatabase{
   async insert(table, data) {
     const copy = { ...data };
     await this.ensureTable(table, copy);
-    await this._ensureColumns(table, copy);
+    
+    // Eksik kolonları ekle
+    await this._ensureMissingColumns(table, copy);
 
     const keys = Object.keys(copy);
     const placeholders = keys.map(() => '?').join(',');
-    const values = Object.values(copy);
+    const values = Object.values(copy).map(v => this._serializeValue(v));
     const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(',')}) VALUES (${placeholders})`;
 
     const result = await this.query(sql, values);
@@ -216,12 +267,14 @@ class SQLiteDatabase extends IDatabase{
    */
   async update(table, data, where) {
     await this.ensureTable(table, { ...data, ...where });
-    await this._ensureColumns(table, data);
+    
+    // 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.changes;
   }
 
@@ -232,9 +285,13 @@ class SQLiteDatabase extends IDatabase{
   async delete(table, where) {
     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.changes;
   }
 
@@ -244,16 +301,29 @@ class SQLiteDatabase extends IDatabase{
    */
   async select(table, where = null) {
     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);
+    const rows = await this.query(sql, params);
+    return rows.map(row => {
+      const newRow = {};
+      for (const key in row) {
+        newRow[key] = this._deserializeValue(row[key]);
+      }
+      return newRow;
+    });
   }
 
   /**
@@ -261,7 +331,10 @@ class SQLiteDatabase extends IDatabase{
    */
   async set(table, data, where) {
     await this.ensureTable(table, { ...data, ...where });
-    await this._ensureColumns(table, data);
+    
+    // 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 });
@@ -286,9 +359,13 @@ class SQLiteDatabase extends IDatabase{
   async deleteOne(table, where) {
     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 rowid IN (SELECT rowid 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.changes;
   }
 
@@ -298,11 +375,14 @@ class SQLiteDatabase extends IDatabase{
    */
   async updateOne(table, data, where) {
     await this.ensureTable(table, { ...data, ...where });
-    await this._ensureColumns(table, data);
+    
+    // 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 rowid IN (SELECT rowid FROM \`${table}\` 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.changes;
   }
 
@@ -316,26 +396,74 @@ class SQLiteDatabase extends IDatabase{
     // İlk elemanı tablo oluşturmak için kullan
     await this.ensureTable(table, dataArray[0]);
     
-    // Tüm elemanların sütunlarını kontrol et
-    for (const item of dataArray) {
-      await this._ensureColumns(table, item);
+    // Tüm datalardan gelen tüm anahtarları topla
+    const allKeys = new Set();
+    dataArray.forEach(obj => {
+      Object.keys(obj).forEach(key => allKeys.add(key));
+    });
+
+    // Tüm eksik kolonları ekle
+    for (const key of allKeys) {
+      const columnsInfo = await this.query(`PRAGMA table_info(\`${table}\`)`);
+      const existingNames = columnsInfo.map(col => col.name);
+      
+      if (!existingNames.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 columnType = columnValues.length > 0 ? this._determineBestColumnType(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 = Object.keys(dataArray[0]);
+    const keys = Array.from(allKeys);
     const placeholders = keys.map(() => '?').join(',');
     const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(',')}) VALUES (${placeholders})`;
     
-    // 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;");
+    // sqlite3'te toplu ekleme için transaction kullan
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(sql, (err) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+      });
+      
+      this.db.serialize(() => {
+        this.db.run("BEGIN TRANSACTION;");
+        
+        let completed = 0;
+        let hasError = false;
+        
+        for (const item of dataArray) {
+          if (hasError) break;
+          
+          const values = keys.map(k => this._serializeValue(item[k]));
+          stmt.run(values, (err) => {
+            if (err && !hasError) {
+              hasError = true;
+              this.db.run("ROLLBACK;");
+              reject(err);
+              return;
+            }
+            
+            completed++;
+            if (completed === dataArray.length && !hasError) {
+              this.db.run("COMMIT;", (err) => {
+                if (err) {
+                  reject(err);
+                } else {
+                  stmt.finalize();
+                  resolve(dataArray.length);
+                }
+              });
+            }
+          });
+        }
+      });
     });
-
-    return dataArray.length;
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "7.0.0",
+  "version": "7.2.0",
   "main": "index.js",
   "scripts": {
     "test": "node test.js"
@@ -16,7 +16,6 @@
     "sqlite3",
     "quick.db",
     "postgresql",
-    "redis",
     "utility",
     "functions",
     "nodejs"
@@ -26,7 +25,6 @@
   "description": "ZeroHelper is a versatile JavaScript library offering helper functions and database utilities for developers. It supports MongoDB, MySQL, SQLite, Redis, and PostgreSQL.",
   "dependencies": {
     "bcrypt": "^5.1.1",
-    
     "crypto": "^1.0.1",
     "csv": "^6.3.11",
     "dotenv": "^16.4.7",
@@ -34,13 +32,13 @@
     "js-yaml": "^4.1.0",
     "jsonwebtoken": "^9.0.2",
     "lodash": "^4.17.21",
+    "lru-cache": "^10.0.0",
     "mongodb": "^6.12.0",
     "mysql2": "^3.14.1",
     "path": "^0.12.7",
     "pg": "^8.14.1",
     "promise-mysql": "^5.2.0",
-    "redis": "^4.7.0",
-    "sqlite3": "^5.1.7",
-    "lru-cache": "^10.0.0"
+    "redis": "^5.8.2",
+    "sqlite3": "^5.1.7"
   }
 }

package/readme.md

@@ -187,6 +187,7 @@ const cachedSqliteDb = createDatabase({
   config: {
     filePath: path.join(__dirname, 'data', 'cached_development.sqlite'),
     cache: {
+      type:'memory'
       max: 1000, // Cache up to 1000 items
       ttl: 1000 * 60 * 10, // Cache items for 10 minutes
       updateAgeOnGet: true // Refresh TTL on access
@@ -196,6 +197,29 @@ const cachedSqliteDb = createDatabase({
 
 // Subsequent `select` or `selectOne` calls for the same query will hit the cache
 // Write operations (insert, update, delete, set, bulkInsert) will automatically invalidate the cache for the affected table.
+
+const postgresWithRedisCache = createDatabase({
+  adapter: 'postgres',
+  config: {
+    host: 'localhost',
+    user: 'postgres',
+    password: 'password',
+    database: 'myapp',
+    cache: {
+      type: 'redis',
+      host: 'localhost',
+      port: 6379,
+      password: 'redis_password', 
+      db: 0,
+      ttl: 600, //seconds
+      keyPrefix: 'myapp_cache:',
+      redis: {
+        connectTimeout: 10000,
+        lazyConnect: true
+      }
+    }
+  }
+});
 ```
 
 **Basic Usage (without cache configuration shown):**
@@ -250,6 +274,17 @@ const mongoDb = createDatabase({
     database: 'my_app_prod'
   }
 });
+// --- Using Redis ---
+const redisDatabase = createDatabase({
+  adapter: 'redis',
+  config: {
+    host: 'localhost',
+    port: 6379,
+    password: 'redis_password',
+    db: 1,
+    keyPrefix: 'myapp_data:'
+  }
+});
 ```
 
 ### Basic Operations (CRUD)

package/data/test_db.json

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

package/test copy.js

@@ -1,144 +0,0 @@
-const path = require('path');
-const createDatabase = require('./database');
-const helpers = require('./functions');
-const { setInterval } = require('timers');
-
-const mysqlConfig = {
-  adapter: 'mysql',
-  config: {
-    host: process.env.MYSQL_HOST || 'localhost',
-    user: process.env.MYSQL_USER || 'root',
-    password: process.env.MYSQL_PASSWORD || '',
-    database: process.env.MYSQL_DATABASE || 'test_db_zerohelper',
-    cache: {
-      max: 100,
-      ttl: 1000 * 10,
-      updateAgeOnGet: true,
-    },
-  },
-};
-// Absurd configurations for testing edge cases
-async function runDatabaseTests() {
-  console.log('Starting database tests...');
-
-  const databases = [
-    { name: 'MySQL', config: mysqlConfig },
-  ];
-
-  for (const dbInfo of databases) {
-    const { name, config } = dbInfo;
-    console.log(`\n--- Testing ${name} Database ---`);
-    let db;
-    try {
-      db = createDatabase(config);
-      console.log(`${name} database connected.`);
-
-      // Test Insert
-      const insertResult = await db.insert('users', { name: 'Test User', email: `test_${name.toLowerCase()}@example.com`, int_age: 30, bool_active: true,city: 'Test City' });
-      console.log(`${name} Insert:`, insertResult);
-      const selectResult = await db.selectOne('users', { _id: insertResult});
-      console.log(`${name} Select One:`, selectResult);
-      await db.set('users', {city:'Amkara'}, {_id: insertResult });
-
-      setInterval(async () => {
-        const updatedSelectResult = await db.selectOne('users', { _id: insertResult });
-        console.log(`${name} Select One after update:`, updatedSelectResult);
-      }, 1000);
-
-     
-
-    } catch (error) {
-      console.error(`Error testing ${name} database:`, error);
-    } finally {
-      if (db) {
-        try {
-        } catch (closeError) {
-          console.error(`Error closing ${name} database connection:`, closeError);
-        }
-      }
-    }
-  
-
-  console.log('\nAll database tests completed.');
-}
-}
-function runHelperFunctionTests() {
-  console.log('\nStarting helper function tests...');
-
-  // Random Functions
-  console.log('\n--- Testing Random Functions ---');
-  console.log('makeUniqueId:', helpers.random.makeUniqueId());
-  console.log('randomArray:', helpers.random.randomArray([1, 2, 3]));
-  console.log('randomText (5 chars):', helpers.random.randomText(5));
-  console.log('randomNumber (1-10):', helpers.random.randomNumber(1, 10));
-  console.log('randomEmoji:', helpers.random.randomEmoji());
-  console.log('randomHex:', helpers.random.randomHex());
-  console.log('randomFloat (1.0-2.0):', helpers.random.randomFloat(1.0, 2.0));
-
-  // String Functions
-  console.log('\n--- Testing String Functions ---');
-  console.log('titleCase:', helpers.string.titleCase('hello world'));
-  console.log('generateRandomString (8 chars):', helpers.string.generateRandomString(8));
-
-  // Array Functions
-  console.log('\n--- Testing Array Functions ---');
-  console.log('shuffleArray:', helpers.array.shuffleArray([1, 2, 3, 4, 5]));
-  console.log('flattenArray:', helpers.array.flattenArray([1, [2, [3]], 4]));
-  console.log('removeFalsyValues:', helpers.array.removeFalsyValues([0, 1, false, '', null, undefined, 2]));
-  const groupByData = [
-    { type: 'A', value: 1 },
-    { type: 'B', value: 2 },
-    { type: 'A', value: 3 },
-  ];
-  console.log('groupBy:', helpers.array.groupBy(groupByData, 'type'));
-  const pluckData = [
-    { name: 'Alice', age: 30 },
-    { name: 'Bob', age: 24 },
-  ];
-  console.log('pluck (name):', helpers.array.pluck(pluckData, 'name'));
-  const sortByData = [
-    { age: 30 },
-    { age: 20 },
-    { age: 40 },
-  ];
-  console.log('sortBy (age):', helpers.array.sortBy(sortByData, 'age'));
-
-  // Object Functions
-  console.log('\n--- Testing Object Functions ---');
-  const filterObjectData = { a: 1, b: 2, c: 3 };
-  console.log('filterObjectByKey:', helpers.object.filterObjectByKey(filterObjectData, ['a', 'c']));
-  const deepMergeData1 = { a: 1, b: { c: 2 } };
-  const deepMergeData2 = { b: { d: 3 }, e: 4 };
-  console.log('deepMerge:', helpers.object.deepMerge(deepMergeData1, deepMergeData2));
-
-  // Crypto Functions
-  console.log('\n--- Testing Crypto Functions ---');
-  const secret = 'mySuperSecretKey';
-  const textToEncrypt = 'Hello Crypto!';
-  const encryptedResult = helpers.crypto.encryptText(textToEncrypt, secret);
-  const encryptedText = encryptedResult.encryptedText;
-  const iv = encryptedResult.iv;
-  console.log('encryptText:', encryptedText);
-  console.log('decryptText:', helpers.crypto.decryptText(encryptedText, secret, iv));
-  const password = 'mySecurePassword';
-  const hashedPassword = helpers.crypto.hashPassword(password);
-  console.log('hashPassword:', hashedPassword);
-  console.log('verifyPassword (true):', helpers.crypto.verifyPassword(password, hashedPassword));
-  console.log('verifyPassword (false):', helpers.crypto.verifyPassword('wrongPassword', hashedPassword));
-  const jwtPayload = { userId: 123, username: 'testuser' };
-  const jwtToken = helpers.crypto.generateJWT(jwtPayload, secret);
-  console.log('generateJWT:', jwtToken);
-  console.log('verifyJWT:', helpers.crypto.verifyJWT(jwtToken, secret));
-
-  // Math Functions
-  console.log('\n--- Testing Math Functions ---');
-  console.log('mean:', helpers.math.mean([1, 2, 3, 4, 5]));
-  console.log('isPrime (7):', helpers.math.isPrime(7));
-  console.log('isPrime (10):', helpers.math.isPrime(10));
-}
-
-async function main() {
-  await runDatabaseTests();
-}
-
-main();