@onurege3467/zerohelper 5.0.3 → 6.0.1

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

@@ -1,42 +0,0 @@
-"use strict";
-
-const get = require("lodash/get");
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, table = "default") {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-
-  let tables = await this.tables();
-  if (!tables.includes(table)) return null;
-
-  let keys = key.split("."),
-    keys2 = key.split(".");
-  if (keys.length > 1) {
-    key = keys.shift();
-  }
-  let res = await this.query({
-    sql: `SELECT value FROM \`${table}\` WHERE \`key_name\` = ?`,
-    values: [key],
-  });
-  if (!res.length) return null;
-  let value = null;
-  if (res.length) {
-    value = res[0].value;
-    if (!isNaN(value)) {
-      value = Number(value);
-    }
-    try {
-      value = JSON.parse(value);
-    } catch (e) {}
-  }
-  if (keys2.length > 1 && typeof value === "object") {
-    value = get(value, keys.join("."));
-    if (value == undefined) value = null;
-  } else if (keys2.length > 1) {
-    throw new ReferenceError(errors.targetNotObject.replace("{key}", key));
-  }
-  return value ? false : true;
-};

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

@@ -1,17 +0,0 @@
-"use strict";
-
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, value, table = "default") {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-  if (value === undefined)
-    throw new TypeError(errors.value.replace("{received}", typeof value));
-
-  let data = (await this.get(table, key)) || [];
-  if (!Array.isArray(data))
-    throw new TypeError(errors.array.replace("{key}", key));
-  return data.includes(value);
-};

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

@@ -1,11 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(){
-	let tables = await this.tables();
-	if(!tables.length) throw new TypeError(errors.noTablesExisted);
-	let ms = Date.now();
-	await this.query(`SELECT * from \`${tables[0]}\``);
-	return Date.now() - ms;
-}

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

@@ -1,7 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(){
-	return this.db.query("SHOW PROCESSLIST;");
-}

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

@@ -1,23 +0,0 @@
-"use strict";
-
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, value, table = "default", option) {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-  if (value === undefined)
-    throw new TypeError(errors.value.replace("{received}", typeof value));
-
-  let data = await this.get(table, key);
-  if (!data) throw new TypeError(errors.dataNotFound.replace("{key}", key));
-  if (!Array.isArray(data))
-    throw new TypeError(errors.array.replace("{key}", key));
-  if (option && (option === true || option.toLowerCase() === "all")) {
-    data = data.filter((obj) => obj !== value);
-  } else {
-    if (data.includes(value)) data.splice(data.indexOf(value), 1);
-  }
-  return await this.set(key, data, table);
-};

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

@@ -1,23 +0,0 @@
-"use strict";
-
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, value, table = "default", option) {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-  if (value === undefined)
-    throw new TypeError(errors.value.replace("{received}", typeof value));
-
-  await this.create(table);
-  let data = (await this.get(table, key)) || [];
-  if (!Array.isArray(data))
-    throw new TypeError(errors.array.replace("{key}", key));
-  if (option === true) {
-    if (!data.includes(value)) data.push(value);
-  } else {
-    data.push(value);
-  }
-  return await this.set(key, data, table);
-};

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

@@ -1,9 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(query){
-	if(!query) throw new TypeError(errors.query.replace("{received}", typeof query));
-	
-	return this.db.query(query);
-}

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

@@ -1,16 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(table, newTable){
-	if(!table || !newTable || typeof table !== "string" || typeof newTable !== "string") throw new TypeError(errors.table.replace("{received}", typeof table));
-	if(table === newTable) throw new TypeError(errors.tableRenameSameName);
-	
-	let tables = await this.tables();
-	if(!tables.includes(table)) throw new TypeError(errors.tableNotFound.replace("{table}", table));
-	if(tables.includes(newTable)) throw new TypeError(errors.tableAlreadyExists.replace("{table}", newTable));
-	
-	await this.query(`ALTER TABLE \`${table}\` RENAME TO \`${newTable}\``);
-	this.emit("tableRename", table, newTable);
-	return true;
-}

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

@@ -1,60 +0,0 @@
-"use strict";
-
-const set = require("lodash/set");
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, value, table = "default") {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-  if (value === undefined)
-    throw new TypeError(errors.value.replace("{received}", typeof value));
-
-  await this.create(table);
-
-  let oldData = await this.get(table, key);
-
-  let keys = key.split("."),
-    keys2 = key.split(".");
-  if (keys.length > 1) key = keys.shift();
-
-  let data = await this.query({
-    sql: `SELECT value FROM \`${table}\` WHERE \`key_name\` = ?`,
-    values: [key],
-  });
-  if (!data.length) {
-    await this.query({
-      sql: `INSERT INTO \`${table}\` (\`key_name\`, \`value\`) VALUES (?, ?)`,
-      values: [key, JSON.stringify({})],
-    });
-  }
-  data = (await this.get(table, key)) || {};
-  if (keys2.length > 1 && typeof data === "object") {
-    value = set(data, keys.join("."), value);
-  } else if (keys2.length > 1) {
-    throw new ReferenceError(errors.targetNotObject.replace("{key}", key));
-  }
-
-  try {
-    value = JSON.stringify(value);
-  } catch (e) {}
-  await this.query({
-    sql: `UPDATE \`${table}\` SET \`value\` = ? WHERE \`key_name\` = ?`,
-    values: [value, key],
-  });
-  let modifiedAt = Date.now();
-
-  let newData = await this.get(
-    table,
-    keys2.length > 1 ? key + "." + keys.join(".") : key
-  );
-  this.emit("dataModification", {
-    oldData,
-    newData,
-    type: oldData == null && newData != null ? "SET" : "UPDATE",
-    table,
-    modifiedAt,
-  });
-  return newData;
-};

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

@@ -1,13 +0,0 @@
-"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));
-
-  let res = await this.query(
-    `SHOW TABLE STATUS FROM ${this.db.pool.config.connectionConfig.database} WHERE name LIKE '${table}';`
-  );
-  return res[0] || null;
-};

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

@@ -1,19 +0,0 @@
-"use strict";
-
-const errors = require("../errors/strings.js");
-
-module.exports = async function (key, value, table = "default") {
-  if (!table || typeof table !== "string")
-    throw new TypeError(errors.table.replace("{received}", typeof table));
-  if (!key || typeof key !== "string")
-    throw new TypeError(errors.key.replace("{received}", typeof key));
-  if (value === undefined)
-    throw new TypeError(errors.value.replace("{received}", typeof value));
-  if (isNaN(value) || value <= 0)
-    throw new TypeError(errors.numberType.replace("{received}", typeof value));
-
-  await this.create(table);
-  let data = (await this.get(table, key)) || 0;
-  if (isNaN(data)) throw new TypeError(errors.notNumber.replace("{key}", key));
-  return await this.set(key, data - Number(value), table);
-};

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

@@ -1,8 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(){
-	let tables = await this.query("SHOW TABLES;");
-	return tables.map(m => m["Tables_in_" + this.db.pool.config.connectionConfig.database.toLowerCase()]);
-}

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

@@ -1,20 +0,0 @@
-"use strict";
-
-const errors = require('../errors/strings.js');
-
-module.exports = async function(variables){
-	if(!variables) throw new TypeError(errors.variables.replace("{received}", variables));
-	if(typeof variables !== "object" || Array.isArray(variables)) throw new TypeError(errors.variablesNotObject.replace("{received}", typeof variables));
-	
-	let res = {};
-	let keys = Object.keys(variables);
-	for(var i = 0; i < keys.length; i++){
-		let returned = await this.query(`SET GLOBAL ${keys[i]}=${variables[keys[i]]};`);
-		if(!returned.message){
-			res[keys[i]] = variables[keys[i]];
-		}else{
-			res[keys[i]] = returned;
-		}
-	}
-	return res;
-}

package/database/newMongoDB/index.js

@@ -1,94 +0,0 @@
-const { MongoClient, ObjectId } = require("mongodb");
-
-class MongoDBDatabase {
-  constructor(config) {
-    this.config = config;
-    this.client = new MongoClient(config.url, {
-      useNewUrlParser: true,
-      useUnifiedTopology: true,
-    });
-    this.dbPromise = this.client.connect().then(() => this.client.db(config.database));
-  }
-
-  async ensureCollection(collection) {
-    const db = await this.dbPromise;
-    const collections = await db.listCollections({ name: collection }).toArray();
-    if (collections.length === 0) {
-      await db.createCollection(collection);
-    }
-  }
-
-  async insert(collection, data) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).insertOne(data);
-    return result.insertedId;
-  }
-
-  async bulkInsert(collection, dataArray) {
-    if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).insertMany(dataArray);
-    return result.insertedCount;
-  }
-
-  async update(collection, data, where) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).updateMany(where, { $set: data });
-    return result.modifiedCount;
-  }
-
-  async updateOne(collection, data, where) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).updateOne(where, { $set: data });
-    return result.modifiedCount;
-  }
-
-  async delete(collection, where) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).deleteMany(where);
-    return result.deletedCount;
-  }
-
-  async deleteOne(collection, where) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const result = await db.collection(collection).deleteOne(where);
-    return result.deletedCount;
-  }
-
-  async select(collection, where = {}) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    return await db.collection(collection).find(where).toArray();
-  }
-
-  async selectOne(collection, where = {}) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    return await db.collection(collection).findOne(where);
-  }
-
-  async set(collection, data, where) {
-    await this.ensureCollection(collection);
-    const db = await this.dbPromise;
-    const existing = await db.collection(collection).findOne(where);
-    if (!existing) {
-      const result = await db.collection(collection).insertOne({ ...where, ...data });
-      return result.insertedId;
-    } else {
-      const result = await db.collection(collection).updateOne(where, { $set: data });
-      return result.modifiedCount;
-    }
-  }
-
-  async close() {
-    await this.client.close();
-  }
-}
-
-module.exports = MongoDBDatabase;

package/database/newMySQL/index.js

@@ -1,205 +0,0 @@
-const mysql = require("mysql2/promise");
-
-class MySQLDatabase {
-  constructor(config) {
-    this.config = config;
-    this.pool = null;
-
-    this.poolPromise = (async () => {
-      const connection = await mysql.createConnection({
-        host: config.host,
-        port: config.port || 3306,
-        user: config.user,
-        password: config.password,
-      });
-
-      await connection.query(`CREATE DATABASE IF NOT EXISTS \`${config.database}\``);
-      await connection.end();
-
-      this.pool = mysql.createPool({
-        host: config.host,
-        port: config.port || 3306,
-        user: config.user,
-        password: config.password,
-        database: config.database,
-        waitForConnections: true,
-        connectionLimit: config.connectionLimit || 10,
-        queueLimit: 0,
-      });
-
-      return this.pool;
-    })();
-  }
-
-  async query(sql, params = []) {
-    const pool = await this.poolPromise;
-    const [rows] = await pool.execute(sql, params);
-    return rows;
-  }
-
-  async ensureTable(table, data = {}) {
-    if (!data || Object.keys(data).length === 0) return;
-
-    const escapedTable = mysql.escape(table);
-    const tables = await this.query(`SHOW TABLES LIKE ${escapedTable}`);
-    if (tables.length === 0) {
-      const columns = Object.keys(data).map(col => `\`${col}\` VARCHAR(255)`).join(", ");
-      const createTableSQL = `
-        CREATE TABLE \`${table}\` (
-          id INT PRIMARY KEY AUTO_INCREMENT,
-          ${columns}
-        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
-      `;
-      await this.query(createTableSQL);
-    }
-  }
-
-  async insert(table, data) {
-    const copy = { ...data };
-    await this.ensureTable(table, copy);
-    const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-    if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-    const existingNames = existingColumns.map(col => col.Field);
-    for (const key of Object.keys(copy)) {
-      if (!existingNames.includes(key)) {
-        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`);
-      }
-    }
-
-    const keys = Object.keys(copy);
-    const placeholders = keys.map(() => "?").join(",");
-    const values = Object.values(copy);
-    const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(",")}) VALUES (${placeholders})`;
-
-    const result = await this.query(sql, values);
-    return result.insertId;
-  }
-
-  async update(table, data, where) {
-    await this.ensureTable(table, { ...data, ...where });
-    const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-    if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-    const existingColumnNames = existingColumns.map(col => col.Field);
-    for (const key of Object.keys(data)) {
-      if (!existingColumnNames.includes(key)) {
-        const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`;
-        await this.query(alterSQL);
-        console.log(`Added missing column '${key}' to table '${table}'`);
-      }
-    }
-    const setString = Object.keys(data).map(k => `\`${k}\` = ?`).join(", ");
-    const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
-    const sql = `UPDATE \`${table}\` SET ${setString} WHERE ${whereString}`;
-    const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
-    return result.affectedRows;
-  }
-
-  async delete(table, where) {
-    if (!where || Object.keys(where).length === 0) return 0;
-    await this.ensureTable(table, { ...where });
-    const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
-    const sql = `DELETE FROM \`${table}\` WHERE ${whereString}`;
-    const result = await this.query(sql, Object.values(where));
-    return result.affectedRows;
-  }
-
-  async select(table, where = null) {
-    await this.ensureTable(table, where || {});
-    let sql = `SELECT * FROM \`${table}\``;
-    let params = [];
-
-    if (where && Object.keys(where).length > 0) {
-      const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
-      sql += ` WHERE ${whereString}`;
-      params = Object.values(where);
-    }
-
-    return await this.query(sql, params);
-  }
-
-  async set(table, data, where) {
-    await this.ensureTable(table, { ...data, ...where });
-    const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-    if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-    const existingColumnNames = existingColumns.map(col => col.Field);
-    for (const key of Object.keys(data)) {
-      if (!existingColumnNames.includes(key)) {
-        const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`;
-        await this.query(alterSQL);
-        console.log(`Added missing column '${key}' to table '${table}'`);
-      }
-    }
-    const existing = await this.select(table, where);
-    if (existing.length === 0) {
-      return await this.insert(table, { ...where, ...data });
-    } else {
-      return await this.update(table, data, where);
-    }
-  }
-
-  async selectOne(table, where = null) {
-    const results = await this.select(table, where);
-    return results[0] || null;
-  }
-
-  async deleteOne(table, where) {
-    const row = await this.selectOne(table, where);
-    if (!row) return 0;
-    const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
-    const sql = `DELETE FROM \`${table}\` WHERE ${whereString} LIMIT 1`;
-    const result = await this.query(sql, Object.values(where));
-    return result.affectedRows;
-  }
-
-  async updateOne(table, data, where) {
-    await this.ensureTable(table, { ...data, ...where });
-    const existingColumns = await this.query(`DESCRIBE \`${table}\``).catch(() => null);
-    if (!existingColumns) throw new Error(`Table ${table} does not exist.`);
-
-    const existingColumnNames = existingColumns.map(col => col.Field);
-    for (const key of Object.keys(data)) {
-      if (!existingColumnNames.includes(key)) {
-        const alterSQL = `ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`;
-        await this.query(alterSQL);
-        console.log(`Added missing column '${key}' to table '${table}'`);
-      }
-    }
-    const setString = Object.keys(data).map(k => `\`${k}\` = ?`).join(", ");
-    const whereString = Object.keys(where).map(k => `\`${k}\` = ?`).join(" AND ");
-    const sql = `UPDATE \`${table}\` SET ${setString} WHERE ${whereString} LIMIT 1`;
-    const result = await this.query(sql, [...Object.values(data), ...Object.values(where)]);
-    return result.affectedRows;
-  }
-
-  async bulkInsert(table, dataArray) {
-    if (!Array.isArray(dataArray) || dataArray.length === 0) return 0;
-    await this.ensureTable(table, dataArray[0]);
-
-    const existingColumns = await this.query(`DESCRIBE \`${table}\``);
-    const existingColumnNames = existingColumns.map(col => col.Field);
-    const keys = Object.keys(dataArray[0]);
-
-    // Eksik kolonları sadece ilk elemana göre kontrol et
-    for (const key of keys) {
-      if (!existingColumnNames.includes(key)) {
-        await this.query(`ALTER TABLE \`${table}\` ADD COLUMN \`${key}\` VARCHAR(255)`);
-      }
-    }
-
-    const placeholders = dataArray.map(() => `(${keys.map(() => '?').join(',')})`).join(',');
-    const values = dataArray.flatMap(obj => keys.map(k => obj[k]));
-    const sql = `INSERT INTO \`${table}\` (${keys.map(k => `\`${k}\``).join(",")}) VALUES ${placeholders}`;
-
-    const result = await this.query(sql, values);
-    return result.affectedRows;
-  }
-
-  async close() {
-    if (this.pool) await this.pool.end();
-  }
-}
-
-module.exports = MySQLDatabase;