@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/mysql.js

@@ -16,124 +16,44 @@ class MySQLDatabase extends IDatabase_1.IDatabase {
         this._connectionPromise = new Promise(async (resolve, reject) => {
             try {
                 const connection = await promise_1.default.createConnection({
-                    host: config.host,
+                    host: config.host || 'localhost',
                     port: config.port || 3306,
-                    user: config.user,
+                    user: config.username,
                     password: config.password,
-                    typeCast: (field, next) => {
-                        if (field.type === 'TINY' && field.length === 1) {
-                            return (field.string() === '1');
-                        }
-                        if (['INT', 'DECIMAL', 'NEWDECIMAL', 'FLOAT', 'DOUBLE'].includes(field.type)) {
-                            return Number(field.string());
-                        }
-                        return next();
-                    }
                 });
-                await connection.query(`CREATE DATABASE IF NOT EXISTS 
+                await connection.query(`CREATE DATABASE IF NOT EXISTS
 ${config.database}
 `);
                 await connection.end();
                 this.pool = promise_1.default.createPool({
-                    host: config.host,
+                    host: config.host || 'localhost',
                     port: config.port || 3306,
-                    user: config.user,
+                    user: config.username,
                     password: config.password,
                     database: config.database,
                     waitForConnections: true,
-                    connectionLimit: config.connectionLimit || 10,
+                    connectionLimit: config.poolSize || 10,
                     queueLimit: 0,
-                    typeCast: (field, next) => {
-                        if (field.type === 'TINY' && field.length === 1) {
-                            return (field.string() === '1');
-                        }
-                        if (['INT', 'DECIMAL', 'NEWDECIMAL', 'FLOAT', 'DOUBLE'].includes(field.type)) {
-                            return Number(field.string());
-                        }
-                        return next();
-                    }
                 });
                 this._connected = true;
                 resolve(this.pool);
                 this._processQueue();
             }
             catch (error) {
-                console.error("MySQL connection error:", error);
                 reject(error);
             }
         });
     }
-    _getColumnType(value) {
-        if (value === null || value === undefined)
-            return 'TEXT';
-        if (typeof value === 'boolean')
-            return 'BOOLEAN';
-        if (typeof value === 'number') {
-            if (Number.isInteger(value)) {
-                if (value >= -128 && value <= 127)
-                    return 'TINYINT';
-                if (value >= -32768 && value <= 32767)
-                    return 'SMALLINT';
-                if (value >= -2147483648 && value <= 2147483647)
-                    return 'INT';
-                return 'BIGINT';
-            }
-            return 'DOUBLE';
-        }
-        if (typeof value === 'string') {
-            const length = value.length;
-            if (length <= 255)
-                return 'VARCHAR(255)';
-            if (length <= 65535)
-                return 'TEXT';
-            if (length <= 16777215)
-                return 'MEDIUMTEXT';
-            return 'LONGTEXT';
-        }
-        if (typeof value === 'object') {
-            const jsonString = JSON.stringify(value);
-            return jsonString.length <= 65535 ? 'JSON' : 'LONGTEXT';
-        }
-        if (value instanceof Date)
-            return 'DATETIME';
-        return 'TEXT';
-    }
-    _getBestColumnType(values) {
-        const types = values.map(val => this._getColumnType(val));
-        const uniqueTypes = [...new Set(types)];
-        if (uniqueTypes.length === 1)
-            return uniqueTypes[0];
-        const typePriority = {
-            'LONGTEXT': 10, 'MEDIUMTEXT': 9, 'TEXT': 8, 'JSON': 7, 'VARCHAR(255)': 6,
-            'DATETIME': 5, 'DOUBLE': 4, 'BIGINT': 3, 'INT': 2, 'SMALLINT': 1, 'TINYINT': 0, 'BOOLEAN': -1
+    async _execute(op, table, fn) {
+        const start = Date.now();
+        const execute = async () => {
+            const res = await fn();
+            this.recordMetric(op, table, Date.now() - start);
+            return res;
         };
-        return uniqueTypes.sort((a, b) => (typePriority[b] || 0) - (typePriority[a] || 0))[0];
-    }
-    async _ensureMissingColumns(table, data) {
-        const existingColumns = await this.query(`DESCRIBE 
-${table}
-`).catch(() => []);
-        const existingColumnNames = existingColumns.map((col) => col.Field);
-        for (const key of Object.keys(data)) {
-            if (!existingColumnNames.includes(key)) {
-                const columnType = this._getColumnType(data[key]);
-                await this.query(`ALTER TABLE 
-${table}
- ADD COLUMN 
-${key}
- ${columnType}`);
-            }
-        }
-    }
-    async _queueRequest(operation) {
-        if (this._connected) {
-            return operation();
-        }
-        else {
-            return new Promise((resolve, reject) => {
-                this._queue.push({ operation, resolve, reject });
-            });
-        }
+        if (this._connected)
+            return execute();
+        return new Promise((resolve, reject) => this._queue.push({ operation: execute, resolve, reject }));
     }
     async _processQueue() {
         if (!this._connected)
@@ -142,8 +62,7 @@ ${key}
             const item = this._queue.shift();
             if (item) {
                 try {
-                    const result = await item.operation();
-                    item.resolve(result);
+                    item.resolve(await item.operation());
                 }
                 catch (error) {
                     item.reject(error);
@@ -152,162 +71,129 @@ ${key}
         }
     }
     async query(sql, params = []) {
-        return this._queueRequest(async () => {
-            const pool = await this._connectionPromise;
-            const [rows] = await pool.execute(sql, params);
-            return rows;
-        });
+        const pool = await this._connectionPromise;
+        const [rows] = await pool.execute(sql, params);
+        return rows;
     }
-    async ensureTable(table, data = {}) {
-        return this._queueRequest(async () => {
-            const escapedTable = promise_1.default.escape(table);
-            const tables = await this.query(`SHOW TABLES LIKE ${escapedTable}`);
-            if (tables.length === 0) {
-                const columnDefinitions = Object.keys(data).map(col => {
-                    const columnType = this._getColumnType(data[col]);
-                    return `
-${col}
- ${columnType}`;
-                });
-                const columnsPart = columnDefinitions.length > 0 ? ', ' + columnDefinitions.join(", ") : '';
-                const createTableSQL = `
-          CREATE TABLE 
+    async _ensureMissingColumns(table, data) {
+        const existingColumns = await this.query(`DESCRIBE
 ${table}
- (
-            _id INT PRIMARY KEY AUTO_INCREMENT
-            ${columnsPart}
-          ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
-        `;
-                await this.query(createTableSQL);
+`).catch(() => []);
+        const columnNames = existingColumns.map(col => col.Field);
+        for (const key of Object.keys(data)) {
+            if (key !== '_id' && !columnNames.includes(key)) {
+                await this.query(`ALTER TABLE
+${table}
+ ADD COLUMN
+${key}
+ TEXT`);
             }
-        });
+        }
     }
-    async insert(table, data) {
-        return this._queueRequest(async () => {
-            const copy = { ...data };
-            await this.ensureTable(table, copy);
-            await this._ensureMissingColumns(table, copy);
-            const existingColumns = await this.query(`DESCRIBE 
+    async ensureTable(table, data = {}) {
+        const escapedTable = promise_1.default.escape(table);
+        const tables = await this.query(`SHOW TABLES LIKE ${escapedTable}`);
+        if (tables.length === 0) {
+            const defs = Object.keys(data).map(k => `
+${k}
+ TEXT`);
+            const columnsPart = defs.length > 0 ? ', ' + defs.join(", ") : '';
+            await this.query(`CREATE TABLE
 ${table}
-`);
-            const primaryKeyColumn = existingColumns.find(col => col.Key === 'PRI' && col.Extra.includes('auto_increment'));
-            if (primaryKeyColumn && copy[primaryKeyColumn.Field] !== undefined) {
-                delete copy[primaryKeyColumn.Field];
-            }
-            const keys = Object.keys(copy);
-            const placeholders = keys.map(() => "?").join(",");
-            const values = Object.values(copy).map(value => this._serializeValue(value));
-            const sql = `INSERT INTO 
+ (_id INT PRIMARY KEY AUTO_INCREMENT ${columnsPart}) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4`);
+        }
+        else {
+            await this._ensureMissingColumns(table, data);
+        }
+    }
+    async insert(table, data) {
+        await this.runHooks('beforeInsert', table, data);
+        return this._execute('insert', table, async () => {
+            await this.ensureTable(table, data);
+            const keys = Object.keys(data);
+            const sql = `INSERT INTO
 ${table}
  (${keys.map(k => `
 ${k}
-`).join(",")}) VALUES (${placeholders})`;
-            const result = await this.query(sql, values);
+`).join(",")}) VALUES (${keys.map(() => '?').join(",")})`;
+            const result = await this.query(sql, Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
+            const finalData = { _id: result.insertId, ...data };
+            await this.runHooks('afterInsert', table, finalData);
             return result.insertId;
         });
     }
     async update(table, data, where) {
-        return this._queueRequest(async () => {
+        await this.runHooks('beforeUpdate', table, { data, where });
+        return this._execute('update', table, async () => {
             await this.ensureTable(table, { ...data, ...where });
-            await this._ensureMissingColumns(table, { ...data, ...where });
-            const setString = Object.keys(data).map(k => `
+            const set = Object.keys(data).map(k => `
 ${k}
  = ?`).join(", ");
-            const whereString = Object.keys(where).map(k => `
-${k}
- = ?`).join(" AND ");
-            const sql = `UPDATE 
+            const wKeys = Object.keys(where);
+            const sql = `UPDATE
 ${table}
- SET ${setString} WHERE ${whereString}`;
-            const values = [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))];
-            const result = await this.query(sql, values);
+ SET ${set} WHERE ${wKeys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, [...Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v), ...Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v)]);
             return result.affectedRows;
         });
     }
     async delete(table, where) {
-        return this._queueRequest(async () => {
-            if (!where || Object.keys(where).length === 0)
-                return 0;
-            await this.ensureTable(table, { ...where });
-            await this._ensureMissingColumns(table, where);
-            const whereString = Object.keys(where).map(k => `
-${k}
- = ?`).join(" AND ");
-            const sql = `DELETE FROM 
+        await this.runHooks('beforeDelete', table, where);
+        return this._execute('delete', table, async () => {
+            await this.ensureTable(table, where);
+            const keys = Object.keys(where);
+            const sql = `DELETE FROM
 ${table}
- WHERE ${whereString}`;
-            const result = await this.query(sql, Object.values(where).map(v => this._serializeValue(v)));
+ WHERE ${keys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
             return result.affectedRows;
         });
     }
     async select(table, where = null) {
-        return this._queueRequest(async () => {
+        return this._execute('select', table, async () => {
             await this.ensureTable(table, where || {});
-            if (where && Object.keys(where).length > 0) {
-                await this._ensureMissingColumns(table, where);
-            }
-            let sql = `SELECT * FROM 
+            const keys = where ? Object.keys(where) : [];
+            const sql = `SELECT * FROM
 ${table}
-`;
-            let params = [];
-            if (where && Object.keys(where).length > 0) {
-                const whereString = Object.keys(where).map(k => `
+ ` + (keys.length ? ' WHERE ' + keys.map(k => `
 ${k}
- = ?`).join(" AND ");
-                sql += ` WHERE ${whereString}`;
-                params = Object.values(where).map(v => this._serializeValue(v));
-            }
-            const rows = await this.query(sql, params);
+ = ?`).join(" AND ") : '');
+            const rows = await this.query(sql, keys.map(k => typeof where[k] === 'object' ? JSON.stringify(where[k]) : where[k]));
             return rows.map((row) => {
-                const newRow = {};
-                for (const key in row) {
-                    newRow[key] = this._deserializeValue(row[key]);
+                const nr = {};
+                for (const k in row) {
+                    try {
+                        nr[k] = JSON.parse(row[k]);
+                    }
+                    catch {
+                        nr[k] = row[k];
+                    }
                 }
-                return newRow;
+                return nr;
             });
         });
     }
-    async set(table, data, where) {
-        return this._queueRequest(async () => {
-            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;
+        const res = await this.select(table, where);
+        return res[0] || null;
+    }
+    async set(table, data, where) {
+        const existing = await this.selectOne(table, where);
+        return existing ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
     async bulkInsert(table, dataArray) {
-        return this._queueRequest(async () => {
-            if (!Array.isArray(dataArray) || dataArray.length === 0)
-                return 0;
+        if (!dataArray.length)
+            return 0;
+        return this._execute('bulkInsert', table, async () => {
             await this.ensureTable(table, dataArray[0]);
-            const existingColumns = await this.query(`DESCRIBE 
-${table}
-`);
-            const existingColumnNames = existingColumns.map((col) => col.Field);
-            const allKeys = new Set();
-            dataArray.forEach(obj => Object.keys(obj).forEach(key => allKeys.add(key)));
-            for (const key of allKeys) {
-                if (!existingColumnNames.includes(key)) {
-                    const columnValues = dataArray.map(obj => obj[key]).filter(val => val !== undefined && val !== null);
-                    const columnType = columnValues.length > 0 ? this._getBestColumnType(columnValues) : 'TEXT';
-                    await this.query(`ALTER TABLE 
-${table}
- ADD COLUMN 
-${key}
- ${columnType}`);
-                }
-            }
-            const keys = Array.from(allKeys);
+            const keys = Object.keys(dataArray[0]);
             const placeholders = dataArray.map(() => `(${keys.map(() => '?').join(',')})`).join(',');
             const values = dataArray.flatMap(obj => keys.map(k => this._serializeValue(obj[k])));
-            const sql = `INSERT INTO 
+            const sql = `INSERT INTO
 ${table}
  (${keys.map(k => `
 ${k}
@@ -316,69 +202,62 @@ ${k}
             return result.affectedRows;
         });
     }
-    async close() {
-        if (this.pool)
-            await this.pool.end();
-    }
-    _serializeValue(value) {
-        if (value instanceof Date)
-            return value.toISOString().slice(0, 19).replace('T', ' ');
-        if (Array.isArray(value) || (typeof value === 'object' && value !== null))
-            return JSON.stringify(value);
-        return value;
-    }
-    _deserializeValue(value) {
-        try {
-            if (typeof value === 'string' && (value.startsWith('[') || value.startsWith('{'))) {
-                const parsed = JSON.parse(value);
-                if (typeof parsed === 'object' && parsed !== null)
-                    return parsed;
-            }
-        }
-        catch (e) { }
-        return value;
-    }
-    async increment(table, increments, where = {}) {
-        return this._queueRequest(async () => {
-            const incrementClauses = Object.keys(increments).map(field => `
-${field}
- = 
-${field}
+    async increment(table, incs, where) {
+        return this._execute('increment', table, async () => {
+            await this.ensureTable(table, where);
+            const set = Object.keys(incs).map(f => `
+${f}
+ =
+${f}
  + ?`).join(', ');
-            const incrementValues = Object.values(increments);
-            const { whereClause, values: whereValues } = this._buildWhereClause(where);
-            const sql = `UPDATE 
+            const wKeys = Object.keys(where);
+            const sql = `UPDATE
 ${table}
- SET ${incrementClauses}${whereClause}`;
-            const result = await this.query(sql, [...incrementValues, ...whereValues]);
+ SET ${set} WHERE ${wKeys.map(k => `
+${k}
+ = ?`).join(" AND ")}`;
+            const result = await this.query(sql, [...Object.values(incs), ...Object.values(where).map(v => typeof v === 'object' ? JSON.stringify(v) : v)]);
             return result.affectedRows;
         });
     }
-    async decrement(table, decrements, where = {}) {
-        return this._queueRequest(async () => {
-            const decrementClauses = Object.keys(decrements).map(field => `
-${field}
- = 
-${field}
- + ?`).join(', ');
-            const decrementValues = Object.values(decrements);
-            const { whereClause, values: whereValues } = this._buildWhereClause(where);
-            const sql = `UPDATE 
-${table}
- SET ${decrementClauses}${whereClause}`;
-            const result = await this.query(sql, [...decrementValues, ...whereValues]);
-            return result.affectedRows;
-        });
+    async decrement(table, decs, where) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
+    }
+    async close() { if (this.pool)
+        await this.pool.end(); }
+    _getColumnType(v) {
+        if (v === null || v === undefined)
+            return 'TEXT';
+        if (typeof v === 'boolean')
+            return 'BOOLEAN';
+        if (typeof v === 'number')
+            return Number.isInteger(v) ? 'INT' : 'DOUBLE';
+        if (v instanceof Date)
+            return 'DATETIME';
+        if (typeof v === 'object')
+            return 'JSON';
+        return 'TEXT';
     }
-    _buildWhereClause(where = {}) {
-        const conditions = Object.keys(where);
-        if (conditions.length === 0)
+    _serializeValue(v) {
+        if (v instanceof Date)
+            return v.toISOString().slice(0, 19).replace('T', ' ');
+        return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
+    }
+    _buildWhereClause(where) {
+        if (!where)
             return { whereClause: '', values: [] };
-        const whereClause = ' WHERE ' + conditions.map(key => `
-${key}
- = ?`).join(' AND ');
-        const values = Object.values(where).map(v => this._serializeValue(v));
-        return { whereClause, values };
+        const keys = Object.keys(where);
+        if (!keys.length)
+            return { whereClause: '', values: [] };
+        return {
+            whereClause: 'WHERE ' + keys.map(k => `
+${k}
+ = ?`).join(' AND '),
+            values: Object.values(where).map(v => this._serializeValue(v))
+        };
     }
 }
 exports.MySQLDatabase = MySQLDatabase;

package/dist/database/pg.d.ts

@@ -7,24 +7,22 @@ export declare class PostgreSQLDatabase extends IDatabase {
     private _connected;
     private _connectionPromise;
     constructor(config: PostgreSQLConfig);
-    private _getColumnType;
-    private _getBestColumnType;
-    private _ensureMissingColumns;
-    private _queueRequest;
+    private _execute;
     private _processQueue;
     query(sql: string, params?: any[]): Promise<any>;
-    ensureTable(table: string, data?: Record<string, any>): Promise<void>;
-    insert(table: string, data: Record<string, any>): Promise<any>;
-    update(table: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
-    delete(table: string, where: Record<string, any>): Promise<number>;
-    select<T = any>(table: string, where?: Record<string, any> | null): Promise<T[]>;
-    set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
-    selectOne<T = any>(table: string, where?: Record<string, any> | null): Promise<T | null>;
-    bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
+    ensureTable(table: string, data?: any): Promise<void>;
+    insert(table: string, data: any): Promise<any>;
+    update(table: string, data: any, where: any): Promise<number>;
+    delete(table: string, where: any): Promise<number>;
+    select<T = any>(table: string, where?: any): Promise<T[]>;
+    selectOne<T = any>(table: string, where?: any): Promise<T | null>;
+    set(table: string, data: any, where: any): Promise<any>;
+    bulkInsert(table: string, dataArray: any[]): Promise<number>;
+    increment(table: string, incs: Record<string, number>, where: any): Promise<number>;
+    decrement(table: string, decs: Record<string, number>, where: any): Promise<number>;
     close(): Promise<void>;
+    private _getColumnType;
     private _serializeValue;
-    increment(table: string, increments: Record<string, number>, where?: Record<string, any>): Promise<number>;
-    decrement(table: string, decrements: Record<string, number>, where?: Record<string, any>): Promise<number>;
     private _buildWhereClause;
 }
 export default PostgreSQLDatabase;