@onurege3467/zerohelper 10.2.6 → 11.0.0

package/dist/database/mysql.js

@@ -1,282 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MySQLDatabase = void 0;
-const IDatabase_1 = require("./IDatabase");
-const promise_1 = __importDefault(require("mysql2/promise"));
-class MySQLDatabase extends IDatabase_1.IDatabase {
-    constructor(config) {
-        super();
-        this.pool = null;
-        this._queue = [];
-        this._connected = false;
-        this.config = config;
-        this._connectionPromise = new Promise(async (resolve, reject) => {
-            try {
-                const connection = await promise_1.default.createConnection({
-                    host: config.host || 'localhost',
-                    port: config.port || 3306,
-                    user: config.username,
-                    password: config.password,
-                });
-                await connection.query(`CREATE DATABASE IF NOT EXISTS
-${config.database}
-`);
-                await connection.end();
-                this.pool = promise_1.default.createPool({
-                    host: config.host || 'localhost',
-                    port: config.port || 3306,
-                    user: config.username,
-                    password: config.password,
-                    database: config.database,
-                    waitForConnections: true,
-                    connectionLimit: config.poolSize || 15, // Balanced limit
-                    queueLimit: 0,
-                    enableKeepAlive: true,
-                    keepAliveInitialDelay: 10000
-                });
-                this._connected = true;
-                resolve(this.pool);
-                this._processQueue();
-            }
-            catch (error) {
-                this._queue.forEach(q => q.reject(error));
-                this._queue = [];
-                reject(error);
-            }
-        });
-    }
-    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;
-        };
-        if (this._connected)
-            return execute();
-        return new Promise((resolve, reject) => this._queue.push({ operation: execute, resolve, reject }));
-    }
-    async _processQueue() {
-        if (!this._connected)
-            return;
-        while (this._queue.length > 0) {
-            const item = this._queue.shift();
-            if (item) {
-                try {
-                    item.resolve(await item.operation());
-                }
-                catch (error) {
-                    item.reject(error);
-                }
-            }
-        }
-    }
-    async query(sql, params = []) {
-        const pool = await this._connectionPromise;
-        let retries = 3;
-        while (retries > 0) {
-            try {
-                const [rows] = await pool.execute(sql, params);
-                return rows;
-            }
-            catch (error) {
-                if ((error.code === 'ER_CON_COUNT_ERROR' || error.message.includes('Too many connections')) && retries > 1) {
-                    retries--;
-                    await new Promise(r => setTimeout(r, 1000)); // Wait 1s and retry
-                    continue;
-                }
-                throw error;
-            }
-        }
-    }
-    async _ensureMissingColumns(table, data) {
-        const existingColumns = await this.query(`DESCRIBE
-${table}
-`).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 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}
- (_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 (${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) {
-        await this.runHooks('beforeUpdate', table, { data, where });
-        return this._execute('update', table, async () => {
-            await this.ensureTable(table, { ...data, ...where });
-            const set = Object.keys(data).map(k => `
-${k}
- = ?`).join(", ");
-            const wKeys = Object.keys(where);
-            const sql = `UPDATE
-${table}
- 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) {
-        await this.runHooks('beforeDelete', table, where);
-        return this._execute('delete', table, async () => {
-            await this.ensureTable(table, where);
-            const keys = Object.keys(where);
-            const whereClause = keys.length > 0 ? `WHERE ${keys.map(k => `
-${k}
- = ?`).join(" AND ")}` : '';
-            const sql = `DELETE FROM
-${table}
- ${whereClause}`;
-            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._execute('select', table, async () => {
-            await this.ensureTable(table, where || {});
-            const keys = where ? Object.keys(where) : [];
-            const sql = `SELECT * FROM
-${table}
- ` + (keys.length ? ' WHERE ' + keys.map(k => `
-${k}
- = ?`).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 nr = {};
-                for (const k in row) {
-                    try {
-                        nr[k] = JSON.parse(row[k]);
-                    }
-                    catch {
-                        nr[k] = row[k];
-                    }
-                }
-                return nr;
-            });
-        });
-    }
-    async selectOne(table, where = 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) {
-        if (!dataArray.length)
-            return 0;
-        return this._execute('bulkInsert', table, async () => {
-            await this.ensureTable(table, dataArray[0]);
-            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
-${table}
- (${keys.map(k => `
-${k}
-`).join(",")}) VALUES ${placeholders}`;
-            const result = await this.query(sql, values);
-            return result.affectedRows;
-        });
-    }
-    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 wKeys = Object.keys(where);
-            const sql = `UPDATE
-${table}
- 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, 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';
-    }
-    _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 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;
-exports.default = MySQLDatabase;

package/dist/database/pg.d.ts

@@ -1,28 +0,0 @@
-import { IDatabase } from './IDatabase';
-import { PostgreSQLConfig } from './types';
-export declare class PostgreSQLDatabase extends IDatabase {
-    private config;
-    private pool;
-    private _queue;
-    private _connected;
-    private _connectionPromise;
-    constructor(config: PostgreSQLConfig);
-    private _execute;
-    private _processQueue;
-    query(sql: string, params?: any[]): Promise<any>;
-    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;
-    private _buildWhereClause;
-}
-export default PostgreSQLDatabase;

package/dist/database/pg.js

@@ -1,200 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgreSQLDatabase = void 0;
-const IDatabase_1 = require("./IDatabase");
-const pg_1 = require("pg");
-class PostgreSQLDatabase extends IDatabase_1.IDatabase {
-    constructor(config) {
-        super();
-        this.pool = null;
-        this._queue = [];
-        this._connected = false;
-        this.config = config;
-        this._connectionPromise = new Promise(async (resolve, reject) => {
-            try {
-                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 (e) {
-                    if (!e.message.includes('already exists'))
-                        console.warn(e.message);
-                }
-                await tempPool.end();
-                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) {
-                this._queue.forEach(q => q.reject(error));
-                this._queue = [];
-                reject(error);
-            }
-        });
-    }
-    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;
-        while (this._queue.length > 0) {
-            const item = this._queue.shift();
-            if (item) {
-                try {
-                    item.resolve(await item.operation());
-                }
-                catch (error) {
-                    item.reject(error);
-                }
-            }
-        }
-    }
-    async query(sql, params = []) {
-        const pool = await this._connectionPromise;
-        const res = await pool.query(sql, params);
-        return res.rows;
-    }
-    async ensureTable(table, data = {}) {
-        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}" ${this._getColumnType(data[k])}`);
-            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}" ${this._getColumnType(data[key])}`);
-                }
-            }
-        }
-    }
-    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 (${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) {
-        await this.runHooks('beforeUpdate', table, { data, where });
-        return this._execute('update', table, async () => {
-            await this.ensureTable(table, { ...data, ...where });
-            const dataKeys = Object.keys(data);
-            const set = dataKeys.map((k, i) => `"${k}" = $${i + 1}`).join(",");
-            const { whereClause, values: whereValues } = this._buildWhereClause(where, dataKeys.length);
-            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
-            const pool = await this._connectionPromise;
-            const res = await pool.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...whereValues]);
-            return res.rowCount ?? 0;
-        });
-    }
-    async delete(table, where) {
-        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 res = await pool.query(sql, values);
-            return res.rowCount ?? 0;
-        });
-    }
-    async select(table, where = null) {
-        return this._execute('select', table, async () => {
-            await this.ensureTable(table, 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) {
-                    // Postgres returns numbers as strings for safety sometimes,
-                    // but since we used correct types now, driver might handle it better.
-                    // If not, we can cast if it looks like a number.
-                    // For now, let's trust the driver + schema.
-                    nr[k] = r[k];
-                }
-                return nr;
-            });
-        });
-    }
-    async selectOne(table, where = 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) {
-        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 incKeys = Object.keys(incs);
-            const set = incKeys.map((f, i) => `"${f}" = "${f}" + $${i + 1}`).join(',');
-            const { whereClause, values } = this._buildWhereClause(where, incKeys.length);
-            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
-            const pool = await this._connectionPromise;
-            const res = await pool.query(sql, [...Object.values(incs), ...values]);
-            return res.rowCount ?? 0;
-        });
-    }
-    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) ? 'INTEGER' : 'DOUBLE PRECISION';
-        if (v instanceof Date)
-            return 'TIMESTAMP';
-        if (typeof v === 'object')
-            return 'JSONB';
-        return 'TEXT';
-    }
-    _serializeValue(v) {
-        if (v instanceof Date)
-            return v.toISOString();
-        return (typeof v === 'object' && v !== null) ? JSON.stringify(v) : v;
-    }
-    _buildWhereClause(where, offset = 0) {
-        if (!where)
-            return { whereClause: '', values: [] };
-        const safeWhere = where;
-        const keys = Object.keys(safeWhere);
-        if (!keys.length)
-            return { whereClause: '', values: [] };
-        return {
-            whereClause: 'WHERE ' + keys.map((k, i) => `"${k}" = $${i + 1 + offset}`).join(' AND '),
-            values: keys.map(k => this._serializeValue(safeWhere[k]))
-        };
-    }
-}
-exports.PostgreSQLDatabase = PostgreSQLDatabase;
-exports.default = PostgreSQLDatabase;

package/dist/database/redis.d.ts

@@ -1,31 +0,0 @@
-import { IDatabase } from './IDatabase';
-import { RedisConfig } from './types';
-export declare class RedisDatabase extends IDatabase {
-    private config;
-    private client;
-    private keyPrefix;
-    private _queue;
-    private _isReady;
-    private _connectionPromise;
-    constructor(config: RedisConfig);
-    private _ensureConnection;
-    private _flushQueue;
-    private _flushQueueWithError;
-    private _execute;
-    private _getKey;
-    private _getTableKey;
-    select<T = any>(table: string, where?: Record<string, any>): Promise<T[]>;
-    selectOne<T = any>(table: string, where?: Record<string, any>): Promise<T | null>;
-    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>;
-    set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
-    bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
-    /**
-     * Atomic Increment using Lua for Redis
-     */
-    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;