@onurege3467/zerohelper 3.1.0 → 3.2.0

package/database/index.js

@@ -8,6 +8,7 @@ var MySQLDatabase = require("./mysql/index");
 var SQLiteDatabase = require("./sqldb/index");
 var RedisDatabase = require("./redis/index");
 var PostgreSQL = require("./postgresql/index");
+var MigrateDatabase = require("./migrate/index");
 
 module.exports = {
   /**
@@ -45,4 +46,9 @@ module.exports = {
    * @type {PostgreSQL}
    */
   PostgreSQL,
+  /**
+   * Migration utility for databases.
+   * @type {MigrateDatabase}
+   */
+  MigrateDatabase,
 };

package/database/jsondatabase/index.js

@@ -33,6 +33,11 @@ class database {
     this.set(path, data);
     return data;
   }
+  getAllData() {
+    let data = this.read();
+    if (!data) data = {};
+    return data;
+  }
   get(path) {
     let data = this.read(),
       result = undefined;
@@ -72,9 +77,9 @@ class database {
   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)) {
+    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);

package/database/migrate/index.js

@@ -0,0 +1,63 @@
+const JsonDatabase = require("../jsondatabase/index");
+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 "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/src/structers/Data.js

@@ -2,227 +2,281 @@ const mongodb = require("mongodb");
 const PathFormat = require("../tools/FormatTool.js");
 
 class Data {
-    /**
-     * @type {mongodb.Collection}
-     */
-    #collection;
-    /**
-     * @type {String}
-     */
-    #key;
-
-    /**
-     * 
-     * @param {String} key 
-     * @param {mongodb.Collection} collection 
-     */
-    constructor(key, collection) {
-        this.#key = key;
-        this.#collection = collection;
-    }
-
-    /**
-     * Assign to the specified path.
-     * @param {String} path
-     * @param {any} value Value to  be assigned.
-     * @return {any} 
-     */
-    async set(path, value) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $set: { [path]: value } }, { upsert: true });
-        return value;
-    }
-
-    /**
-     * Deletes the specified path.
-     * @param {String} path  
-     * @return {Promise<void>}
-     */
-    async delete(path) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $unset: { [path]: "" } });
-    }
-
-    /**
-     * Returns the value/object at the specified path.
-     * @param {String} path  
-     * @return {any}
-     */
-    async get(path) {
-        path = PathFormat(path);
-
-        const data = await this.#collection.findOne({ key: this.#key }, {
-            projection: {
-                "result": `$${path}`
-            }
-        });
-
-        return data ? data.result : undefined;
-    }
-
-    async getAll() {
-
-        const data = await this.#collection.findOne({ key: this.#key })
-
-        return data ? data.data : {};
-    }
-
-    async ping() {
-        var run1 = Date.now()
-        await this.set(`${run1}`,1)
-        var set = Date.now()
-        var run2 = Date.now()
-        await this.get(run1)
-        var get = Date.now()
-        var run3 = Date.now()
-        await this.delete(run1)
-        var deletet = Date.now()
-
-        return {total:((get+set+deletet)/3)-run1,set:set-run1,get:get-run2,delete:deletet-run3}
-    }
-
-    /**
-     * Sorts the array/values ​​in path.
-     * @param {String} path  
-     * @param {("DESC"|"ASC")} orderType Sorts the data in DESC (descending) or ASC (ascending).
-     * @param {Number} limit determines how many elements will rotate. (Default: 0 this is mean of returns in array all elements)
-     * @return {Promise<any[]>} 
-     */
-    async sort(path, orderType, limit = 0) {
-        path = PathFormat(path);
-
-        const order = orderType == "DESC" ? -1 : 1;
-        const pipelines = [
-            {
-                '$match': {
-                    'key': this.#key
-                }
-            }, {
-                '$unwind': {
-                    'path': `$${path}`
-                }
-            }, {
-                '$sort': {
-                    [`${path}`]: order
-                }
-            }, {
-                '$project': {
-                    'element': `$${path}`
-                }
-            }, {
-                '$limit': limit
-            }
-        ];
-
-        let result = (await this.#collection.aggregate(pipelines).toArray()).map(e => e.element);
-        return result;
-    }
-
-    /**
-     * Do mathematical addition to specified path.
-     * @param {String} path
-     * @param {Number} value
-     * @return {any}
-     */
-    async add(path, value) {
-        path = PathFormat(path);
-
-        const data = await this.#collection.findOneAndUpdate({ key: this.#key }, { $inc: { [path]: value } }, {
-            projection: {
-                "result": `$${path}`
-            },
-            upsert: true,
-            new: true
-        });
-
-        return data ? data.result : undefined;
-    }
-
-    /**
-     * Do mathematical subtraction to specified path.
-     * @param {String} path
-     * @param {Number} value
-     * @return {any}
-     */
-    async sub(path, value) {
-        path = PathFormat(path);
-
-        const data = await this.#collection.findOneAndUpdate({ key: this.#key }, { $inc: { [path]: -Math.abs(value) } }, {
-            projection: {
-                "result": `$${path}`
-            },
-            upsert: true,
-            new: true
-        });
-
-        return data ? data.result : undefined;
-    }
-
-    /**
-     * Check if Field exists to specified path.
-     * @param {String} path
-     * @return {Promise<Boolean>}
-     */
-    async has(path) {
-        path = PathFormat(path);
-
-        const data = await this.#collection.findOne({ key: this.#key, [path]: { $exists: true } }, {
-            projection: {
-                "_id": 1
-            }
-        });
-        return data ? true : false;
-    }
-
-    /**
-     * Push to value an array to specified path.
-     * @param {String} path
-     * @param {any} value
-     * @return {Promise<void>}
-     */
-    async push(path, value) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $push: { [path]: value } }, { upsert: true });
-    }
-
-    /**
-     * Push to multiple values an array to specified path.
-     * @param {String} path
-     * @param {any[]} values 
-     * @return {Promise<void>}
-     */
-    async pushRange(path, values) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $push: { [path]: { $each: values } } }, { upsert: true });
-    }
-
-    /**
-     * Extract element from Array to specified path.
-     * @param {String} path
-     * @param {any} value 
-     * @return {Promise<void>}
-     */
-    async pull(path, value) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $pull: { [path]: value } }, { upsert: true });
-    }
-
-    /**
-     * Extract all elements from Array to specified path.
-     * @param {String} path
-     * @param {any} value 
-     * @return {Promise<void>}
-     */
-    async pullAll(path, value) {
-        path = PathFormat(path);
-
-        await this.#collection.updateOne({ key: this.#key }, { $pullAll: { [path]: value } }, { upsert: true });
-    }
+  /**
+   * @type {mongodb.Collection}
+   */
+  #collection;
+  /**
+   * @type {String}
+   */
+  #key;
+
+  /**
+   *
+   * @param {String} key
+   * @param {mongodb.Collection} collection
+   */
+  constructor(key, collection) {
+    this.#key = key;
+    this.#collection = collection;
+  }
+
+  /**
+   * Assign to the specified path.
+   * @param {String} path
+   * @param {any} value Value to  be assigned.
+   * @return {any}
+   */
+  async set(path, value) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $set: { [path]: value } },
+      { upsert: true }
+    );
+    return value;
+  }
+
+  /**
+   * Deletes the specified path.
+   * @param {String} path
+   * @return {Promise<void>}
+   */
+  async delete(path) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $unset: { [path]: "" } }
+    );
+  }
+
+  /**
+   * Returns the value/object at the specified path.
+   * @param {String} path
+   * @return {any}
+   */
+  async get(path) {
+    path = PathFormat(path);
+
+    const data = await this.#collection.findOne(
+      { key: this.#key },
+      {
+        projection: {
+          result: `$${path}`,
+        },
+      }
+    );
+
+    return data ? data.result : undefined;
+  }
+
+  async getAll() {
+    const data = await this.#collection.findOne({ key: this.#key });
+
+    return data ? data.data : {};
+  }
+
+  async getAllData() {
+    this.getAll().then((data) => {
+      if (!data) data = {};
+      return data;
+    });
+  }
+
+  async ping() {
+    var run1 = Date.now();
+    await this.set(`${run1}`, 1);
+    var set = Date.now();
+    var run2 = Date.now();
+    await this.get(run1);
+    var get = Date.now();
+    var run3 = Date.now();
+    await this.delete(run1);
+    var deletet = Date.now();
+
+    return {
+      total: (get + set + deletet) / 3 - run1,
+      set: set - run1,
+      get: get - run2,
+      delete: deletet - run3,
+    };
+  }
+
+  /**
+   * Sorts the array/values ​​in path.
+   * @param {String} path
+   * @param {("DESC"|"ASC")} orderType Sorts the data in DESC (descending) or ASC (ascending).
+   * @param {Number} limit determines how many elements will rotate. (Default: 0 this is mean of returns in array all elements)
+   * @return {Promise<any[]>}
+   */
+  async sort(path, orderType, limit = 0) {
+    path = PathFormat(path);
+
+    const order = orderType == "DESC" ? -1 : 1;
+    const pipelines = [
+      {
+        $match: {
+          key: this.#key,
+        },
+      },
+      {
+        $unwind: {
+          path: `$${path}`,
+        },
+      },
+      {
+        $sort: {
+          [`${path}`]: order,
+        },
+      },
+      {
+        $project: {
+          element: `$${path}`,
+        },
+      },
+      {
+        $limit: limit,
+      },
+    ];
+
+    let result = (await this.#collection.aggregate(pipelines).toArray()).map(
+      (e) => e.element
+    );
+    return result;
+  }
+
+  /**
+   * Do mathematical addition to specified path.
+   * @param {String} path
+   * @param {Number} value
+   * @return {any}
+   */
+  async add(path, value) {
+    path = PathFormat(path);
+
+    const data = await this.#collection.findOneAndUpdate(
+      { key: this.#key },
+      { $inc: { [path]: value } },
+      {
+        projection: {
+          result: `$${path}`,
+        },
+        upsert: true,
+        new: true,
+      }
+    );
+
+    return data ? data.result : undefined;
+  }
+
+  /**
+   * Do mathematical subtraction to specified path.
+   * @param {String} path
+   * @param {Number} value
+   * @return {any}
+   */
+  async sub(path, value) {
+    path = PathFormat(path);
+
+    const data = await this.#collection.findOneAndUpdate(
+      { key: this.#key },
+      { $inc: { [path]: -Math.abs(value) } },
+      {
+        projection: {
+          result: `$${path}`,
+        },
+        upsert: true,
+        new: true,
+      }
+    );
+
+    return data ? data.result : undefined;
+  }
+
+  /**
+   * Check if Field exists to specified path.
+   * @param {String} path
+   * @return {Promise<Boolean>}
+   */
+  async has(path) {
+    path = PathFormat(path);
+
+    const data = await this.#collection.findOne(
+      { key: this.#key, [path]: { $exists: true } },
+      {
+        projection: {
+          _id: 1,
+        },
+      }
+    );
+    return data ? true : false;
+  }
+
+  /**
+   * Push to value an array to specified path.
+   * @param {String} path
+   * @param {any} value
+   * @return {Promise<void>}
+   */
+  async push(path, value) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $push: { [path]: value } },
+      { upsert: true }
+    );
+  }
+
+  /**
+   * Push to multiple values an array to specified path.
+   * @param {String} path
+   * @param {any[]} values
+   * @return {Promise<void>}
+   */
+  async pushRange(path, values) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $push: { [path]: { $each: values } } },
+      { upsert: true }
+    );
+  }
+
+  /**
+   * Extract element from Array to specified path.
+   * @param {String} path
+   * @param {any} value
+   * @return {Promise<void>}
+   */
+  async pull(path, value) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $pull: { [path]: value } },
+      { upsert: true }
+    );
+  }
+
+  /**
+   * Extract all elements from Array to specified path.
+   * @param {String} path
+   * @param {any} value
+   * @return {Promise<void>}
+   */
+  async pullAll(path, value) {
+    path = PathFormat(path);
+
+    await this.#collection.updateOne(
+      { key: this.#key },
+      { $pullAll: { [path]: value } },
+      { upsert: true }
+    );
+  }
 }
 
 module.exports = { Data };

package/database/mysql/structures/classes/MySQL.js

@@ -1,37 +1,41 @@
 "use strict";
 
-const EventEmitter = require('events');
+const EventEmitter = require("events");
+const getAllData = require("../methods/getAllData");
 
-module.exports = class MySQL extends EventEmitter{
-	constructor(){ super() };
-	name = 'FxesDbMySQL';
-	version = '1.0.0';
-	connect = require('../methods/connect');
-	query = require('../methods/query');
-	get = require('../methods/get');
-	set = require('../methods/set');
-	push = require('../methods/push');
-	includes = require('../methods/includes');
-	pull = require('../methods/pull');
-	add = require('../methods/add');
-	sub = require('../methods/sub');
-	subtract = require('../methods/sub');
-	delete = require('../methods/delete');
-	all = require('../methods/all');
-	tables = require('../methods/tables');
-	rename = require('../methods/rename');
-	stats = require('../methods/stats');
-	auto_increment = require('../methods/auto_increment');
-	create = require('../methods/create');
-	drop = require('../methods/drop');
-	variables = require('../methods/variables');
-	process = require('../methods/process');
-	ping = require('../methods/ping');
-	clear = require('../methods/clear');
-	base_set = require('../methods/base_set');
-	base_get = require('../methods/base_get');
-	end = require('../methods/end');
-	exists = require('../methods/exists');
-	create_db = require('../methods/create_db');
-	has = require('../methods/has')
-}
+module.exports = class MySQL extends EventEmitter {
+  constructor() {
+    super();
+  }
+  name = "FxesDbMySQL";
+  version = "1.0.0";
+  connect = require("../methods/connect");
+  getAllData = getAllData;
+  query = require("../methods/query");
+  get = require("../methods/get");
+  set = require("../methods/set");
+  push = require("../methods/push");
+  includes = require("../methods/includes");
+  pull = require("../methods/pull");
+  add = require("../methods/add");
+  sub = require("../methods/sub");
+  subtract = require("../methods/sub");
+  delete = require("../methods/delete");
+  all = require("../methods/all");
+  tables = require("../methods/tables");
+  rename = require("../methods/rename");
+  stats = require("../methods/stats");
+  auto_increment = require("../methods/auto_increment");
+  create = require("../methods/create");
+  drop = require("../methods/drop");
+  variables = require("../methods/variables");
+  process = require("../methods/process");
+  ping = require("../methods/ping");
+  clear = require("../methods/clear");
+  base_set = require("../methods/base_set");
+  base_get = require("../methods/base_get");
+  end = require("../methods/end");
+  exists = require("../methods/exists");
+  create_db = require("../methods/create_db");
+  has = require("../methods/has");
+};

package/database/mysql/structures/methods/getAllData.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const errors = require("../errors/strings.js");
+
+module.exports = async function (table = "default") {
+  if (!table || typeof table !== "string") {
+    throw new TypeError(errors.table.replace("{received}", typeof table));
+  }
+
+  // Tabloları kontrol et
+  let tables = await this.tables();
+  if (!tables.includes(table)) {
+    throw new TypeError(errors.tableNotFound.replace("{table}", table));
+  }
+
+  // Tüm verileri al
+  let all = await this.query(`SELECT key_name, value FROM \`${table}\``);
+  let result = {};
+
+  all.forEach((row) => {
+    let key = row.key_name;
+    let value = row.value;
+
+    // JSON parse işlemi
+    try {
+      value = JSON.parse(value);
+    } catch (e) {
+      // JSON değilse olduğu gibi bırak
+    }
+
+    result[key] = value;
+  });
+
+  return result;
+};

package/database/postgresql/index.js

@@ -3,6 +3,25 @@ const { Pool } = require("pg");
 class PostgreSQL {
   constructor(config) {
     this.pool = new Pool(config);
+
+    // Ensure the table exists when the class is instantiated
+    this.ensureTableExists(config).catch((error) => {
+      console.error("Error ensuring table exists:", error);
+    });
+  }
+
+  async ensureTableExists(config) {
+    try {
+      await this.pool.query(`
+        CREATE TABLE IF NOT EXISTS key_value_store (
+          key TEXT PRIMARY KEY,
+          value TEXT NOT NULL
+        )
+      `);
+    } catch (error) {
+      console.error("Failed to create table:", error);
+      throw error;
+    }
   }
 
   async set(key, value) {
@@ -88,7 +107,32 @@ class PostgreSQL {
     currentValue.push(value);
     await this.set(key, currentValue);
   }
-
+  async getAllData() {
+    try {
+      const res = await this.pool.query(
+        "SELECT key, value FROM key_value_store"
+      );
+      const result = {};
+
+      res.rows.forEach((row) => {
+        let value = row.value;
+
+        // JSON parse işlemi
+        try {
+          value = JSON.parse(value);
+        } catch (e) {
+          // JSON değilse olduğu gibi bırak
+        }
+
+        result[row.key] = value;
+      });
+
+      return result;
+    } catch (error) {
+      console.error("Error fetching all data:", error);
+      throw error;
+    }
+  }
   async ping() {
     try {
       await this.pool.query("SELECT 1");
@@ -103,16 +147,4 @@ class PostgreSQL {
   }
 }
 
-// Ensure the table exists
-(async () => {
-  const pool = new Pool();
-  await pool.query(`
-        CREATE TABLE IF NOT EXISTS key_value_store (
-            key TEXT PRIMARY KEY,
-            value TEXT NOT NULL
-        )
-    `);
-  await pool.end();
-})();
-
 module.exports = PostgreSQL;

package/database/redis/index.js

@@ -84,7 +84,30 @@ class RedisDatabase {
     currentValue.push(value);
     await this.set(key, currentValue);
   }
-
+  async getAllData() {
+    try {
+      const keys = await this.client.keys("*"); // Tüm anahtarları al
+      const result = {};
+
+      for (const key of keys) {
+        let value = await this.client.get(key);
+
+        // JSON parse işlemi
+        try {
+          value = JSON.parse(value);
+        } catch (e) {
+          // JSON değilse olduğu gibi bırak
+        }
+
+        result[key] = value;
+      }
+
+      return result;
+    } catch (error) {
+      console.error("Error fetching all data:", error);
+      throw error;
+    }
+  }
   async ping() {
     try {
       const pong = await this.client.ping();

package/database/sqldb/index.js

@@ -187,7 +187,35 @@ class Database {
       });
     });
   }
+  async getAllData() {
+    await this.ready; // Veritabanı hazır olana kadar bekle
+    this._ensureDatabaseInitialized();
+
+    return new Promise((resolve, reject) => {
+      this.db.all(`SELECT key, value FROM key_value_store`, [], (err, rows) => {
+        if (err) {
+          console.error("Error fetching all data:", err.message);
+          return reject(err);
+        }
+
+        const result = {};
+        rows.forEach((row) => {
+          let value = row.value;
 
+          // JSON parse işlemi
+          try {
+            value = JSON.parse(value);
+          } catch (e) {
+            // JSON değilse olduğu gibi bırak
+          }
+
+          result[row.key] = value;
+        });
+
+        resolve(result);
+      });
+    });
+  }
   close() {
     if (this.db) {
       this.db.close((err) => {

package/functions/index.js

@@ -234,9 +234,146 @@ function isPrime(num) {
   }
   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;
+}
 // Exportlar
 module.exports = {
+  http: {
+    fetchData,
+    postData,
+  },
+  date: {
+    formatDate,
+    dateDifference,
+    addDays,
+    subtractDays,
+  },
   random: {
     makeUniqueId,
     randomArray,
@@ -249,6 +386,8 @@ module.exports = {
   string: {
     titleCase,
     generateRandomString,
+    generateSlug,
+    wordCount,
   },
   array: {
     shuffleArray,
@@ -283,5 +422,7 @@ module.exports = {
     min,
     range,
     isPrime,
+    combination,
+    permutation,
   },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onurege3467/zerohelper",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "main": "index.js",
   "scripts": {
     "test": "node test.js"
@@ -27,6 +27,7 @@
   "dependencies": {
     "bcrypt": "^5.1.1",
     "crypto": "^1.0.1",
+    "dotenv": "^16.4.7",
     "fs": "^0.0.1-security",
     "jsonwebtoken": "^9.0.2",
     "lodash": "^4.17.21",
@@ -37,4 +38,4 @@
     "redis": "^4.7.0",
     "sqlite3": "^5.1.7"
   }
-}
+}

package/readme.md

@@ -363,3 +363,104 @@ ZeroHelper provides multiple database utilities for seamless integration with va
   await db.close();
 })();
 ```
+
+## Database Migration
+
+The `migrateData` function allows you to migrate data between different types of databases. It supports JSON, MongoDB, MySQL, SQLite, Redis, and PostgreSQL.
+
+# Example: Migrate Data from JSON to MongoDB
+
+```js
+const migrateData = require("@onurege3467/zerohelper/database/migrate");
+
+const sourceConfig = {
+  type: "json",
+  options: {
+    filePath: "databases/source.json", // Path to the JSON file
+  },
+};
+
+const targetConfig = {
+  type: "mongodb",
+  options: {
+    url: "mongodb://localhost:27017", // MongoDB connection URL
+    database: "targetDatabase", // Target database name
+    collection: "targetCollection", // Target collection name
+  },
+};
+
+(async () => {
+  try {
+    await migrateData(sourceConfig, targetConfig);
+    console.log("Data migration completed successfully!");
+  } catch (error) {
+    console.error("Error during migration:", error);
+  }
+})();
+```
+
+# Supported Database Types and Options
+
+```json
+{
+  "type": "json",
+  "options": {
+    "filePath": "path/to/json/file.json"
+  }
+}
+```
+
+```json
+{
+  "type": "mongodb",
+  "options": {
+    "url": "mongodb://localhost:27017",
+    "database": "databaseName",
+    "collection": "collectionName"
+  }
+}
+```
+
+```json
+{
+  "type": "mysql",
+  "options": {
+    "host": "localhost:port",
+    "user": "username",
+    "password": "password",
+    "database": "databaseName"
+  }
+}
+```
+
+```json
+{
+  "type": "sqlite",
+  "options": {
+    "filePath": "path/to/sqlite/file.db"
+  }
+}
+```
+
+```json
+{
+  "type": "redis",
+  "options": {
+    "host": "127.0.0.1",
+    "port": 6379
+  }
+}
+```
+
+```json
+{
+  "type": "postgresql",
+  "options": {
+    "host": "localhost",
+    "user": "username",
+    "password": "password",
+    "database": "databaseName",
+    "port": 5432
+  }
+}
+```