@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/sqlite.js

@@ -11,262 +11,147 @@ const path_1 = __importDefault(require("path"));
 class SQLiteDatabase extends IDatabase_1.IDatabase {
     constructor(config) {
         super();
-        if (!config || !config.filename) {
-            throw new Error('SQLite yapılandırması için "filename" gereklidir.');
-        }
-        const dir = path_1.default.dirname(config.filename);
-        if (!fs_1.default.existsSync(dir)) {
+        if (!config || !config.path)
+            throw new Error('SQLite "path" gereklidir.');
+        const dir = path_1.default.dirname(config.path);
+        if (!fs_1.default.existsSync(dir))
             fs_1.default.mkdirSync(dir, { recursive: true });
-        }
-        this.db = new sqlite3_1.default.Database(config.filename, (err) => {
-            if (err) {
-                console.error("SQLite connection error:", err.message);
-            }
-        });
-    }
-    _detectColumnType(value) {
-        if (value === null || value === undefined)
-            return 'TEXT';
-        if (typeof value === 'boolean')
-            return 'BOOLEAN';
-        if (typeof value === 'number')
-            return Number.isInteger(value) ? 'INTEGER' : 'REAL';
-        if (value instanceof Date)
-            return 'DATETIME';
-        if (typeof value === 'string') {
-            if (value.trim() === '')
-                return 'TEXT';
-            if (/^-?\d+$/.test(value.trim()))
-                return 'INTEGER';
-            if (/^-?\d+\.\d+$/.test(value.trim()))
-                return 'REAL';
-            const lowerValue = value.toLowerCase().trim();
-            if (lowerValue === 'true' || lowerValue === 'false')
-                return 'BOOLEAN';
-            if (value.match(/^\d{4}-\d{2}-\d{2}/))
-                return 'DATETIME';
-        }
-        return 'TEXT';
+        this.db = new sqlite3_1.default.Database(config.path);
     }
-    _determineBestColumnType(values) {
-        const types = values.map(v => this._detectColumnType(v));
-        const typePriority = { 'INTEGER': 1, 'REAL': 2, 'BOOLEAN': 3, 'DATETIME': 4, 'TEXT': 5 };
-        const maxPriority = Math.max(...types.map(t => typePriority[t] || 5));
-        return Object.keys(typePriority).find(t => typePriority[t] === maxPriority) || 'TEXT';
+    async _execute(op, table, fn) {
+        const start = Date.now();
+        const res = await fn();
+        this.recordMetric(op, table, Date.now() - start);
+        return res;
     }
-    async _ensureMissingColumns(table, data) {
-        const columnsInfo = await this.query(`PRAGMA table_info(\`${table}\`)
-`);
-        const existingNames = columnsInfo.map(col => col.name);
-        for (const key of Object.keys(data)) {
-            if (!existingNames.includes(key)) {
-                const columnType = this._detectColumnType(data[key]);
-                await this.query(`ALTER TABLE 
-            }
-        }
-    }
-    query(sql, params = []) {
+    ;
+    async query(sql, params = []) {
         return new Promise((resolve, reject) => {
-            const upperSql = sql.trim().toUpperCase();
-            if (upperSql.startsWith('SELECT') || upperSql.startsWith('PRAGMA')) {
-                this.db.all(sql, params, (err, rows) => {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve(rows);
-                });
+            const s = sql.trim().toUpperCase();
+            if (s.startsWith('SELECT') || s.startsWith('PRAGMA')) {
+                this.db.all(sql, params, (err, rows) => err ? reject(err) : resolve(rows));
             }
             else {
-                this.db.run(sql, params, function (err) {
-                    if (err)
-                        reject(err);
-                    else
-                        resolve({ changes: this.changes, lastInsertRowid: this.lastID });
-                });
+                this.db.run(sql, params, function (err) { err ? reject(err) : resolve({ changes: this.changes, lastID: this.lastID }); });
             }
         });
     }
     async ensureTable(table, data = {}) {
         try {
-            await this.query(`SELECT 1 FROM 
-        }
-        catch (error) {
-            if (error.message.includes('no such table')) {
-                const columnDefinitions = Object.keys(data).map(col => {
-                    const columnType = this._detectColumnType(data[col]);
-                    return `reverse{col}
-                });
-                const columnsPart = columnDefinitions.length > 0 ? ', ' + columnDefinitions.join(", ") : '';
-                const createTableSQL = `CREATE TABLE 
-                await this.query(createTableSQL);
-            }
-            else {
-                throw error;
+            await this.query(`SELECT 1 FROM "${table}" LIMIT 1`);
+            const info = await this.query(`PRAGMA table_info("${table}")`);
+            const names = info.map(c => c.name);
+            for (const key of Object.keys(data)) {
+                if (key !== '_id' && !names.includes(key)) {
+                    await this.query(`ALTER TABLE "${table}" ADD COLUMN "${key}" TEXT`);
+                }
             }
         }
-    }
-    _serializeValue(value) {
-        if (value instanceof Date)
-            return value.toISOString();
-        if (Array.isArray(value) || (typeof value === 'object' && value !== null))
-            return JSON.stringify(value);
-        return value;
-    }
-    _deserializeValue(value) {
-        if (typeof value === 'string' && (value.startsWith('[') || value.startsWith('{'))) {
-            try {
-                const parsed = JSON.parse(value);
-                if (typeof parsed === 'object' && parsed !== null)
-                    return parsed;
-            }
-            catch (e) { }
+        catch {
+            const defs = Object.keys(data).map(k => `"${k}" TEXT`);
+            await this.query(`CREATE TABLE "${table}" (_id INTEGER PRIMARY KEY AUTOINCREMENT ${defs.length ? ', ' + defs.join(',') : ''})`);
         }
-        return value;
     }
     async insert(table, data) {
-        const copy = { ...data };
-        await this.ensureTable(table, copy);
-        await this._ensureMissingColumns(table, copy);
-        const keys = Object.keys(copy);
-        const placeholders = keys.map(() => '?').join(',');
-        const values = Object.values(copy).map(v => this._serializeValue(v));
-        const sql = `INSERT INTO 
-        const result = await this.query(sql, values);
-        return result.lastInsertRowid;
+        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 res = await this.query(sql, Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v));
+            const finalData = { _id: res.lastID, ...data };
+            await this.runHooks('afterInsert', table, finalData);
+            return res.lastID;
+        });
     }
     async update(table, data, where) {
-        await this.ensureTable(table, { ...data, ...where });
-        await this._ensureMissingColumns(table, { ...data, ...where });
-        const setString = Object.keys(data).map(k => `reverse{k}
-        const whereString = Object.keys(where).map(k => `reverse{k}
-        const sql = `UPDATE 
-        const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
-        return result.changes;
+        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 { whereClause, values: whereValues } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
+            const res = await this.query(sql, [...Object.values(data).map(v => typeof v === 'object' ? JSON.stringify(v) : v), ...whereValues]);
+            return res.changes;
+        });
     }
     async delete(table, where) {
-        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 => `reverse{k}
-        const sql = `DELETE FROM 
-        const result = await this.query(sql, Object.values(where).map(v => this._serializeValue(v)));
-        return result.changes;
+        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 res = await this.query(sql, values);
+            return res.changes;
+        });
     }
     async select(table, where = null) {
-        await this.ensureTable(table, where || {});
-        if (where && Object.keys(where).length > 0) {
-            await this._ensureMissingColumns(table, where);
-        }
-        let sql = `SELECT * FROM 
-        let params = [];
-        if (where && Object.keys(where).length > 0) {
-            const whereString = Object.keys(where).map(k => `reverse{k}
-            sql += ` WHERE ${whereString}`;
-            params = Object.values(where).map(v => this._serializeValue(v));
-        }
-        const rows = await this.query(sql, params);
-        return rows.map((row) => {
-            const newRow = {};
-            for (const key in row) {
-                newRow[key] = this._deserializeValue(row[key]);
-            }
-            return newRow;
+        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) {
+                    try {
+                        nr[k] = JSON.parse(r[k]);
+                    }
+                    catch {
+                        nr[k] = r[k];
+                    }
+                }
+                return nr;
+            });
         });
     }
-    async set(table, data, where) {
-        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 ex = await this.selectOne(table, where);
+        return ex ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
     }
     async bulkInsert(table, dataArray) {
-        if (!Array.isArray(dataArray) || dataArray.length === 0)
+        if (!dataArray.length)
             return 0;
-        await this.ensureTable(table, dataArray[0]);
-        const allKeys = new Set();
-        dataArray.forEach(obj => Object.keys(obj).forEach(key => allKeys.add(key)));
-        for (const key of allKeys) {
-            const columnsInfo = await this.query(`PRAGMA table_info(
-            if (!columnsInfo.map(col => col.name).includes(key)) {
-                const columnValues = dataArray.map(obj => obj[key]).filter(val => val !== undefined && val !== null);
-                const columnType = columnValues.length > 0 ? this._determineBestColumnType(columnValues) : 'TEXT';
-                await this.query(`ALTER TABLE 
-            }
-        }
-        const keys = Array.from(allKeys);
-        const sql = `INSERT INTO 
-        return new Promise((resolve, reject) => {
-            this.db.serialize(() => {
-                this.db.run("BEGIN TRANSACTION;");
-                let completed = 0;
-                let hasError = false;
-                const stmt = this.db.prepare(sql);
-                for (const item of dataArray) {
-                    if (hasError)
-                        break;
-                    stmt.run(keys.map(k => this._serializeValue(item[k])), (err) => {
-                        if (err && !hasError) {
-                            hasError = true;
-                            this.db.run("ROLLBACK;");
-                            reject(err);
-                        }
-                        completed++;
-                        if (completed === dataArray.length && !hasError) {
-                            this.db.run("COMMIT;", (err) => {
-                                if (err)
-                                    reject(err);
-                                else {
-                                    stmt.finalize();
-                                    resolve(dataArray.length);
-                                }
-                            });
-                        }
-                    });
-                }
-            });
+        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 => `"${f}" = CAST("${f}" AS NUMERIC) + ?`);
+            const { whereClause, values } = this._buildWhereClause(where);
+            const sql = `UPDATE "${table}" SET ${set} ${whereClause}`;
+            const res = await this.query(sql, [...Object.values(incs), ...values]);
+            return res.changes;
         });
     }
-    async increment(table, increments, where = {}) {
-        const incrementClauses = Object.keys(increments).map(field => `reverse{field}
-        const incrementValues = Object.values(increments);
-        const { whereClause, values: whereValues } = this._buildWhereClause(where);
-        const sql = `UPDATE 
-        const result = await this.query(sql, [...incrementValues, ...whereValues]);
-        return result.changes;
+    async decrement(table, decs, where) {
+        const incs = {};
+        for (const k in decs)
+            incs[k] = -decs[k];
+        return this.increment(table, incs, where);
     }
-    async decrement(table, decrements, where = {}) {
-        const decrementClauses = Object.keys(decrements).map(field => `reverse{field}
-        const decrementValues = Object.values(decrements);
-        const { whereClause, values: whereValues } = this._buildWhereClause(where);
-        const sql = `UPDATE 
-        const result = await this.query(sql, [...decrementValues, ...whereValues]);
-        return result.changes;
+    async close() { return new Promise((resolve, reject) => this.db.close(err => err ? reject(err) : resolve())); }
+    _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 = {}) {
-        const conditions = Object.keys(where);
-        if (conditions.length === 0)
+    _buildWhereClause(where) {
+        if (!where)
             return { whereClause: '', values: [] };
-        const whereClause = ' WHERE ' + conditions.map(key => `reverse{key}
-        const values = Object.values(where).map(v => this._serializeValue(v));
-        return { whereClause, values };
-    }
-    async close() {
-        return new Promise((resolve, reject) => {
-            this.db.close((err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
+        const safeWhere = where;
+        const keys = Object.keys(safeWhere);
+        if (!keys.length)
+            return { whereClause: '', values: [] };
+        return {
+            whereClause: 'WHERE ' + keys.map(k => `"${k}" = ?`).join(' AND '),
+            values: keys.map(k => this._serializeValue(safeWhere[k]))
+        };
     }
 }
 exports.SQLiteDatabase = SQLiteDatabase;

package/dist/database/telemetry.d.ts

@@ -0,0 +1,35 @@
+export interface DatabaseMetrics {
+    operation: string;
+    table: string;
+    duration: number;
+    timestamp: number;
+}
+export interface CacheMetrics {
+    hits: number;
+    misses: number;
+    keys: number;
+}
+declare class TelemetrySystem {
+    private dbMetrics;
+    private cacheStats;
+    private maxLogs;
+    recordDb(metric: DatabaseMetrics): void;
+    recordCacheHit(): void;
+    recordCacheMiss(): void;
+    getMetrics(): {
+        database: {
+            totalOperations: number;
+            averageDuration: string;
+            slowestOperations: DatabaseMetrics[];
+            recentLogs: DatabaseMetrics[];
+        };
+        cache: {
+            ratio: string;
+            hits: number;
+            misses: number;
+        };
+    };
+    clear(): void;
+}
+export declare const telemetry: TelemetrySystem;
+export {};

package/dist/database/telemetry.js

@@ -0,0 +1,41 @@
+"use strict";
+// database/telemetry.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.telemetry = void 0;
+class TelemetrySystem {
+    constructor() {
+        this.dbMetrics = [];
+        this.cacheStats = { hits: 0, misses: 0 };
+        this.maxLogs = 1000;
+    }
+    recordDb(metric) {
+        this.dbMetrics.push(metric);
+        if (this.dbMetrics.length > this.maxLogs)
+            this.dbMetrics.shift();
+    }
+    recordCacheHit() { this.cacheStats.hits++; }
+    recordCacheMiss() { this.cacheStats.misses++; }
+    getMetrics() {
+        const totalOps = this.dbMetrics.length;
+        const avgDuration = totalOps > 0
+            ? this.dbMetrics.reduce((s, m) => s + m.duration, 0) / totalOps
+            : 0;
+        return {
+            database: {
+                totalOperations: totalOps,
+                averageDuration: avgDuration.toFixed(2) + 'ms',
+                slowestOperations: [...this.dbMetrics].sort((a, b) => b.duration - a.duration).slice(0, 5),
+                recentLogs: this.dbMetrics.slice(-10)
+            },
+            cache: {
+                ...this.cacheStats,
+                ratio: (this.cacheStats.hits / (this.cacheStats.hits + this.cacheStats.misses || 1) * 100).toFixed(2) + '%'
+            }
+        };
+    }
+    clear() {
+        this.dbMetrics = [];
+        this.cacheStats = { hits: 0, misses: 0 };
+    }
+}
+exports.telemetry = new TelemetrySystem();

package/dist/database/toon.d.ts

@@ -0,0 +1,32 @@
+import { IDatabase } from './IDatabase';
+import { ToonConfig } from './types';
+export declare class ToonDatabase extends IDatabase {
+    private filePath;
+    private db;
+    private isDirty;
+    private isWriting;
+    private writeQueue;
+    private saveDebounceTimeout;
+    private saveInterval;
+    private initPromise;
+    constructor(config: ToonConfig);
+    private _execute;
+    private _load;
+    private _queueRequest;
+    private _processQueue;
+    private _scheduleSave;
+    private _saveNow;
+    private flushSync;
+    ensureTable(table: string): Promise<void>;
+    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[]>;
+    selectOne<T = any>(table: string, where?: Record<string, any> | null): Promise<T | null>;
+    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, 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 ToonDatabase;