@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/redis.js

@@ -4,40 +4,36 @@ exports.RedisDatabase = void 0;
 const IDatabase_1 = require("./IDatabase");
 const redis_1 = require("redis");
 class RedisDatabase extends IDatabase_1.IDatabase {
-    constructor(config = {}) {
+    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.config = config;
         this.keyPrefix = config.keyPrefix || 'app:';
     }
+    async _execute(op, table, fn) {
+        const start = Date.now();
+        const res = await fn();
+        this.recordMetric(op, table, Date.now() - start);
+        return res;
+    }
+    ;
     async connect() {
         if (this.client && this.client.isReady)
             return this.client;
         if (this.isConnecting) {
-            while (this.isConnecting) {
-                await new Promise(resolve => setTimeout(resolve, 100));
-            }
+            while (this.isConnecting)
+                await new Promise(r => setTimeout(r, 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,
-                },
+                url: this.config.url,
+                socket: { host: this.config.host || '127.0.0.1', port: this.config.port || 6379 },
                 password: this.config.password,
-                database: this.config.db,
+                database: Number(this.config.database) || 0,
             });
-            this.client.on('error', (err) => console.error('Redis Error:', err.message));
             await this.client.connect();
             return this.client;
         }
@@ -45,113 +41,91 @@ class RedisDatabase extends IDatabase_1.IDatabase {
             this.isConnecting = false;
         }
     }
-    _getKey(table, id) {
-        return `${this.keyPrefix}${table}:${id}`;
-    }
-    _getTableKey(table) {
-        return `${this.keyPrefix}${table}:*`;
-    }
+    _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));
+        return this._execute('select', table, async () => {
+            const client = await this.connect();
+            const keys = await client.keys(this._getTableKey(table));
+            if (!keys.length)
+                return [];
+            const vals = await client.mGet(keys);
+            return vals.map(v => v ? JSON.parse(v) : null).filter(Boolean)
+                .filter(item => Object.entries(where).every(([k, v]) => String(item[k]) === String(v)));
+        });
     }
     async selectOne(table, where = {}) {
-        const results = await this.select(table, where);
-        return results.length ? results[0] : null;
+        const res = await this.select(table, where);
+        return res[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;
+        await this.runHooks('beforeInsert', table, data);
+        return this._execute('insert', table, async () => {
+            const client = await this.connect();
+            const d = { ...data };
+            if (!d._id && !d.id)
+                d._id = Date.now().toString() + Math.random().toString(36).slice(2, 9);
+            const id = String(d._id || d.id);
+            await client.set(this._getKey(table, id), JSON.stringify(d));
+            await this.runHooks('afterInsert', table, d);
+            return d._id || d.id;
+        });
     }
     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;
+        await this.runHooks('beforeUpdate', table, { data, where });
+        return this._execute('update', table, async () => {
+            const existing = await this.select(table, where);
+            const client = await this.connect();
+            for (const item of existing) {
+                const merged = { ...item, ...data };
+                await client.set(this._getKey(table, item._id || item.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;
+        await this.runHooks('beforeDelete', table, where);
+        return this._execute('delete', table, async () => {
+            const existing = await this.select(table, where);
+            const client = await this.connect();
+            if (existing.length) {
+                const keys = existing.map(i => this._getKey(table, String(i._id || i.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 });
-        }
+        const ex = await this.selectOne(table, where);
+        return ex ? this.update(table, data, where) : this.insert(table, { ...data, ...where });
     }
     async bulkInsert(table, dataArray) {
-        for (const data of dataArray) {
-            await this.insert(table, data);
-        }
+        for (const d of dataArray)
+            await this.insert(table, d);
         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;
+    async increment(table, incs, where = {}) {
+        return this._execute('increment', table, async () => {
+            const recs = await this.select(table, where);
+            const client = await this.connect();
+            for (const r of recs) {
+                for (const [f, v] of Object.entries(incs))
+                    r[f] = (Number(r[f]) || 0) + v;
+                await client.set(this._getKey(table, r._id || r.id), JSON.stringify(r));
             }
-            const id = record._id || record.id;
-            await client.set(this._getKey(table, id), JSON.stringify(record));
-        }
-        return records.length;
+            return recs.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;
-        }
+    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.client) {
+        await this.client.quit();
+        this.client = null;
+    } }
 }
 exports.RedisDatabase = RedisDatabase;
 exports.default = RedisDatabase;

package/dist/database/seeder.d.ts

@@ -0,0 +1,20 @@
+import { IDatabase } from './IDatabase';
+export interface SeederField {
+    type: 'string' | 'number' | 'email' | 'id' | 'date' | 'boolean' | 'pick';
+    values?: any[];
+    min?: number;
+    max?: number;
+    length?: number;
+}
+export interface SeederSchema {
+    [key: string]: SeederField;
+}
+export declare class DataSeeder {
+    private db;
+    constructor(database: IDatabase);
+    private generateValue;
+    /**
+     * Seeds a table with mock data based on a schema.
+     */
+    seed(table: string, count: number, schema: SeederSchema): Promise<number>;
+}

package/dist/database/seeder.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSeeder = void 0;
+const index_1 = require("../functions/index");
+class DataSeeder {
+    constructor(database) {
+        this.db = database;
+    }
+    generateValue(field) {
+        switch (field.type) {
+            case 'id': return Date.now().toString(36) + Math.random().toString(36).substr(2);
+            case 'email': return `${(0, index_1.randomText)(5)}@${(0, index_1.randomArray)(['gmail.com', 'outlook.com', 'zero.io'])}`;
+            case 'number': return (0, index_1.randomNumber)(field.min ?? 0, field.max ?? 1000);
+            case 'string': return (0, index_1.randomText)(field.length ?? 8);
+            case 'boolean': return Math.random() > 0.5;
+            case 'date': return new Date(Date.now() - Math.random() * 10000000000);
+            case 'pick': return (0, index_1.randomArray)(field.values ?? []);
+            default: return null;
+        }
+    }
+    /**
+     * Seeds a table with mock data based on a schema.
+     */
+    async seed(table, count, schema) {
+        const dataArray = [];
+        for (let i = 0; i < count; i++) {
+            const row = {};
+            for (const [key, field] of Object.entries(schema)) {
+                row[key] = this.generateValue(field);
+            }
+            dataArray.push(row);
+        }
+        await this.db.bulkInsert(table, dataArray);
+        return count;
+    }
+}
+exports.DataSeeder = DataSeeder;

package/dist/database/sqlite.d.ts

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