@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/pg.js

@@ -12,103 +12,32 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         this.config = config;
         this._connectionPromise = new Promise(async (resolve, reject) => {
             try {
-                const tempPool = new pg_1.Pool({
-                    host: config.host,
-                    port: config.port || 5432,
-                    user: config.user,
-                    password: config.password,
-                    database: 'postgres'
-                });
+                const tempPool = new pg_1.Pool({ host: config.host || 'localhost', port: config.port || 5432, user: config.username, password: config.password, database: 'postgres' });
                 try {
                     await tempPool.query(`CREATE DATABASE "${config.database}"`);
                 }
-                catch (error) {
-                    if (!error.message.includes('already exists')) {
-                        console.warn('Database creation warning:', error.message);
-                    }
+                catch (e) {
+                    if (!e.message.includes('already exists'))
+                        console.warn(e.message);
                 }
                 await tempPool.end();
-                this.pool = new pg_1.Pool({
-                    host: config.host,
-                    port: config.port || 5432,
-                    user: config.user,
-                    password: config.password,
-                    database: config.database,
-                    max: config.connectionLimit || 10,
-                    idleTimeoutMillis: 30000,
-                    connectionTimeoutMillis: 2000,
-                });
+                this.pool = new pg_1.Pool({ host: config.host || 'localhost', port: config.port || 5432, user: config.username, password: config.password, database: config.database, max: config.poolSize || 10 });
                 this._connected = true;
                 resolve(this.pool);
                 this._processQueue();
             }
             catch (error) {
-                console.error("PostgreSQL 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 >= -32768 && value <= 32767)
-                    return 'SMALLINT';
-                if (value >= -2147483648 && value <= 2147483647)
-                    return 'INTEGER';
-                return 'BIGINT';
-            }
-            return 'DOUBLE PRECISION';
-        }
-        if (typeof value === 'string') {
-            return value.length <= 255 ? 'VARCHAR(255)' : 'TEXT';
-        }
-        if (typeof value === 'object')
-            return 'JSONB';
-        if (value instanceof Date)
-            return 'TIMESTAMP';
-        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 = {
-            'TEXT': 10, 'JSONB': 9, 'VARCHAR(255)': 8, 'TIMESTAMP': 7,
-            'DOUBLE PRECISION': 6, 'BIGINT': 5, 'INTEGER': 4, 'SMALLINT': 3, 'BOOLEAN': 2
-        };
-        return uniqueTypes.sort((a, b) => (typePriority[b] || 0) - (typePriority[a] || 0))[0];
-    }
-    async _ensureMissingColumns(table, data) {
-        const existingColumns = await this.query(`
-      SELECT column_name 
-      FROM information_schema.columns 
-      WHERE table_name = $1 AND table_schema = 'public'
-    `, [table]);
-        if (!existingColumns || existingColumns.length === 0)
-            throw new Error(`Table ${table} does not exist.`);
-        const existingColumnNames = existingColumns.map(col => col.column_name);
-        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 });
-            });
-        }
+    async _execute(op, table, fn) {
+        const start = Date.now();
+        const res = await fn();
+        this.recordMetric(op, table, Date.now() - start);
+        return res;
     }
+    ;
     async _processQueue() {
         if (!this._connected)
             return;
@@ -116,8 +45,7 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
             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);
@@ -126,174 +54,137 @@ class PostgreSQLDatabase extends IDatabase_1.IDatabase {
         }
     }
     async query(sql, params = []) {
-        return this._queueRequest(async () => {
-            const pool = await this._connectionPromise;
-            const result = await pool.query(sql, params);
-            return result.rows;
-        });
+        const pool = await this._connectionPromise;
+        const res = await pool.query(sql, params);
+        return res.rows;
     }
     async ensureTable(table, data = {}) {
-        return this._queueRequest(async () => {
-            const tables = await this.query(`
-        SELECT table_name 
-        FROM information_schema.tables 
-        WHERE table_schema = 'public' AND table_name = $1
-      `, [table]);
-            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 "${table}" ("_id" SERIAL PRIMARY KEY ${columnsPart})`;
-                await this.query(createTableSQL);
+        const tables = await this.query(`SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND table_name = $1`, [table]);
+        if (tables.length === 0) {
+            const defs = Object.keys(data).map(k => `"${k}" TEXT`);
+            await this.query(`CREATE TABLE "${table}" ("_id" SERIAL PRIMARY KEY ${defs.length ? ', ' + defs.join(",") : ''})`);
+        }
+        else {
+            const existing = await this.query(`SELECT column_name FROM information_schema.columns WHERE table_name = $1 AND table_schema = 'public'`, [table]);
+            const names = existing.map((c) => c.column_name);
+            for (const key of Object.keys(data)) {
+                if (key !== '_id' && !names.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(`
-        SELECT column_name, column_default 
-        FROM information_schema.columns 
-        WHERE table_name = $1 AND table_schema = 'public'
-      `, [table]);
-            const primaryKeyColumn = existingColumns.find(col => col.column_default && col.column_default.includes('nextval'));
-            if (primaryKeyColumn && copy[primaryKeyColumn.column_name] !== undefined) {
-                delete copy[primaryKeyColumn.column_name];
-            }
-            const keys = Object.keys(copy);
-            const placeholders = keys.map((_, index) => `$${index + 1}`).join(",");
-            const values = Object.values(copy).map(value => this._serializeValue(value));
-            const sql = `INSERT INTO "${table}" (${keys.map(k => `"${k}"`).join(",")}) VALUES (${placeholders}) RETURNING "_id"`;
-            const result = await this.query(sql, values);
-            return result[0]._id;
+        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 (${keys.map((_, i) => `$${i + 1}`).join(",")}) RETURNING "_id"`;
+            const res = await this.query(sql, Object.values(data).map(v => this._serializeValue(v)));
+            const finalData = { _id: res[0]._id, ...data };
+            await this.runHooks('afterInsert', table, finalData);
+            return res[0]._id;
         });
     }
     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, i) => `"${k}" = $${i + 1}`).join(", ");
-            const whereString = Object.keys(where).map((k, i) => `"${k}" = $${Object.keys(data).length + i + 1}`).join(" AND ");
-            const sql = `UPDATE "${table}" SET ${setString} WHERE ${whereString}`;
+            const set = Object.keys(data).map((k, i) => `"${k}" = $${i + 1}`).join(",");
+            const { whereClause, values: whereValues } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
             const pool = await this._connectionPromise;
-            const result = await pool.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
-            return result.rowCount ?? 0;
+            const res = await pool.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...whereValues]);
+            return res.rowCount ?? 0;
         });
     }
     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, i) => `"${k}" = $${i + 1}`).join(" AND ");
-            const sql = `DELETE FROM "${table}" WHERE ${whereString}`;
+        await this.runHooks('beforeDelete', table, where);
+        return this._execute('delete', table, async () => {
+            await this.ensureTable(table, where);
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `DELETE FROM "${table}" ${whereClause}`;
             const pool = await this._connectionPromise;
-            const result = await pool.query(sql, Object.values(where).map(v => this._serializeValue(v)));
-            return result.rowCount ?? 0;
+            const res = await pool.query(sql, values);
+            return res.rowCount ?? 0;
         });
     }
     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 "${table}"`;
-            let params = [];
-            if (where && Object.keys(where).length > 0) {
-                const whereString = Object.keys(where).map((k, i) => `"${k}" = $${i + 1}`).join(" AND ");
-                sql += ` WHERE ${whereString}`;
-                params = Object.values(where).map(v => this._serializeValue(v));
-            }
-            const rows = await this.query(sql, params);
-            return rows;
-        });
-    }
-    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);
-            }
+            const { whereClause, values } = this._buildWhereClause(where);
+            const rows = await this.query(`SELECT * FROM "${table}" ${whereClause}`, values);
+            return rows.map((r) => {
+                const nr = {};
+                for (const k in r)
+                    nr[k] = r[k];
+                return nr;
+            });
         });
     }
     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 ex = await this.selectOne(table, where);
+        return ex ? 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;
-            await this.ensureTable(table, dataArray[0]);
-            const allKeys = new Set();
-            dataArray.forEach(obj => Object.keys(obj).forEach(key => allKeys.add(key)));
-            const existingColumns = await this.query(`
-        SELECT column_name 
-        FROM information_schema.columns 
-        WHERE table_name = $1 AND table_schema = 'public'
-      `, [table]);
-            const existingColumnNames = existingColumns.map(col => col.column_name);
-            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 placeholders = dataArray.map((_, rowIndex) => `(${keys.map((_, colIndex) => `$${rowIndex * keys.length + colIndex + 1}`).join(',')})`).join(',');
-            const values = dataArray.flatMap(obj => keys.map(k => this._serializeValue(obj[k])));
-            const sql = `INSERT INTO "${table}" (${keys.map(k => `"${k}"`).join(",")}) VALUES ${placeholders}`;
+        if (!dataArray.length)
+            return 0;
+        for (const d of dataArray)
+            await this.insert(table, d);
+        return dataArray.length;
+    }
+    async increment(table, incs, where) {
+        return this._execute('increment', table, async () => {
+            await this.ensureTable(table, where);
+            const set = Object.keys(incs).map((f, i) => `"${f}" = "${f}" + $${i + 1}`).join(',');
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
             const pool = await this._connectionPromise;
-            const result = await pool.query(sql, values);
-            return result.rowCount ?? 0;
+            const res = await pool.query(sql, [...Object.values(incs), ...values]);
+            return res.rowCount ?? 0;
         });
     }
-    async close() {
-        if (this.pool)
-            await this.pool.end();
-    }
-    _serializeValue(value) {
-        if (value instanceof Date)
-            return value.toISOString();
-        if (Array.isArray(value) || (typeof value === 'object' && value !== null))
-            return JSON.stringify(value);
-        return value;
+    async decrement(table, decs, where) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
     }
-    async increment(table, increments, where = {}) {
-        const incrementClauses = Object.keys(increments).map((field, index) => `"${field}" = "${field}" + $${index + 1}`).join(', ');
-        const incrementValues = Object.values(increments);
-        const { whereClause, values: whereValues } = this._buildWhereClause(where, incrementValues.length);
-        const sql = `UPDATE "${table}" SET ${incrementClauses}${whereClause}`;
-        const pool = await this._connectionPromise;
-        const result = await pool.query(sql, [...incrementValues, ...whereValues]);
-        return result.rowCount ?? 0;
+    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) ? 'INTEGER' : 'DOUBLE PRECISION';
+        if (v instanceof Date)
+            return 'TIMESTAMP';
+        if (typeof v === 'object')
+            return 'JSONB';
+        return 'TEXT';
     }
-    async decrement(table, decrements, where = {}) {
-        const decrementClauses = Object.keys(decrements).map((field, index) => `"${field}" = "${field}" - $${index + 1}`).join(', ');
-        const decrementValues = Object.values(decrements);
-        const { whereClause, values: whereValues } = this._buildWhereClause(where, decrementValues.length);
-        const sql = `UPDATE "${table}" SET ${decrementClauses}${whereClause}`;
-        const pool = await this._connectionPromise;
-        const result = await pool.query(sql, [...decrementValues, ...whereValues]);
-        return result.rowCount ?? 0;
+    _serializeValue(v) {
+        if (v instanceof Date)
+            return v.toISOString();
+        return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
     }
-    _buildWhereClause(where = {}, startIndex = 0) {
-        const conditions = Object.keys(where);
-        if (conditions.length === 0)
+    _buildWhereClause(where) {
+        if (!where)
+            return { whereClause: '', values: [] };
+        const safeWhere = where;
+        const keys = Object.keys(safeWhere);
+        if (!keys.length)
             return { whereClause: '', values: [] };
-        const whereClause = ' WHERE ' + conditions.map((key, index) => `"${key}" = $${startIndex + index + 1}`).join(' AND ');
-        const values = Object.values(where).map(v => this._serializeValue(v));
-        return { whereClause, values };
+        return {
+            whereClause: 'WHERE ' + keys.map((k, i) => `"${k}" = $${i + 1}`).join(' AND '),
+            values: keys.map(k => this._serializeValue(safeWhere[k]))
+        };
     }
 }
 exports.PostgreSQLDatabase = PostgreSQLDatabase;

package/dist/database/redis.d.ts

@@ -1,11 +1,13 @@
 import { IDatabase } from './IDatabase';
 import { RedisClientType } from 'redis';
+import { RedisConfig } from './types';
 export declare class RedisDatabase extends IDatabase {
     private config;
     private client;
     private isConnecting;
     private keyPrefix;
-    constructor(config?: any);
+    constructor(config: RedisConfig);
+    private _execute;
     connect(): Promise<RedisClientType>;
     private _getKey;
     private _getTableKey;
@@ -16,8 +18,8 @@ export declare class RedisDatabase extends IDatabase {
     delete(table: string, where: Record<string, any>): Promise<number>;
     set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
     bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
-    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>;
+    increment(table: string, incs: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    decrement(table: string, decs: Record<string, number>, where?: Record<string, any>): Promise<number>;
     close(): Promise<void>;
 }
 export default RedisDatabase;