@onurege3467/zerohelper 3.0.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 };