@onurege3467/zerohelper 1.2.0

package/database/index.js

@@ -0,0 +1,9 @@
+var jsonDatabasse = require('./jsondatabase/index')
+var MongoDB = require('./mongodb/index')
+var MySQL = require('./mysql/index')
+
+module.exports = {
+    JsonDatabase:  jsonDatabasse,
+    MongoDB,
+    MySQLDatabase:MySQL
+}

package/database/jsondatabase/index.js

@@ -0,0 +1,127 @@
+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;
+  }
+  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/mongodb/index.js

@@ -0,0 +1,49 @@
+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

@@ -0,0 +1,37 @@
+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 };

package/database/mongodb/src/structers/Collection.js

@@ -0,0 +1,136 @@
+const mongodb = require("mongodb");
+const { Data } = require("./Data.js");
+
+const PathFormat = require("../tools/FormatTool.js");
+
+class Collection {
+    /**
+     * @type {mongodb.Collection}
+     */
+    Collection;
+
+    /**
+     * @param {mongodb.Collection} client 
+     */
+    constructor(collection) {
+        this.Collection = collection;
+    }
+
+    /**
+     * If data does not exists, creates data then returns the data. Otherwise just returns data.
+     * @param {String} key
+     * @return {Data} 
+     */
+    data(key) {
+        return new Data(key, this.Collection);
+    }
+
+    /**
+     * Drop the data in collection.
+     * @param {String} key
+     * @return {Data} 
+     */
+    async dropData(key) {
+        return this.Collection.deleteOne({ key: key });
+    }
+
+    /**
+     * Sorts all data by the value in the specified path.
+     * @param {String} path It determines the field where the sorting will be done.
+     * @param {("DESC"|"ASC")} orderType Sorts the data in DESC (descending) or ASC (ascending).
+     * @param {number} limit It determines the data limit to be received.
+     * @return {Array<any>}
+     */
+    async sort(path, orderType, limit = 0) {
+        path = PathFormat(path);
+
+        const order = orderType == "DESC" ? -1 : 1;
+        const data = await this.Collection.find({ [path]: { $exists: true } }).sort(path, order).limit(limit).toArray();
+
+        return data;
+    }
+
+    /**
+     * In all data, the value is assigned to the specified path.
+     * @param {String} path
+     * @param {any} value
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async set(path, value) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $set: { [path]: value } }, { upsert: true });
+    }
+
+    /**
+     * Removes a field from all data in the collection.
+     * @param {String} path
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async delete(path) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $unset: { [path]: "" } }, { upsert: true });
+    }
+
+    /**
+     * Perform mathematical addition in the specified path in all data.
+     * @param {String} path
+     * @param {Number} value
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async add(path, value) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $inc: { [path]: Math.abs(value) } }, { upsert: true });
+    }
+    /**
+     * Perform mathematical subtraction in the specified path in all data.
+     * @param {String} path
+     * @param {Number} value
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async sub(path, value) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $inc: { [path]: -Math.abs(value) } }, { upsert: true });
+    }
+
+    /**
+     * Push value to array in specified path in all data.
+     * @param {String} path
+     * @param {any} value
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async push(path, value) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $push: { [path]: value } }, { upsert: true });
+    }
+
+    /**
+     * Values ​​in the specified array are added to all data in the collection in the specified path.
+     * @param {String} path
+     * @param {any[]} values
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async pushRange(path, values) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $push: { [path]: { $each: values } } }, { upsert: true });
+    }
+
+    /**
+     * Pull the value from the array in the specified path in all data.
+     * @param {String} path
+     * @param {any} value
+     * @return {mongodb.UpdateWriteOpResult}
+     */
+    async pull(path, value) {
+        path = PathFormat(path);
+
+        return await this.Collection.updateMany({}, { $pull: { [path]: value } }, { upsert: true });
+    }
+}
+
+module.exports = { Collection };

package/database/mongodb/src/structers/Data.js

@@ -0,0 +1,228 @@
+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 });
+    }
+}
+
+module.exports = { Data };

package/database/mongodb/src/structers/Database.js

@@ -0,0 +1,53 @@
+const mongodb = require("mongodb");
+const { Collection } = require("./Collection.js");
+
+class Database {
+
+    /**
+     * It has Db feature in MongoDB. Most operations are done with this area.
+     * @type {mongodb.Db}
+     */
+    Db;
+
+    /**
+     * It carries the Client connected to MongoDB.
+     * @type {mongodb.MongoClient}
+     */
+    Client;
+
+    /**
+     * 
+     * @param {mongodb.MongoClient} client 
+     * @param {mongodb.Db} databaseName 
+     */
+    constructor(client, databaseName) {
+        this.Client = client;
+        this.Db = this.Client.db(databaseName);
+    }
+
+    /**
+     * If collection does not exists, creates collection then returns the collection. Otherwise just returns collection.
+     * @param {String} collectionName 
+     * @return {Collection}
+     */
+    collection(collectionName) {
+        const dbCollection = this.Db.collection(collectionName);
+        dbCollection.createIndex({ key: 1 });
+        const collection = new Collection(dbCollection);
+
+        return collection;
+    }
+
+    /**
+     * Drops the Database Collection.
+     * @param {String} collectionName 
+     * @return {Promise<void>} 
+     */
+    async dropCollection(collectionName) {
+        const flag = await this.Db.dropCollection(collectionName);
+
+        return flag;
+    }
+}
+
+module.exports = { Database };

package/database/mongodb/src/tools/FormatTool.js

@@ -0,0 +1,5 @@
+function PathFormat(str) {
+    return "data." + str;
+}
+
+module.exports = PathFormat;