@onurege3467/zerohelper 6.1.0 → 7.0.0

package/database/pg.js

@@ -0,0 +1,473 @@
+const IDatabase = require('./IDatabase'); // Arayüzü import et
+const { Pool } = require('pg');
+
+/**
+ * @implements {IDatabase}
+ */
+class PostgreSQLDatabase extends IDatabase {
+  constructor(config) {
+    super();
+    this.config = config;
+    this.pool = null;
+    this._queue = [];
+    this._connected = false;
+
+    this._connectionPromise = new Promise(async (resolve, reject) => {
+      try {
+        // First, connect to create database if not exists
+        const tempPool = new Pool({
+          host: config.host,
+          port: config.port || 5432,
+          user: config.user,
+          password: config.password,
+          database: 'postgres' // Connect to default database first
+        });
+
+        try {
+          await tempPool.query(`CREATE DATABASE "${config.database}"`);
+        } catch (error) {
+          // Database might already exist, ignore error
+          if (!error.message.includes('already exists')) {
+            console.warn('Database creation warning:', error.message);
+          }
+        }
+        await tempPool.end();
+
+        // Now connect to the actual database
+        this.pool = new Pool({
+          host: config.host,
+          port: config.port || 5432,
+          user: config.user,
+          password: config.password,
+          database: config.database,
+          max: config.connectionLimit || 10,
+          idleTimeoutMillis: 30000,
+          connectionTimeoutMillis: 2000,
+        });
+
+        this._connected = true;
+        resolve(this.pool);
+        this._processQueue(); // Process any queued requests
+      } catch (error) {
+        console.error("PostgreSQL connection error:", error);
+        reject(error);
+      }
+    });
+  }
+
+  /**
+   * Değerin türüne göre PostgreSQL column türünü otomatik belirler
+   */
+  _getColumnType(value) {
+    if (value === null || value === undefined) {
+      return 'TEXT'; // Null değerler için varsayılan
+    }
+    
+    if (typeof value === 'boolean') {
+      return 'BOOLEAN';
+    }
+    
+    if (typeof value === 'number') {
+      if (Number.isInteger(value)) {
+        // Integer range kontrolü
+        if (value >= -32768 && value <= 32767) {
+          return 'SMALLINT';
+        } else if (value >= -2147483648 && value <= 2147483647) {
+          return 'INTEGER';
+        } else {
+          return 'BIGINT';
+        }
+      } else {
+        // Float/Double için
+        return 'DOUBLE PRECISION';
+      }
+    }
+    
+    if (typeof value === 'string') {
+      const length = value.length;
+      if (length <= 255) {
+        return 'VARCHAR(255)';
+      } else {
+        return 'TEXT';
+      }
+    }
+    
+    if (typeof value === 'object') {
+      // Array ve Object'ler JSONB olarak saklanır
+      return 'JSONB';
+    }
+    
+    if (value instanceof Date) {
+      return 'TIMESTAMP';
+    }
+    
+    // Varsayılan
+    return 'TEXT';
+  }
+
+  /**
+   * Birden fazla değere göre en uygun column türünü belirler
+   */
+  _getBestColumnType(values) {
+    const types = values.map(val => this._getColumnType(val));
+    const uniqueTypes = [...new Set(types)];
+    
+    // Eğer hepsi aynı türse, o türü kullan
+    if (uniqueTypes.length === 1) {
+      return uniqueTypes[0];
+    }
+    
+    // Mixed türler için öncelik sırası
+    const typePriority = {
+      'TEXT': 10,
+      'JSONB': 9,
+      'VARCHAR(255)': 8,
+      'TIMESTAMP': 7,
+      'DOUBLE PRECISION': 6,
+      'BIGINT': 5,
+      'INTEGER': 4,
+      'SMALLINT': 3,
+      'BOOLEAN': 2
+    };
+    
+    // En yüksek öncelikli türü seç
+    let bestType = uniqueTypes[0];
+    let bestPriority = typePriority[bestType] || 0;
+    
+    for (const type of uniqueTypes) {
+      const priority = typePriority[type] || 0;
+      if (priority > bestPriority) {
+        bestType = type;
+        bestPriority = priority;
+      }
+    }
+    
+    return bestType;
+  }
+
+  async _queueRequest(operation) {
+    if (this._connected) {
+      return operation();
+    } else {
+      return new Promise((resolve, reject) => {
+        this._queue.push({ operation, resolve, reject });
+      });
+    }
+  }
+
+  async _processQueue() {
+    if (!this._connected) return;
+
+    while (this._queue.length > 0) {
+      const { operation, resolve, reject } = this._queue.shift();
+      try {
+        const result = await operation();
+        resolve(result);
+      } catch (error) {
+        reject(error);
+      }
+    }
+  }
+
+  async query(sql, params = []) {
+    return this._queueRequest(async () => {
+      const pool = await this._connectionPromise;
+      const result = await pool.query(sql, params);
+      return result.rows;
+    });
+  }
+
+  async ensureTable(table, data = {}) {
+    return this._queueRequest(async () => {
+      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 columnDefinitions = Object.keys(data).map(col => {
+          const columnType = this._getColumnType(data[col]);
+          return `"${col}" ${columnType}`;
+        });
+        
+        let columnsPart = '';
+        if (columnDefinitions.length > 0) {
+          columnsPart = ', ' + columnDefinitions.join(", ");
+        }
+        
+        const createTableSQL = `
+          CREATE TABLE "${table}" (
+            "_id" SERIAL PRIMARY KEY
+            ${columnsPart}
+          )
+        `;
+        await this.query(createTableSQL);
+      }
+    });
+  }
+
+  async insert(table, data) {
+    return this._queueRequest(async () => {
+      const copy = { ...data };
+      await this.ensureTable(table, copy);
+      
+      const existingColumns = await this.query(`
+        SELECT column_name, column_default, is_nullable, data_type
+        FROM information_schema.columns 
+        WHERE table_name = $1 AND table_schema = 'public'
+      `, [table]);
+      
+      if (!existingColumns || existingColumns.length === 0) {
+        throw new Error(`Table ${table} does not exist.`);
+      }
+
+      const existingNames = existingColumns.map(col => col.column_name);
+      const primaryKeyColumn = existingColumns.find(col => 
+        col.column_default && col.column_default.includes('nextval')
+      );
+
+      const insertData = { ...copy };
+      // Remove the auto-incrementing primary key from insertData if it's present
+      if (primaryKeyColumn && insertData[primaryKeyColumn.column_name] !== undefined) {
+        delete insertData[primaryKeyColumn.column_name];
+      }
+
+      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((_, index) => `$${index + 1}`).join(",");
+      const values = Object.values(insertData).map(value => this._serializeValue(value));
+      const sql = `INSERT INTO "${table}" (${keys.map(k => `"${k}"`).join(",")}) VALUES (${placeholders}) RETURNING "_id"`;
+
+      const result = await this.query(sql, values);
+      return result[0]._id;
+    });
+  }
+
+  async update(table, data, where) {
+    return this._queueRequest(async () => {
+      await this.ensureTable(table, { ...data, ...where });
+      
+      const existingColumns = await this.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 AND table_schema = 'public'
+      `, [table]);
+      
+      if (!existingColumns || existingColumns.length === 0) {
+        throw new Error(`Table ${table} does not exist.`);
+      }
+
+      const existingColumnNames = existingColumns.map(col => col.column_name);
+      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}`);
+        }
+      }
+
+      const setString = Object.keys(data).map((k, i) => `"${k}" = $${i + 1}`).join(", ");
+      const whereString = Object.keys(where).map((k, i) => `"${k}" = $${Object.keys(data).length + i + 1}`).join(" AND ");
+      const sql = `UPDATE "${table}" SET ${setString} WHERE ${whereString}`;
+      
+      const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where)]);
+      return result.length; // PostgreSQL doesn't return affectedRows in the same way
+    });
+  }
+
+  async delete(table, where) {
+    return this._queueRequest(async () => {
+      if (!where || Object.keys(where).length === 0) return 0;
+      await this.ensureTable(table, { ...where });
+      
+      const whereString = Object.keys(where).map((k, i) => `"${k}" = $${i + 1}`).join(" AND ");
+      const sql = `DELETE FROM "${table}" WHERE ${whereString}`;
+      const result = await this.query(sql, Object.values(where));
+      return result.length;
+    });
+  }
+
+  async select(table, where = null) {
+    return this._queueRequest(async () => {
+      await this.ensureTable(table, where || {});
+      let sql = `SELECT * FROM "${table}"`;
+      let params = [];
+
+      if (where && Object.keys(where).length > 0) {
+        const whereString = Object.keys(where).map((k, i) => `"${k}" = $${i + 1}`).join(" AND ");
+        sql += ` WHERE ${whereString}`;
+        params = Object.values(where);
+      }
+
+      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;
+      });
+    });
+  }
+
+  async set(table, data, where) {
+    return this._queueRequest(async () => {
+      await this.ensureTable(table, { ...data, ...where });
+      
+      const existingColumns = await this.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 AND table_schema = 'public'
+      `, [table]);
+      
+      if (!existingColumns || existingColumns.length === 0) {
+        throw new Error(`Table ${table} does not exist.`);
+      }
+
+      const existingColumnNames = existingColumns.map(col => col.column_name);
+      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}`);
+        }
+      }
+
+      const existing = await this.select(table, where);
+      if (existing.length === 0) {
+        return await this.insert(table, { ...where, ...data });
+      } else {
+        return await this.update(table, data, where);
+      }
+    });
+  }
+
+  async selectOne(table, where = null) {
+    return this._queueRequest(async () => {
+      const results = await this.select(table, where);
+      if (results[0]) {
+        const newResult = {};
+        for (const key in results[0]) {
+          newResult[key] = this._deserializeValue(results[0][key]);
+        }
+        return newResult;
+      }
+      return null;
+    });
+  }
+
+  async deleteOne(table, where) {
+    return this._queueRequest(async () => {
+      const row = await this.selectOne(table, where);
+      if (!row) return 0;
+      
+      const whereString = Object.keys(where).map((k, i) => `"${k}" = $${i + 1}`).join(" AND ");
+      const sql = `DELETE FROM "${table}" WHERE ${whereString} AND ctid = (SELECT ctid FROM "${table}" WHERE ${whereString} LIMIT 1)`;
+      const result = await this.query(sql, [...Object.values(where), ...Object.values(where)]);
+      return result.length;
+    });
+  }
+
+  async updateOne(table, data, where) {
+    return this._queueRequest(async () => {
+      await this.ensureTable(table, { ...data, ...where });
+      
+      const existingColumns = await this.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 AND table_schema = 'public'
+      `, [table]);
+      
+      if (!existingColumns || existingColumns.length === 0) {
+        throw new Error(`Table ${table} does not exist.`);
+      }
+
+      const existingColumnNames = existingColumns.map(col => col.column_name);
+      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}`);
+        }
+      }
+
+      const setString = Object.keys(data).map((k, i) => `"${k}" = $${i + 1}`).join(", ");
+      const whereString = Object.keys(where).map((k, i) => `"${k}" = $${Object.keys(data).length + i + 1}`).join(" AND ");
+      const sql = `UPDATE "${table}" SET ${setString} WHERE ${whereString} AND ctid = (SELECT ctid FROM "${table}" WHERE ${whereString} LIMIT 1)`;
+      
+      const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where), ...Object.values(where)]);
+      return result.length;
+    });
+  }
+
+  async bulkInsert(table, dataArray) {
+    return this._queueRequest(async () => {
+      if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
+      await this.ensureTable(table, dataArray[0]);
+
+      const existingColumns = await this.query(`
+        SELECT column_name 
+        FROM information_schema.columns 
+        WHERE table_name = $1 AND table_schema = 'public'
+      `, [table]);
+      
+      const existingColumnNames = existingColumns.map(col => col.column_name);
+      const keys = Object.keys(dataArray[0]);
+
+      // Eksik kolonları kontrol et ve ekle
+      for (const key of keys) {
+        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 columnType = columnValues.length > 0 ? this._getBestColumnType(columnValues) : 'TEXT';
+          await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${columnType}`);
+        }
+      }
+
+      // PostgreSQL için VALUES clause oluştur
+      const placeholders = dataArray.map((_, rowIndex) => 
+        `(${keys.map((_, colIndex) => `$${rowIndex * keys.length + colIndex + 1}`).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}`;
+
+      const result = await this.query(sql, values);
+      return result.length;
+    });
+  }
+
+  async close() {
+    if (this.pool) await this.pool.end();
+  }
+
+  // Helper to serialize values for storage
+  _serializeValue(value) {
+    if (value instanceof Date) {
+      return value.toISOString(); // PostgreSQL TIMESTAMP format
+    }
+    if (Array.isArray(value) || (typeof value === 'object' && value !== null)) {
+      return JSON.stringify(value); // PostgreSQL will handle JSONB conversion
+    }
+    return value;
+  }
+
+  // Helper to deserialize values after retrieval
+  _deserializeValue(value) {
+    // PostgreSQL JSONB columns are automatically parsed by pg driver
+    // No need for manual JSON parsing unlike MySQL
+    return value;
+  }
+}
+
+module.exports = PostgreSQLDatabase;

package/database/sqlite.js

@@ -33,6 +33,93 @@ class SQLiteDatabase extends IDatabase{
     });
   }
 
+  /**
+   * Değerin türünü otomatik olarak tespit eder ve SQLite türünü döndürür.
+   * @param {any} value - Kontrol edilecek değer
+   * @returns {string} SQLite veri türü
+   */
+  _detectColumnType(value) {
+    if (value === null || value === undefined) {
+      return 'TEXT'; // Varsayılan olarak TEXT
+    }
+
+    // Boolean kontrolü
+    if (typeof value === 'boolean') {
+      return 'BOOLEAN';
+    }
+
+    // Number kontrolü
+    if (typeof value === 'number') {
+      // Tam sayı mı ondalık mı kontrol et
+      if (Number.isInteger(value)) {
+        return 'INTEGER';
+      } else {
+        return 'REAL';
+      }
+    }
+
+    // Date kontrolü
+    if (value instanceof Date) {
+      return 'DATETIME';
+    }
+
+    // String kontrolü - sayısal string'leri kontrol et
+    if (typeof value === 'string') {
+      // Boş string kontrolü
+      if (value.trim() === '') {
+        return 'TEXT';
+      }
+
+      // Tam sayı string kontrolü
+      if (/^-?\d+$/.test(value.trim())) {
+        return 'INTEGER';
+      }
+
+      // Ondalık sayı string kontrolü
+      if (/^-?\d+\.\d+$/.test(value.trim())) {
+        return 'REAL';
+      }
+
+      // Boolean string kontrolü
+      const lowerValue = value.toLowerCase().trim();
+      if (lowerValue === 'true' || lowerValue === 'false') {
+        return 'BOOLEAN';
+      }
+
+      // ISO date string kontrolü
+      if (value.match(/^\d{4}-\d{2}-\d{2}/) || value.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)) {
+        return 'DATETIME';
+      }
+    }
+
+    // Varsayılan olarak TEXT
+    return 'TEXT';
+  }
+
+  /**
+   * Birden fazla değerden en uygun sütun türünü belirler.
+   * @param {Array} values - Değer dizisi
+   * @returns {string} En uygun SQLite veri türü
+   */
+  _determineBestColumnType(values) {
+    const types = values.map(v => this._detectColumnType(v));
+    
+    // Tür öncelik sırası: INTEGER < REAL < BOOLEAN < DATETIME < TEXT
+    const typePriority = {
+      'INTEGER': 1,
+      'REAL': 2,
+      'BOOLEAN': 3,
+      'DATETIME': 4,
+      'TEXT': 5
+    };
+
+    // En yüksek öncelikli türü seç
+    const maxPriority = Math.max(...types.map(t => typePriority[t] || 5));
+    const bestType = Object.keys(typePriority).find(t => typePriority[t] === maxPriority);
+    
+    return bestType || 'TEXT';
+  }
+
   /**
    * SQL sorgusu çalıştırır. Promise döndürür.
    * @param {string} sql - Çalıştırılacak SQL sorgusu.
@@ -62,16 +149,26 @@ class SQLiteDatabase extends IDatabase{
    * @param {object} data - Tablo oluşturulurken sütunları belirlemek için örnek veri.
    */
   async ensureTable(table, data = {}) {
-    
-
     try {
       await this.query(`SELECT 1 FROM \`${table}\` LIMIT 1`);
     } catch (error) {
       if (error.message.includes('no such table')) {
         const columnDefinitions = Object.keys(data).map(col => {
-          const columnType = col.startsWith('int_') ? 'INTEGER' : 'TEXT';
+          const columnType = this._detectColumnType(data[col]);
           return `\`${col}\` ${columnType}`;
-        });        let columnsPart = '';        if (columnDefinitions.length > 0) {          columnsPart = ', ' + columnDefinitions.join(", ");        }        const createTableSQL = `          CREATE TABLE \`${table}\` (            _id INTEGER PRIMARY KEY AUTOINCREMENT            ${columnsPart}          )        `;
+        });
+        
+        let columnsPart = '';
+        if (columnDefinitions.length > 0) {
+          columnsPart = ', ' + columnDefinitions.join(", ");
+        }
+        
+        const createTableSQL = `
+          CREATE TABLE \`${table}\` (
+            _id INTEGER PRIMARY KEY AUTOINCREMENT
+            ${columnsPart}
+          )
+        `;
         await this.query(createTableSQL);
       } else {
         throw error;
@@ -89,7 +186,8 @@ class SQLiteDatabase extends IDatabase{
 
     for (const key of Object.keys(data)) {
       if (!existingNames.includes(key)) {
-        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${key.startsWith('int_') ? 'INTEGER' : 'TEXT'}`);
+        const columnType = this._detectColumnType(data[key]);
+        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` ${columnType}`);
       }
     }
   }
@@ -214,8 +312,14 @@ class SQLiteDatabase extends IDatabase{
    */
   async bulkInsert(table, dataArray) {
     if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
+    
+    // İlk elemanı tablo oluşturmak için kullan
     await this.ensureTable(table, dataArray[0]);
-    await this._ensureColumns(table, dataArray[0]);
+    
+    // Tüm elemanların sütunlarını kontrol et
+    for (const item of dataArray) {
+      await this._ensureColumns(table, item);
+    }
 
     const keys = Object.keys(dataArray[0]);
     const placeholders = keys.map(() => '?').join(',');
@@ -247,4 +351,4 @@ class SQLiteDatabase extends IDatabase{
   }
 }
 
-module.exports = SQLiteDatabase;
+module.exports = SQLiteDatabase;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "6.1.0",
+  "version": "7.0.0",
   "main": "index.js",
   "scripts": {
     "test": "node test.js"

package/readme.md

@@ -239,6 +239,17 @@ const mongoDb = createDatabase({
         database: 'my_app_mongo'
     }
 });
+
+// --- 5. Using PG ---
+const mongoDb = createDatabase({
+    adapter: 'postgres',
+    config: {
+    host: 'localhost',
+    user: 'root',
+    password: 'your_password',
+    database: 'my_app_prod'
+  }
+});
 ```
 
 ### Basic Operations (CRUD)