@onurege3467/zerohelper 7.1.0 → 8.0.0

package/database/redis.js

@@ -0,0 +1,342 @@
+// redis.js - Redis Database Adapter (v4.x Uyumlu)
+const { createClient } = require('redis');
+
+class RedisDatabase {
+    constructor(config = {}) {
+        this.config = {
+            host: config.host || '127.0.0.1',
+            port: config.port || 6379,
+            password: config.password,
+            db: config.db || 0,
+            connectTimeout: config.connectTimeout || 5000,
+            commandTimeout: config.commandTimeout || 5000,
+        };
+
+        this.keyPrefix = config.keyPrefix || 'app:';
+        this.client = null;
+        this.isConnecting = false; // Eşzamanlı bağlantı girişimlerini önlemek için
+    }
+
+    async connect() {
+        if (this.client && this.client.isReady) {
+            return this.client;
+        }
+
+        // Eğer zaten bağlantı girişimi yapılıyorsa, bekle
+        if (this.isConnecting) {
+            while (this.isConnecting) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            return this.client;
+        }
+
+        this.isConnecting = true;
+
+        try {
+            this.client = createClient({
+                socket: {
+                    host: this.config.host,
+                    port: this.config.port,
+                    connectTimeout: this.config.connectTimeout,
+                },
+                password: this.config.password,
+                database: this.config.db,
+            });
+
+            this.client.on('error', (err) => {
+                console.error('Redis Error:', err.message);
+            });
+
+            //this.client.on('connect', () => console.log('Redis Connected'));
+            //this.client.on('ready', () => console.log('Redis Ready'));
+            this.client.on('end', () => {
+                console.log('Redis Connection Ended');
+                this.client = null;
+            });
+
+            // Timeout ile bağlantı kontrolü
+            await Promise.race([
+                this.client.connect(),
+                               new Promise((_, reject) =>
+                               setTimeout(() => reject(new Error('Redis connection timeout')), this.config.connectTimeout)
+                               ),
+            ]);
+
+            console.log('Redis bağlantısı başarılı');
+        } catch (err) {
+            this.client = null;
+            throw new Error(`Redis bağlantısı başarısız: ${err.message}`);
+        } finally {
+            this.isConnecting = false;
+        }
+
+        return this.client;
+    }
+
+    _getKey(table, id) {
+        return `${this.keyPrefix}${table}:${id}`;
+    }
+
+    _getTableKey(table) {
+        return `${this.keyPrefix}${table}:*`;
+    }
+
+    async select(table, where = {}) {
+        try {
+            const client = await this.connect();
+            const pattern = this._getTableKey(table);
+            const keys = await client.keys(pattern);
+
+            if (!keys.length) return [];
+
+            const values = await client.mGet(keys);
+            return values
+            .map(v => {
+                try {
+                    return v ? JSON.parse(v) : null;
+                } catch (parseErr) {
+                    console.error('JSON parse error:', parseErr);
+                    return null;
+                }
+            })
+            .filter(Boolean)
+            .filter(item => Object.entries(where).every(([k, val]) => item[k] === val));
+        } catch (err) {
+            console.error('Select error:', err);
+            throw err;
+        }
+    }
+
+    async selectOne(table, where = {}) {
+        const results = await this.select(table, where);
+        return results.length ? results[0] : null;
+    }
+
+    async insert(table, data) {
+        try {
+            const client = await this.connect();
+            const insertData = { ...data };
+
+            if (!insertData.id) {
+                insertData.id = Date.now().toString() + Math.random().toString(36).slice(2, 9);
+            }
+
+            const key = this._getKey(table, insertData.id);
+            await client.set(key, JSON.stringify(insertData));
+            return insertData;
+        } catch (err) {
+            console.error('Insert error:', err);
+            throw err;
+        }
+    }
+
+    async update(table, data, where) {
+        try {
+            const existing = await this.select(table, where);
+            if (!existing.length) return [];
+
+            const client = await this.connect();
+            const updated = [];
+
+            for (const item of existing) {
+                const merged = { ...item, ...data };
+                await client.set(this._getKey(table, item.id), JSON.stringify(merged));
+                updated.push(merged);
+            }
+            return updated;
+        } catch (err) {
+            console.error('Update error:', err);
+            throw err;
+        }
+    }
+
+    async updateOne(table, data, where) {
+        const results = await this.update(table, data, where);
+        return results.length ? results[0] : null;
+    }
+
+    async set(table, data, where) {
+        try {
+            const existing = await this.selectOne(table, where);
+            if (existing) {
+                return await this.updateOne(table, data, where);
+            } else {
+                return await this.insert(table, { ...data, ...where });
+            }
+        } catch (err) {
+            console.error('Set error:', err);
+            throw err;
+        }
+    }
+
+    async delete(table, where) {
+        try {
+            const existing = await this.select(table, where);
+            if (!existing.length) return [];
+
+            const client = await this.connect();
+            const keys = existing.map(item => this._getKey(table, item.id));
+            await client.del(keys);
+            return existing;
+        } catch (err) {
+            console.error('Delete error:', err);
+            throw err;
+        }
+    }
+
+    async deleteOne(table, where) {
+        const results = await this.delete(table, where);
+        return results.length ? results[0] : null;
+    }
+
+    async bulkInsert(table, dataArray) {
+        if (!Array.isArray(dataArray) || !dataArray.length) {
+            return [];
+        }
+
+        try {
+            const results = [];
+            for (const data of dataArray) {
+                results.push(await this.insert(table, data));
+            }
+            return results;
+        } catch (err) {
+            console.error('Bulk insert error:', err);
+            throw err;
+        }
+    }
+
+    async ensureTable(table) {
+        // Redis'te tablo kavramı yoktur, her zaman true döner
+        return true;
+    }
+
+    async close() {
+        if (this.client) {
+            try {
+                await this.client.quit();
+            } catch (err) {
+                console.error('Redis close error:', err);
+            } finally {
+                this.client = null;
+            }
+        }
+    }
+
+    async ping() {
+        try {
+            const client = await this.connect();
+            return await client.ping();
+        } catch (err) {
+            console.error('Ping error:', err);
+            throw err;
+        }
+    }
+
+    async flushTable(table) {
+        try {
+            const client = await this.connect();
+            const pattern = this._getTableKey(table);
+            const keys = await client.keys(pattern);
+
+            if (keys.length > 0) {
+                await client.del(keys);
+            }
+
+            return keys.length;
+        } catch (err) {
+            console.error('Flush table error:', err);
+            throw err;
+        }
+    }
+
+    // Yardımcı metodlar
+    async getStats(table) {
+        try {
+            const client = await this.connect();
+            const pattern = this._getTableKey(table);
+            const keys = await client.keys(pattern);
+            return {
+                table,
+                keyCount: keys.length,
+                pattern
+            };
+        } catch (err) {
+            console.error('Get stats error:', err);
+            throw err;
+        }
+    }
+
+    async exists(table, where) {
+        const result = await this.selectOne(table, where);
+        return result !== null;
+    }
+
+    /**
+     * Numerik alanları artırır (increment).
+     * Redis için hash field'ları üzerinde HINCRBY kullanır.
+     * @param {string} table - Verinin güncelleneceği tablo adı.
+     * @param {object} increments - Artırılacak alanlar ve miktarları.
+     * @param {object} where - Güncelleme koşulları.
+     * @returns {Promise<number>} Etkilenen kayıt sayısı.
+     */
+    async increment(table, increments, where = {}) {
+        try {
+            const client = await this.connect();
+            
+            // Önce mevcut kayıtları bul
+            const existingRecords = await this.select(table, where);
+            let affectedCount = 0;
+            
+            for (const record of existingRecords) {
+                const key = this._getRecordKey(table, record._id);
+                
+                // Her increment field için HINCRBY kullan
+                for (const [field, value] of Object.entries(increments)) {
+                    await client.hIncrBy(key, field, value);
+                }
+                affectedCount++;
+            }
+            
+            return affectedCount;
+        } catch (err) {
+            console.error('Increment error:', err);
+            throw err;
+        }
+    }
+
+    /**
+     * Numerik alanları azaltır (decrement).
+     * Redis için hash field'ları üzerinde HINCRBY ile negatif değer kullanır.
+     * @param {string} table - Verinin güncelleneceği tablo adı.
+     * @param {object} decrements - Azaltılacak alanlar ve miktarları.
+     * @param {object} where - Güncelleme koşulları.
+     * @returns {Promise<number>} Etkilenen kayıt sayısı.
+     */
+    async decrement(table, decrements, where = {}) {
+        try {
+            const client = await this.connect();
+            
+            // Önce mevcut kayıtları bul
+            const existingRecords = await this.select(table, where);
+            let affectedCount = 0;
+            
+            for (const record of existingRecords) {
+                const key = this._getRecordKey(table, record._id);
+                
+                // Her decrement field için HINCRBY ile negatif değer kullan
+                for (const [field, value] of Object.entries(decrements)) {
+                    await client.hIncrBy(key, field, -value);
+                }
+                affectedCount++;
+            }
+            
+            return affectedCount;
+        } catch (err) {
+            console.error('Decrement error:', err);
+            throw err;
+        }
+    }
+}
+
+module.exports = RedisDatabase;

package/database/sqlite.js

@@ -466,6 +466,75 @@ class SQLiteDatabase extends IDatabase{
     });
   }
 
+  /**
+   * WHERE clause oluşturur
+   * @param {object} where - WHERE koşulları
+   * @returns {object} - whereClause string ve values array
+   */
+  buildWhereClause(where = {}) {
+    const conditions = Object.keys(where);
+    if (conditions.length === 0) {
+      return { whereClause: '', values: [] };
+    }
+    
+    const whereClause = ' WHERE ' + conditions.map(key => `${key} = ?`).join(' AND ');
+    const values = Object.values(where);
+    
+    return { whereClause, values };
+  }
+
+  /**
+   * Numerik alanları artırır (increment).
+   * @param {string} table - Verinin güncelleneceği tablo adı.
+   * @param {object} increments - Artırılacak alanlar ve miktarları.
+   * @param {object} where - Güncelleme koşulları.
+   * @returns {Promise<number>} Etkilenen kayıt sayısı.
+   */
+  async increment(table, increments, where = {}) {
+    const incrementClauses = Object.keys(increments).map(field => 
+      `${field} = ${field} + ?`
+    ).join(', ');
+    
+    const incrementValues = Object.values(increments);
+    const { whereClause, values: whereValues } = this.buildWhereClause(where);
+    
+    const sql = `UPDATE ${table} SET ${incrementClauses}${whereClause}`;
+    const allValues = [...incrementValues, ...whereValues];
+    
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, allValues, function(err) {
+        if (err) reject(err);
+        else resolve(this.changes);
+      });
+    });
+  }
+
+  /**
+   * Numerik alanları azaltır (decrement).
+   * @param {string} table - Verinin güncelleneceği tablo adı.
+   * @param {object} decrements - Azaltılacak alanlar ve miktarları.
+   * @param {object} where - Güncelleme koşulları.
+   * @returns {Promise<number>} Etkilenen kayıt sayısı.
+   */
+  async decrement(table, decrements, where = {}) {
+    const decrementClauses = Object.keys(decrements).map(field => 
+      `${field} = ${field} - ?`
+    ).join(', ');
+    
+    const decrementValues = Object.values(decrements);
+    const { whereClause, values: whereValues } = this.buildWhereClause(where);
+    
+    const sql = `UPDATE ${table} SET ${decrementClauses}${whereClause}`;
+    const allValues = [...decrementValues, ...whereValues];
+    
+    return new Promise((resolve, reject) => {
+      this.db.run(sql, allValues, function(err) {
+        if (err) reject(err);
+        else resolve(this.changes);
+      });
+    });
+  }
+
   /**
    * Veritabanı bağlantısını kapatır.
    */

package/functions/index.js

@@ -372,6 +372,256 @@ function generateSlug(text) {
 function wordCount(text) {
   return text.trim().split(/\s+/).length;
 }
+
+// Validasyon İşlemleri
+function isEmail(email) {
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailRegex.test(email);
+}
+
+function isPhone(phone) {
+  const phoneRegex = /^[\+]?[1-9][\d]{0,15}$/;
+  return phoneRegex.test(phone.replace(/[\s\-\(\)]/g, ''));
+}
+
+function isURL(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sanitizeHTML(html) {
+  return html
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+    .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, '')
+    .replace(/javascript:/gi, '')
+    .replace(/on\w+\s*=/gi, '');
+}
+
+function validateCreditCard(cardNumber) {
+  // Luhn algoritması
+  const cleanNumber = cardNumber.replace(/\D/g, '');
+  if (cleanNumber.length < 13 || cleanNumber.length > 19) return false;
+  
+  let sum = 0;
+  let isEven = false;
+  
+  for (let i = cleanNumber.length - 1; i >= 0; i--) {
+    let digit = parseInt(cleanNumber[i]);
+    
+    if (isEven) {
+      digit *= 2;
+      if (digit > 9) digit -= 9;
+    }
+    
+    sum += digit;
+    isEven = !isEven;
+  }
+  
+  return sum % 10 === 0;
+}
+
+function validateSchema(data, schema) {
+  const errors = [];
+  
+  for (const [key, rules] of Object.entries(schema)) {
+    const value = data[key];
+    
+    if (rules.required && (value === undefined || value === null || value === '')) {
+      errors.push(`${key} alanı zorunludur`);
+      continue;
+    }
+    
+    if (value !== undefined && value !== null) {
+      if (rules.type && typeof value !== rules.type) {
+        errors.push(`${key} alanı ${rules.type} tipinde olmalıdır`);
+      }
+      
+      if (rules.minLength && value.length < rules.minLength) {
+        errors.push(`${key} en az ${rules.minLength} karakter olmalıdır`);
+      }
+      
+      if (rules.maxLength && value.length > rules.maxLength) {
+        errors.push(`${key} en fazla ${rules.maxLength} karakter olmalıdır`);
+      }
+      
+      if (rules.pattern && !rules.pattern.test(value)) {
+        errors.push(`${key} geçerli formatta değil`);
+      }
+      
+      if (rules.min && value < rules.min) {
+        errors.push(`${key} en az ${rules.min} olmalıdır`);
+      }
+      
+      if (rules.max && value > rules.max) {
+        errors.push(`${key} en fazla ${rules.max} olmalıdır`);
+      }
+    }
+  }
+  
+  return {
+    isValid: errors.length === 0,
+    errors
+  };
+}
+
+function sanitizeInput(input, options = {}) {
+  if (typeof input !== 'string') return input;
+  
+  let sanitized = input;
+  
+  if (options.trim !== false) {
+    sanitized = sanitized.trim();
+  }
+  
+  if (options.removeHTML) {
+    sanitized = sanitizeHTML(sanitized);
+  }
+  
+  if (options.escape) {
+    sanitized = sanitized
+      .replace(/&/g, '&amp;')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#x27;');
+  }
+  
+  return sanitized;
+}
+
+// Logger İşlemleri
+class Logger {
+  constructor(options = {}) {
+    this.level = options.level || 'info';
+    this.enableColors = options.enableColors !== false;
+    this.enableTimestamp = options.enableTimestamp !== false;
+    this.logFile = options.logFile || null;
+    this.levels = {
+      error: 0,
+      warn: 1, 
+      info: 2,
+      debug: 3
+    };
+    this.colors = {
+      error: '\x1b[31m',  // Red
+      warn: '\x1b[33m',   // Yellow
+      info: '\x1b[36m',   // Cyan
+      debug: '\x1b[35m',  // Magenta
+      reset: '\x1b[0m'
+    };
+  }
+
+  shouldLog(level) {
+    return this.levels[level] <= this.levels[this.level];
+  }
+
+  formatMessage(level, message, data) {
+    let formatted = '';
+    
+    if (this.enableTimestamp) {
+      formatted += `[${new Date().toISOString()}] `;
+    }
+    
+    if (this.enableColors) {
+      formatted += `${this.colors[level]}[${level.toUpperCase()}]${this.colors.reset} `;
+    } else {
+      formatted += `[${level.toUpperCase()}] `;
+    }
+    
+    formatted += message;
+    
+    if (data !== undefined) {
+      formatted += ' ' + (typeof data === 'object' ? JSON.stringify(data, null, 2) : data);
+    }
+    
+    return formatted;
+  }
+
+  writeToFile(message) {
+    if (this.logFile) {
+      const fs = require('fs');
+      const timestamp = new Date().toISOString();
+      const logEntry = `${timestamp} ${message}\n`;
+      
+      try {
+        fs.appendFileSync(this.logFile, logEntry);
+      } catch (error) {
+        console.error('Log dosyasına yazılamadı:', error.message);
+      }
+    }
+  }
+
+  log(level, message, data) {
+    if (!this.shouldLog(level)) return;
+    
+    const formatted = this.formatMessage(level, message, data);
+    
+    if (level === 'error') {
+      console.error(formatted);
+    } else if (level === 'warn') {
+      console.warn(formatted);
+    } else {
+      console.log(formatted);
+    }
+    
+    this.writeToFile(formatted);
+  }
+
+  error(message, data) {
+    this.log('error', message, data);
+  }
+
+  warn(message, data) {
+    this.log('warn', message, data);
+  }
+
+  info(message, data) {
+    this.log('info', message, data);
+  }
+
+  debug(message, data) {
+    this.log('debug', message, data);
+  }
+
+  setLevel(level) {
+    if (this.levels.hasOwnProperty(level)) {
+      this.level = level;
+    } else {
+      throw new Error(`Geçersiz log seviyesi: ${level}`);
+    }
+  }
+
+  getLevel() {
+    return this.level;
+  }
+}
+
+function createLogger(options = {}) {
+  return new Logger(options);
+}
+
+// Varsayılan logger instance
+const defaultLogger = new Logger();
+
+function logInfo(message, data) {
+  defaultLogger.info(message, data);
+}
+
+function logError(message, data) {
+  defaultLogger.error(message, data);
+}
+
+function logWarn(message, data) {
+  defaultLogger.warn(message, data);
+}
+
+function logDebug(message, data) {
+  defaultLogger.debug(message, data);
+}
 // Exportlar
 module.exports = {
   http: {
@@ -435,4 +685,21 @@ module.exports = {
     combination,
     permutation,
   },
+  validation: {
+    isEmail,
+    isPhone,
+    isURL,
+    sanitizeHTML,
+    validateCreditCard,
+    validateSchema,
+    sanitizeInput,
+  },
+  logger: {
+    createLogger,
+    Logger,
+    info: logInfo,
+    error: logError,
+    warn: logWarn,
+    debug: logDebug,
+  },
 };