@onurege3467/zerohelper 5.0.3 → 6.0.1

package/test.js

@@ -0,0 +1,244 @@
+const path = require('path');
+const createDatabase = require('./database');
+const helpers = require('./functions');
+
+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,
+    },
+  },
+};
+
+const mongoConfig = {
+  adapter: 'mongodb',
+  config: {
+    url: process.env.MONGODB_URL || 'mongodb://localhost:27017/test',
+    database: process.env.MONGODB_DATABASE || 'test_mongo_db_zerohelper',
+    cache: {
+      max: 100,
+      ttl: 1000 * 10,
+      updateAgeOnGet: true,
+    },
+  },
+};
+
+const jsonConfig = {
+  adapter: 'json',
+  config: {
+    filePath: path.join(__dirname, 'data', 'test_db.json'),
+  },
+};
+
+const sqliteConfig = {
+  adapter: 'sqlite',
+  config: {
+    filePath: path.join(__dirname, 'data', 'test_db.sqlite'),
+  },
+};
+
+const cachedSqliteConfig = {
+  adapter: 'sqlite',
+  config: {
+    filePath: path.join(__dirname, 'data', 'test_db_cached.sqlite'),
+    cache: {
+      max: 100, // Max 100 items
+      ttl: 1000 * 10, // 10 seconds TTL
+      updateAgeOnGet: true,
+    },
+  },
+};
+
+async function runDatabaseTests() {
+  console.log('Starting database tests...');
+
+  const databases = [
+    { name: 'MySQL', config: mysqlConfig },
+    { name: 'MongoDB', config: mongoConfig },
+    { name: 'JSON', config: jsonConfig },
+    { name: 'SQLite', config: sqliteConfig },
+  ];
+
+  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`, age: 30 });
+      console.log(`${name} Insert:`, insertResult);
+
+      // Test SelectOne
+      const user = await db.selectOne('users', { name: 'Test User' });
+      console.log(`${name} SelectOne:`, user);
+
+      // Test Update
+      if (user) {
+        const updateResult = await db.update('users', { age: 31 }, { name: 'Test User' });
+        console.log(`${name} Update:`, updateResult);
+      }
+
+      // Test Select (all)
+      const allUsers = await db.select('users');
+      console.log(`${name} Select All:`, allUsers);
+
+      // Test Set (upsert)
+      const setResult = await db.set('users', { city: 'Test City' }, { name: 'Test User' });
+      console.log(`${name} Set (upsert):`, setResult);
+
+      // Test Delete
+      const deleteResult = await db.delete('users', { name: 'Test User' });
+      console.log(`${name} Delete:`, deleteResult);
+
+    } catch (error) {
+      console.error(`Error testing ${name} database:`, error);
+    } finally {
+      if (db) {
+        try {
+          await db.close();
+          console.log(`${name} database connection closed.`);
+        } catch (closeError) {
+          console.error(`Error closing ${name} database connection:`, closeError);
+        }
+      }
+    }
+  }
+
+  // --- Testing Cached SQLite Database ---
+  console.log('\n--- Testing Cached SQLite Database ---');
+  let cachedDb;
+  try {
+    cachedDb = createDatabase(cachedSqliteConfig);
+    console.log('Cached SQLite database connected.');
+
+    // Insert a record
+    await cachedDb.insert('products', { name: 'Laptop', price: 1200 });
+    console.log('Inserted Laptop into cached DB.');
+
+    // First select - should be a cache miss
+    let product = await cachedDb.selectOne('products', { name: 'Laptop' });
+    console.log('First select (should be cache miss): ', product);
+
+    // Second select - should be a cache hit
+    product = await cachedDb.selectOne('products', { name: 'Laptop' });
+    console.log('Second select (should be cache hit): ', product);
+
+    // Update the record - should invalidate cache
+    await cachedDb.update('products', { price: 1150 }, { name: 'Laptop' });
+    console.log('Updated Laptop price, cache should be invalidated.');
+
+    // Third select - should be a cache miss again (after invalidation)
+    product = await cachedDb.selectOne('products', { name: 'Laptop' });
+    console.log('Third select (should be cache miss after update): ', product);
+
+    // Delete the record
+    await cachedDb.delete('products', { name: 'Laptop' });
+    console.log('Deleted Laptop from cached DB.');
+
+  } catch (error) {
+    console.error('Error testing Cached SQLite database:', error);
+  } finally {
+    if (cachedDb) {
+      try {
+        await cachedDb.close();
+        console.log('Cached SQLite database connection closed.');
+      } catch (closeError) {
+        console.error('Error closing Cached SQLite 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();
+  runHelperFunctionTests();
+}
+
+main();

package/database/csvdb/index.js

@@ -1,90 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const { parse, stringify } = require("csv");
-
-class CSVDatabase {
-  constructor(filePath) {
-    this.filePath = filePath || path.join(__dirname, "database.csv");
-    if (!fs.existsSync(this.filePath)) {
-      fs.writeFileSync(this.filePath, "key,value\n"); // Başlık satırı
-    }
-  }
-
-  async _readCSV() {
-    const data = fs.readFileSync(this.filePath, "utf8");
-    return new Promise((resolve, reject) => {
-      parse(data, { columns: true }, (err, records) => {
-        if (err) reject(err);
-        else resolve(records);
-      });
-    });
-  }
-
-  async _writeCSV(records) {
-    const data = await new Promise((resolve, reject) => {
-      stringify(records, { header: true }, (err, output) => {
-        if (err) reject(err);
-        else resolve(output);
-      });
-    });
-    fs.writeFileSync(this.filePath, data);
-  }
-
-  async set(key, value) {
-    const records = await this._readCSV();
-    const index = records.findIndex((record) => record.key === key);
-    if (index !== -1) {
-      records[index].value = JSON.stringify(value);
-    } else {
-      records.push({ key, value: JSON.stringify(value) });
-    }
-    await this._writeCSV(records);
-  }
-
-  async get(key) {
-    const records = await this._readCSV();
-    const record = records.find((record) => record.key === key);
-    return record ? JSON.parse(record.value) : null;
-  }
-
-  async delete(key) {
-    const records = await this._readCSV();
-    const filteredRecords = records.filter((record) => record.key !== key);
-    await this._writeCSV(filteredRecords);
-  }
-
-  async has(key) {
-    const value = await this.get(key);
-    return value !== null;
-  }
-
-  async push(key, value) {
-    const currentValue = (await this.get(key)) || [];
-    if (!Array.isArray(currentValue)) throw new Error("Value is not an array");
-    currentValue.push(value);
-    await this.set(key, currentValue);
-  }
-
-  async add(key, value) {
-    const currentValue = (await this.get(key)) || 0;
-    if (typeof currentValue !== "number") throw new Error("Value is not a number");
-    await this.set(key, currentValue + value);
-  }
-
-  async sub(key, value) {
-    const currentValue = (await this.get(key)) || 0;
-    if (typeof currentValue !== "number") throw new Error("Value is not a number");
-    await this.set(key, currentValue - value);
-  }
-
-  async getAllData() {
-    const records = await this._readCSV();
-    const result = {};
-    records.forEach((record) => {
-      result[record.key] = JSON.parse(record.value);
-    });
-    return result;
-  }
-}
-
-module.exports = CSVDatabase;

package/database/jsondatabase/index.js

@@ -1,132 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-class database {
-  constructor(name = "database", loc2) {
-    var location = "database";
-    var filePath = `databases/${name}.json`;
-    if (name.endsWith(".json")) {
-      filePath = `databases/${name}`;
-    }
-    if (location == "database" && !fs.existsSync(`databases`)) {
-      fs.mkdirSync(`databases`, { recursive: true });
-    } else if (!fs.existsSync(`${location}`)) {
-      fs.mkdirSync(`databases`, { recursive: true });
-    }
-    if (loc2) {
-      if (!fs.existsSync(`${loc2}`)) {
-        fs.mkdirSync(`databases/${loc2}`, { recursive: true });
-      }
-      filePath = `databases/${loc2}/${name}.json`;
-      if (name.endsWith(".json")) {
-        filePath = `databases/${loc2}/${name}`;
-      }
-    }
-
-    if (!fs.existsSync(filePath)) fs.closeSync(fs.openSync(filePath, "w"));
-    this.FilePath = filePath;
-    this.Location = location;
-  }
-  add(path, value) {
-    let data = this.get(path);
-    if (typeof data == "number") data += Number(value);
-    else data = Number(value);
-    this.set(path, data);
-    return data;
-  }
-  getAllData() {
-    let data = this.read();
-    if (!data) data = {};
-    return data;
-  }
-  get(path) {
-    let data = this.read(),
-      result = undefined;
-    if (!data) data = {};
-    result = _get(path, data);
-    return result ? result : undefined;
-  }
-  has(path) {
-    let data = this.read(),
-      result = undefined;
-    result = _get(path, data);
-    if (!result) return false;
-    else {
-      return true;
-    }
-  }
-  set(path, value) {
-    let data = this.read();
-    if (!data) data = {};
-    data = _set(path, value, data);
-    fs.truncateSync(this.FilePath);
-    fs.writeFileSync(this.FilePath, JSON.stringify(data, null, 4), {
-      encoding: "utf-8",
-    });
-    return data;
-  }
-  delete(path) {
-    let data = this.read();
-    if (!data) data = {};
-    data = _set(path, undefined, data);
-    fs.truncateSync(this.FilePath);
-    fs.writeFileSync(this.FilePath, JSON.stringify(data, null, 4), {
-      encoding: "utf-8",
-    });
-    return data;
-  }
-  push(path, value) {
-    let data = this.read();
-    if (!data) data = {};
-    if (_get(path, data) && Array.isArray(_get(path, data))) {
-      _get(path, data).push(value);
-    } else if (!_get(path, data)) {
-      _set(path, [value], data);
-    }
-    fs.truncateSync(this.FilePath);
-    fs.writeFileSync(this.FilePath, JSON.stringify(data, null, 4), {
-      encoding: "utf-8",
-    });
-    return data;
-  }
-  sub(path, value) {
-    let data = this.get(path);
-    if (typeof data == "number") data -= Number(value);
-    else data = Number(value);
-    this.set(path, data);
-    return data;
-  }
-  read() {
-    let data = fs.readFileSync(this.FilePath, { encoding: "utf-8" });
-    if (!data || (data && data == null)) return {};
-    let obj = JSON.parse(data);
-
-    return obj;
-  }
-}
-
-function _set(path, value, obj = undefined) {
-  if (obj == undefined) return undefined;
-  let locations = path.split("."),
-    output = {};
-  output = obj;
-  let ref = output;
-  for (let index = 0; index < locations.length - 1; index++) {
-    if (!ref[locations[index]]) ref = ref[locations[index]] = {};
-    else ref = ref[locations[index]];
-  }
-  ref[locations[locations.length - 1]] = value;
-  return output;
-}
-
-function _get(path, obj = {}) {
-  let locations = path.split("."),
-    ref = obj;
-  for (let index = 0; index < locations.length - 1; index++) {
-    ref = ref[locations[index]] ? ref[locations[index]] : undefined;
-    if (!ref) return undefined;
-  }
-  let output = ref[locations[locations.length - 1]];
-  return output;
-}
-
-module.exports = database;

package/database/migrate/index.js

@@ -1,68 +0,0 @@
-const JsonDatabase = require("../jsondatabase/index");
-const YamlDatabase = require("../yamldatabase/index"); // Assuming you've saved the YAML class in this path
-const MongoDB = require("../mongodb/index");
-const MySQLDatabase = require("../mysql/index");
-const SQLiteDatabase = require("../sqldb/index");
-const RedisDatabase = require("../redis/index");
-const PostgreSQL = require("../postgresql/index");
-
-/**
- * Migrates data from one database to another.
- * @param {Object} source - Source database configuration.
- * @param {Object} target - Target database configuration.
- */
-async function migrateData(source, target) {
-  const sourceDb = await initializeDatabase(source);
-  const targetDb = await initializeDatabase(target);
-
-  const allData = await sourceDb.getAllData();
-  console.log(allData);
-
-  for (const [key, value] of Object.entries(allData)) {
-    await targetDb.set(key, value);
-  }
-
-  console.log(`Migration completed from ${source.type} to ${target.type}`);
-}
-
-/**
- * Initializes a database instance based on the configuration.
- * @param {Object} config - Database configuration.
- * @returns {Object} - Database instance.
- */
-async function initializeDatabase(config) {
-  switch (config.type) {
-    case "json":
-      return new JsonDatabase(config.options.filePath);
-    case "yaml":
-      return new YamlDatabase(config.options.filePath);
-    case "csv":
-      return new YamlDatabase(config.options.filePath);
-    case "mongodb":
-      const mongoClient = await MongoDB.createData(
-        config.options.database,
-        config.options.collection,
-        config.options.data,
-        undefined,
-        config.options.url
-      );
-      return mongoClient;
-    case "mysql":
-      const mysqlDb = new MySQLDatabase();
-      await mysqlDb.connect(config.options);
-      return mysqlDb;
-    case "sqlite":
-      return new SQLiteDatabase(config.options.filePath);
-    case "redis":
-      const redisDb = new RedisDatabase(config.options);
-      await redisDb.connect();
-      return redisDb;
-    case "postgresql":
-      return new PostgreSQL(config.options);
-    default:
-      throw new Error(`Unsupported database type: ${config.type}`);
-  }
-}
-
-// Export the migrateData function
-module.exports = migrateData;

package/database/mongodb/index.js

@@ -1,49 +0,0 @@
-const { MongoClient } = require('mongodb');
-
-const { Client } = require('./src/client/Client.js');
-const { Collection } = require("./src/structers/Collection.js");
-const { Data } = require("./src/structers/Data.js");
-const { Database } = require("./src/structers/Database.js");
-
-
-require('dotenv').config();
-
-class MongoDB {
-    /**
-     * Creates a new client and connects to MongoDB. (Connects to socket)
-     * @param {String} url 
-     * @param {MongoClientOptions} options 
-     * @return {Promise<Client>}
-     */
-    static connect = async function (url, options = undefined) {
-        const mongoClient = new MongoClient(url, options);
-        await mongoClient.connect();
-        return new Client(mongoClient);
-    }
-}
-
-const justConnect = async (database = 'database',collection ='collection',data='data',options = undefined,url = process.env.MONGODB_URL)=>{
-    const mongoClient = new MongoClient(url, options);
-    await mongoClient.connect();
-    return new Client(mongoClient);
-}
-
-const createDatabase = async (database = 'database',options = undefined,url = process.env.MONGODB_URL)=>{
-    const mongoClient = new MongoClient(url, options);
-    await mongoClient.connect();
-    return new Client(mongoClient).database(database);
-}
-
-const createCollection = async (database = 'database',collection ='collection',options = undefined,url = process.env.MONGODB_URL)=>{
-    const mongoClient = new MongoClient(url, options);
-    await mongoClient.connect();
-    return new Client(mongoClient).database(database).collection(collection);
-}
-
-const createData = async (database = 'database',collection ='collection',data='data',options = undefined,url = process.env.MONGODB_URL)=>{
-    const mongoClient = new MongoClient(url, options);
-    await mongoClient.connect();
-    return new Client(mongoClient).database(database).collection(collection).data(data);
-}
-
-module.exports = { MongoDB, Client, Database, Collection, Data, createDatabase,createCollection,createData,justConnect };

package/database/mongodb/src/client/Client.js

@@ -1,37 +0,0 @@
-const mongodb = require("mongodb");
-const { Database } = require("../structers/Database.js");
-
-class Client {
-    /**
-     * @type {mongodb.MongoClient}
-     */
-    Client;
-
-    /**
-     * @param {MongoClient} client 
-     */
-    constructor(client) {
-        this.Client = client;
-    }
-
-    /**
-     * If database does not exists, creates database then returns the database. Otherwise just returns database.
-     * @param {String} databaseName
-     * @return {Database} 
-     */
-    database(databaseName) {
-        const database = new Database(this.Client, databaseName);
-        return database;
-    }
-
-    /**
-     * Drops the database.
-     * @param {String} databaseName 
-     * @return {Promise<void>}
-     */
-    async dropDatabase(databaseName) {
-        await this.Client.db(databaseName).dropDatabase();
-    }
-}
-
-module.exports = { Client };