@onurege3467/zerohelper 8.0.0 → 9.0.0

package/functions/index.js

@@ -1,705 +0,0 @@
-const crypto = require("crypto");
-const jwt = require("jsonwebtoken");
-const bcrypt = require("bcrypt");
-
-// Random İşlemler
-function makeUniqueId() {
-  return Date.now().toString(36) + Math.random().toString(36).substr(2);
-}
-
-function randomArray(arr) {
-  return arr[Math.floor(Math.random() * arr.length)];
-}
-
-function randomText(length = 8) {
-  const characters =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  return Array.from({ length }, () =>
-    characters.charAt(Math.floor(Math.random() * characters.length))
-  ).join("");
-}
-
-function randomNumber(min = 0, max = 9999999) {
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-function randomEmoji() {
-  const emojiler = [
-    "😄",
-    "😃",
-    "😀",
-    "😊",
-    "😉",
-    "😍",
-    "😘",
-    "😚",
-    "😜",
-    "😝",
-    "😛",
-    "😁",
-  ];
-  return emojiler[Math.floor(Math.random() * emojiler.length)];
-}
-
-function randomHex() {
-  return `#${Array.from({ length: 6 }, () =>
-    "0123456789ABCDEF".charAt(Math.floor(Math.random() * 16))
-  ).join("")}`;
-}
-
-function randomFloat(min, max) {
-  return Math.random() * (max - min) + min;
-}
-
-// String İşlemleri
-function titleCase(sentence) {
-  return sentence
-    .toLowerCase()
-    .split(" ")
-    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
-    .join(" ");
-}
-
-// Array İşlemleri
-function shuffleArray(array) {
-  let currentIndex = array.length;
-  while (currentIndex !== 0) {
-    const randomIndex = Math.floor(Math.random() * currentIndex);
-    currentIndex--;
-    [array[currentIndex], array[randomIndex]] = [
-      array[randomIndex],
-      array[currentIndex],
-    ];
-  }
-  return array;
-}
-
-function flattenArray(arr) {
-  return arr.reduce(
-    (flat, toFlatten) =>
-      flat.concat(
-        Array.isArray(toFlatten) ? flattenArray(toFlatten) : toFlatten
-      ),
-    []
-  );
-}
-
-function removeFalsyValues(arr) {
-  return arr.filter(Boolean);
-}
-
-function groupBy(arr, key) {
-  return arr.reduce((result, item) => {
-    const group = item[key];
-    if (!result[group]) result[group] = [];
-    result[group].push(item);
-    return result;
-  }, {});
-}
-
-function pluck(arr, key) {
-  return arr.map((item) => item[key]);
-}
-
-function sortBy(arr, key) {
-  return [...arr].sort((a, b) => (a[key] > b[key] ? 1 : -1));
-}
-
-// Object İşlemleri
-function filterObjectByKey(obj, keys) {
-  return Object.fromEntries(
-    Object.entries(obj).filter(([key]) => keys.includes(key))
-  );
-}
-
-function deepMerge(obj1, obj2) {
-  const isObject = (obj) => obj && typeof obj === "object";
-  return Object.keys({ ...obj1, ...obj2 }).reduce((result, key) => {
-    result[key] =
-      isObject(obj1[key]) && isObject(obj2[key])
-        ? deepMerge(obj1[key], obj2[key])
-        : obj2[key] ?? obj1[key];
-    return result;
-  }, {});
-}
-
-// Ş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 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 { encryptedText: encrypted, iv: iv.toString('hex') };
-}
-
-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;
-}
-
-function hashPassword(password) {
-  const saltRounds = 10;
-  return bcrypt.hashSync(password, saltRounds);
-}
-
-function verifyPassword(password, hash) {
-  return bcrypt.compareSync(password, hash);
-}
-
-function generateJWT(payload, secret) {
-  return jwt.sign(payload, secret, { expiresIn: "1h" });
-}
-
-function verifyJWT(token, secret) {
-  try {
-    return jwt.verify(token, secret);
-  } catch {
-    return null;
-  }
-}
-
-function generateSalt() {
-  return crypto.randomBytes(16).toString("hex");
-}
-
-function generateRandomString(length) {
-  const characters =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  return Array.from({ length }, () =>
-    characters.charAt(Math.floor(Math.random() * characters.length))
-  ).join("");
-}
-
-function validateUUID(uuid) {
-  const uuidRegex =
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-  return uuidRegex.test(uuid);
-}
-
-function isPasswordStrong(password) {
-  const strongPasswordRegex =
-    /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;
-  return strongPasswordRegex.test(password);
-}
-
-// Matematiksel İşlemler
-function mean(arr) {
-  if (!arr.length) return 0;
-  return arr.reduce((sum, num) => sum + num, 0) / arr.length;
-}
-
-function median(arr) {
-  if (!arr.length) return 0;
-  const sorted = [...arr].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-  return sorted.length % 2 !== 0
-    ? sorted[mid]
-    : (sorted[mid - 1] + sorted[mid]) / 2;
-}
-
-function variance(arr) {
-  if (!arr.length) return 0;
-  const avg = mean(arr);
-  return arr.reduce((sum, num) => sum + Math.pow(num - avg, 2), 0) / arr.length;
-}
-
-function standardDeviation(arr) {
-  return Math.sqrt(variance(arr));
-}
-
-function sum(arr) {
-  return arr.reduce((total, num) => total + num, 0);
-}
-
-function max(arr) {
-  return Math.max(...arr);
-}
-
-function min(arr) {
-  return Math.min(...arr);
-}
-
-function range(start, end) {
-  if (start > end) return [];
-  return Array.from({ length: end - start + 1 }, (_, i) => start + i);
-}
-
-function isPrime(num) {
-  if (num <= 1) return false;
-  if (num <= 3) return true;
-  if (num % 2 === 0 || num % 3 === 0) return false;
-  for (let i = 5; i * i <= num; i += 6) {
-    if (num % i === 0 || num % (i + 2) === 0) return false;
-  }
-  return true;
-}
-// Tarih ve Saat İşlemleri
-function formatDate(date, format = "YYYY-MM-DD") {
-  const options = {
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit",
-  };
-  const formattedDate = new Intl.DateTimeFormat("en-US", options).format(date);
-  const [month, day, year, hour, minute, second] = formattedDate.match(/\d+/g);
-
-  return format
-    .replace("YYYY", year)
-    .replace("MM", month)
-    .replace("DD", day)
-    .replace("HH", hour)
-    .replace("mm", minute)
-    .replace("ss", second);
-}
-
-function dateDifference(date1, date2) {
-  const diffTime = Math.abs(date2 - date1);
-  return Math.ceil(diffTime / (1000 * 60 * 60 * 24)); // Gün cinsinden fark
-}
-
-function addDays(date, days) {
-  const result = new Date(date);
-  result.setDate(result.getDate() + days);
-  return result;
-}
-
-function subtractDays(date, days) {
-  const result = new Date(date);
-  result.setDate(result.getDate() - days);
-  return result;
-}
-
-function combination(n, r) {
-  return factorial(n) / (factorial(r) * factorial(n - r));
-}
-
-function permutation(n, r) {
-  return factorial(n) / factorial(n - r);
-}
-const https = require("https");
-const http = require("http");
-
-function fetchData(url) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith("https") ? https : http;
-
-    client
-      .get(url, (response) => {
-        let data = "";
-
-        // Gelen veriyi parça parça topluyoruz
-        response.on("data", (chunk) => {
-          data += chunk;
-        });
-
-        // Veri tamamen alındığında çözümleme yapıyoruz
-        response.on("end", () => {
-          try {
-            resolve(JSON.parse(data));
-          } catch (error) {
-            resolve(data); // JSON değilse düz metin döndür
-          }
-        });
-      })
-      .on("error", (error) => {
-        reject(error);
-      });
-  });
-}
-
-function postData(url, data) {
-  return new Promise((resolve, reject) => {
-    const client = url.startsWith("https") ? https : http;
-    const parsedUrl = new URL(url);
-
-    const options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port || (url.startsWith("https") ? 443 : 80),
-      path: parsedUrl.pathname,
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Content-Length": Buffer.byteLength(JSON.stringify(data)),
-      },
-    };
-
-    const req = client.request(options, (response) => {
-      let responseData = "";
-
-      response.on("data", (chunk) => {
-        responseData += chunk;
-      });
-
-      response.on("end", () => {
-        try {
-          resolve(JSON.parse(responseData));
-        } catch (error) {
-          resolve(responseData); // JSON değilse düz metin döndür
-        }
-      });
-    });
-
-    req.on("error", (error) => {
-      reject(error);
-    });
-
-    // Gönderilecek veriyi yazıyoruz
-    req.write(JSON.stringify(data));
-    req.end();
-  });
-}
-
-function generateSlug(text) {
-  return text
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-}
-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: {
-    fetchData,
-    postData,
-  },
-  date: {
-    formatDate,
-    dateDifference,
-    addDays,
-    subtractDays,
-  },
-  random: {
-    makeUniqueId,
-    randomArray,
-    randomText,
-    randomNumber,
-    randomEmoji,
-    randomHex,
-    randomFloat,
-  },
-  string: {
-    titleCase,
-    generateRandomString,
-    generateSlug,
-    wordCount,
-  },
-  array: {
-    shuffleArray,
-    flattenArray,
-    removeFalsyValues,
-    groupBy,
-    pluck,
-    sortBy,
-  },
-  object: {
-    filterObjectByKey,
-    deepMerge,
-  },
-  crypto: {
-    encryptText,
-    decryptText,
-    hashPassword,
-    verifyPassword,
-    generateJWT,
-    verifyJWT,
-    generateSalt,
-    validateUUID,
-    isPasswordStrong,
-  },
-  math: {
-    mean,
-    median,
-    variance,
-    standardDeviation,
-    sum,
-    max,
-    min,
-    range,
-    isPrime,
-    combination,
-    permutation,
-  },
-  validation: {
-    isEmail,
-    isPhone,
-    isURL,
-    sanitizeHTML,
-    validateCreditCard,
-    validateSchema,
-    sanitizeInput,
-  },
-  logger: {
-    createLogger,
-    Logger,
-    info: logInfo,
-    error: logError,
-    warn: logWarn,
-    debug: logDebug,
-  },
-};

package/index.js

@@ -1,7 +0,0 @@
-var database = require("./database");
-var functions = require("./functions");
-
-module.exports = {
-  database,
-  functions,
-};