@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/database/pg.js

@@ -0,0 +1,300 @@
+"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,
+                    port: config.port || 5432,
+                    user: config.user,
+                    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);
+                    }
+                }
+                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._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 _processQueue() {
+        if (!this._connected)
+            return;
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (item) {
+                try {
+                    const result = await item.operation();
+                    item.resolve(result);
+                }
+                catch (error) {
+                    item.reject(error);
+                }
+            }
+        }
+    }
+    async query(sql, params = []) {
+        return this._queueRequest(async () => {
+            const pool = await this._connectionPromise;
+            const result = await pool.query(sql, params);
+            return result.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);
+            }
+        });
+    }
+    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;
+        });
+    }
+    async update(table, data, where) {
+        return this._queueRequest(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 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;
+        });
+    }
+    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}`;
+            const pool = await this._connectionPromise;
+            const result = await pool.query(sql, Object.values(where).map(v => this._serializeValue(v)));
+            return result.rowCount ?? 0;
+        });
+    }
+    async select(table, where = null) {
+        return this._queueRequest(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);
+            }
+        });
+    }
+    async selectOne(table, where = null) {
+        const results = await this.select(table, where);
+        return results[0] || null;
+    }
+    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}`;
+            const pool = await this._connectionPromise;
+            const result = await pool.query(sql, values);
+            return result.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 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 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;
+    }
+    _buildWhereClause(where = {}, startIndex = 0) {
+        const conditions = Object.keys(where);
+        if (conditions.length === 0)
+            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 };
+    }
+}
+exports.PostgreSQLDatabase = PostgreSQLDatabase;
+exports.default = PostgreSQLDatabase;

package/dist/database/redis.d.ts

@@ -0,0 +1,23 @@
+import { IDatabase } from './IDatabase';
+import { RedisClientType } from 'redis';
+export declare class RedisDatabase extends IDatabase {
+    private config;
+    private client;
+    private isConnecting;
+    private keyPrefix;
+    constructor(config?: any);
+    connect(): Promise<RedisClientType>;
+    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>;
+    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>;
+    close(): Promise<void>;
+}
+export default RedisDatabase;

package/dist/database/redis.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisDatabase = void 0;
+const IDatabase_1 = require("./IDatabase");
+const redis_1 = require("redis");
+class RedisDatabase extends IDatabase_1.IDatabase {
+    constructor(config = {}) {
+        super();
+        this.client = null;
+        this.isConnecting = false;
+        this.config = {
+            host: config.host || '127.0.0.1',
+            port: config.port || 6379,
+            password: config.password,
+            db: config.db || 0,
+            connectTimeout: config.connectTimeout || 5000,
+        };
+        this.keyPrefix = config.keyPrefix || 'app:';
+    }
+    async connect() {
+        if (this.client && this.client.isReady)
+            return this.client;
+        if (this.isConnecting) {
+            while (this.isConnecting) {
+                await new Promise(resolve => setTimeout(resolve, 100));
+            }
+            return this.client;
+        }
+        this.isConnecting = true;
+        try {
+            this.client = (0, redis_1.createClient)({
+                socket: {
+                    host: this.config.host,
+                    port: this.config.port,
+                    connectTimeout: this.config.connectTimeout,
+                },
+                password: this.config.password,
+                database: this.config.db,
+            });
+            this.client.on('error', (err) => console.error('Redis Error:', err.message));
+            await this.client.connect();
+            return this.client;
+        }
+        finally {
+            this.isConnecting = false;
+        }
+    }
+    _getKey(table, id) {
+        return `${this.keyPrefix}${table}:${id}`;
+    }
+    _getTableKey(table) {
+        return `${this.keyPrefix}${table}:*`;
+    }
+    async select(table, where = {}) {
+        const client = await this.connect();
+        const pattern = this._getTableKey(table);
+        const keys = await client.keys(pattern);
+        if (!keys.length)
+            return [];
+        const values = await client.mGet(keys);
+        return values
+            .map(v => {
+            try {
+                return v ? JSON.parse(v) : null;
+            }
+            catch (e) {
+                return null;
+            }
+        })
+            .filter(Boolean)
+            .filter(item => Object.entries(where).every(([k, val]) => item[k] === val));
+    }
+    async selectOne(table, where = {}) {
+        const results = await this.select(table, where);
+        return results.length ? results[0] : null;
+    }
+    async insert(table, data) {
+        const client = await this.connect();
+        const insertData = { ...data };
+        if (!insertData._id && !insertData.id) {
+            insertData._id = Date.now().toString() + Math.random().toString(36).slice(2, 9);
+        }
+        const id = insertData._id || insertData.id;
+        const key = this._getKey(table, id);
+        await client.set(key, JSON.stringify(insertData));
+        return insertData;
+    }
+    async update(table, data, where) {
+        const existing = await this.select(table, where);
+        if (!existing.length)
+            return 0;
+        const client = await this.connect();
+        for (const item of existing) {
+            const merged = { ...item, ...data };
+            const id = item._id || item.id;
+            await client.set(this._getKey(table, id), JSON.stringify(merged));
+        }
+        return existing.length;
+    }
+    async delete(table, where) {
+        const existing = await this.select(table, where);
+        if (!existing.length)
+            return 0;
+        const client = await this.connect();
+        const keys = existing.map(item => this._getKey(table, item._id || item.id));
+        await client.del(keys);
+        return existing.length;
+    }
+    async set(table, data, where) {
+        const existing = await this.selectOne(table, where);
+        if (existing) {
+            await this.update(table, data, where);
+            return existing;
+        }
+        else {
+            return await this.insert(table, { ...data, ...where });
+        }
+    }
+    async bulkInsert(table, dataArray) {
+        for (const data of dataArray) {
+            await this.insert(table, data);
+        }
+        return dataArray.length;
+    }
+    async increment(table, increments, where = {}) {
+        const records = await this.select(table, where);
+        const client = await this.connect();
+        for (const record of records) {
+            for (const [field, value] of Object.entries(increments)) {
+                record[field] = (Number(record[field]) || 0) + value;
+            }
+            const id = record._id || record.id;
+            await client.set(this._getKey(table, id), JSON.stringify(record));
+        }
+        return records.length;
+    }
+    async decrement(table, decrements, where = {}) {
+        const records = await this.select(table, where);
+        const client = await this.connect();
+        for (const record of records) {
+            for (const [field, value] of Object.entries(decrements)) {
+                record[field] = (Number(record[field]) || 0) - value;
+            }
+            const id = record._id || record.id;
+            await client.set(this._getKey(table, id), JSON.stringify(record));
+        }
+        return records.length;
+    }
+    async close() {
+        if (this.client) {
+            await this.client.quit();
+            this.client = null;
+        }
+    }
+}
+exports.RedisDatabase = RedisDatabase;
+exports.default = RedisDatabase;

package/dist/database/sqlite.d.ts

@@ -0,0 +1,25 @@
+import { IDatabase } from './IDatabase';
+import { SQLiteConfig } from './types';
+export declare class SQLiteDatabase extends IDatabase {
+    private db;
+    constructor(config: SQLiteConfig);
+    private _detectColumnType;
+    private _determineBestColumnType;
+    private _ensureMissingColumns;
+    query(sql: string, params?: any[]): Promise<any>;
+    ensureTable(table: string, data?: Record<string, any>): Promise<void>;
+    private _serializeValue;
+    private _deserializeValue;
+    insert(table: string, data: Record<string, any>): Promise<number>;
+    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>;
+    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;
+    close(): Promise<void>;
+}
+export default SQLiteDatabase;