@onurege3467/zerohelper 10.2.6 → 11.0.0

package/dist/database/json.js

@@ -1,208 +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.JsonDatabase = void 0;
-const IDatabase_1 = require("./IDatabase");
-const promises_1 = __importDefault(require("fs/promises"));
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-class JsonDatabase extends IDatabase_1.IDatabase {
-    constructor(config) {
-        super();
-        this.db = {};
-        this.isDirty = false;
-        this.isWriting = false;
-        this.writeQueue = [];
-        this.saveDebounceTimeout = null;
-        if (!config || !config.path)
-            throw new Error('JsonDB: "path" gereklidir.');
-        this.filePath = config.path;
-        this.saveInterval = config.saveInterval || 500;
-        process.on('exit', () => this.flushSync());
-        this.initPromise = this._load();
-    }
-    async _execute(op, table, fn) {
-        const start = Date.now();
-        const res = await fn();
-        this.recordMetric(op, table, Date.now() - start);
-        return res;
-    }
-    async _load() {
-        try {
-            const dir = path_1.default.dirname(this.filePath);
-            await promises_1.default.mkdir(dir, { recursive: true });
-            const fileContent = await promises_1.default.readFile(this.filePath, 'utf-8');
-            this.db = JSON.parse(fileContent);
-        }
-        catch (error) {
-            if (error.code === 'ENOENT') {
-                this.db = {};
-                await this._saveNow();
-            }
-            else {
-                this.db = {};
-            }
-        }
-    }
-    _queueRequest(operation) {
-        return new Promise((resolve, reject) => {
-            this.writeQueue.push({ operation, resolve, reject });
-            this._processQueue();
-        });
-    }
-    async _processQueue() {
-        if (this.isWriting || this.writeQueue.length === 0)
-            return;
-        this.isWriting = true;
-        const item = this.writeQueue.shift();
-        if (item) {
-            try {
-                const result = item.operation();
-                this.isDirty = true;
-                this._scheduleSave();
-                item.resolve(result);
-            }
-            catch (error) {
-                item.reject(error);
-            }
-            finally {
-                this.isWriting = false;
-                this._processQueue();
-            }
-        }
-    }
-    _scheduleSave() {
-        if (this.saveDebounceTimeout)
-            clearTimeout(this.saveDebounceTimeout);
-        this.saveDebounceTimeout = setTimeout(() => this._saveNow(), this.saveInterval);
-    }
-    async _saveNow() {
-        if (!this.isDirty)
-            return;
-        if (this.saveDebounceTimeout)
-            clearTimeout(this.saveDebounceTimeout);
-        this.saveDebounceTimeout = null;
-        try {
-            await promises_1.default.writeFile(this.filePath, JSON.stringify(this.db, null, 2));
-            this.isDirty = false;
-        }
-        catch (error) {
-            console.error("JsonDB save error:", error);
-        }
-    }
-    flushSync() {
-        if (this.isDirty) {
-            try {
-                (0, fs_1.writeFileSync)(this.filePath, JSON.stringify(this.db, null, 2));
-                this.isDirty = false;
-            }
-            catch (error) { }
-        }
-    }
-    async ensureTable(table) {
-        await this.initPromise;
-        if (!this.db[table]) {
-            return this._queueRequest(() => { this.db[table] = []; });
-        }
-    }
-    async insert(table, data) {
-        await this.runHooks('beforeInsert', table, data);
-        return this._execute('insert', table, async () => {
-            await this.ensureTable(table);
-            return this._queueRequest(() => {
-                const maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
-                const newId = maxId + 1;
-                const newRow = { _id: newId, ...data };
-                this.db[table].push(newRow);
-                this.runHooks('afterInsert', table, newRow);
-                return newId;
-            });
-        });
-    }
-    async update(table, data, where) {
-        await this.runHooks('beforeUpdate', table, { data, where });
-        return this._execute('update', table, async () => {
-            await this.ensureTable(table);
-            return this._queueRequest(() => {
-                let affected = 0;
-                this.db[table].forEach(row => {
-                    if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
-                        Object.assign(row, data);
-                        affected++;
-                    }
-                });
-                this.runHooks('afterUpdate', table, { affected });
-                return affected;
-            });
-        });
-    }
-    async delete(table, where) {
-        await this.runHooks('beforeDelete', table, where);
-        return this._execute('delete', table, async () => {
-            await this.ensureTable(table);
-            return this._queueRequest(() => {
-                const initial = this.db[table].length;
-                this.db[table] = this.db[table].filter(row => !Object.keys(where).every(k => String(row[k]) === String(where[k])));
-                const affected = initial - this.db[table].length;
-                this.runHooks('afterDelete', table, { affected });
-                return affected;
-            });
-        });
-    }
-    async select(table, where = null) {
-        return this._execute('select', table, async () => {
-            await this.initPromise;
-            const results = where && Object.keys(where).length > 0
-                ? (this.db[table] || []).filter(row => Object.keys(where).every(k => String(row[k]) === String(where[k])))
-                : (this.db[table] || []);
-            return JSON.parse(JSON.stringify(results));
-        });
-    }
-    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) {
-        return this._execute('bulkInsert', table, async () => {
-            if (!dataArray.length)
-                return 0;
-            await this.ensureTable(table);
-            return this._queueRequest(() => {
-                let maxId = this.db[table].reduce((max, row) => (row._id > max ? row._id : max), 0);
-                dataArray.forEach(data => { maxId++; this.db[table].push({ _id: maxId, ...data }); });
-                return dataArray.length;
-            });
-        });
-    }
-    async increment(table, incs, where = {}) {
-        return this._execute('increment', table, async () => {
-            await this.ensureTable(table);
-            return this._queueRequest(() => {
-                let affected = 0;
-                this.db[table].forEach(row => {
-                    if (Object.keys(where).every(k => String(row[k]) === String(where[k]))) {
-                        for (const [f, v] of Object.entries(incs))
-                            row[f] = (Number(row[f]) || 0) + v;
-                        affected++;
-                    }
-                });
-                return affected;
-            });
-        });
-    }
-    async decrement(table, decs, where = {}) {
-        const incs = {};
-        for (const k in decs)
-            incs[k] = -decs[k];
-        return this.increment(table, incs, where);
-    }
-    async close() { await this._saveNow(); }
-}
-exports.JsonDatabase = JsonDatabase;
-exports.default = JsonDatabase;

package/dist/database/migration.d.ts

@@ -1,21 +0,0 @@
-import { IDatabase } from './IDatabase';
-export interface MigrationFile {
-    name: string;
-    path: string;
-}
-export declare class MigrationManager {
-    private db;
-    private migrationsDir;
-    private migrationsTable;
-    constructor(database: IDatabase, options?: any);
-    private ensureMigrationsDir;
-    ensureMigrationsTable(): Promise<void>;
-    createMigration(name: string, description?: string): string;
-    getMigrationFiles(): MigrationFile[];
-    getExecutedMigrations(): Promise<string[]>;
-    getPendingMigrations(): Promise<MigrationFile[]>;
-    runMigration(migrationFile: MigrationFile, direction?: 'up' | 'down'): Promise<boolean>;
-    migrate(): Promise<void>;
-    rollback(steps?: number): Promise<void>;
-}
-export default MigrationManager;

package/dist/database/migration.js

@@ -1,97 +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.MigrationManager = void 0;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-class MigrationManager {
-    constructor(database, options = {}) {
-        this.db = database;
-        this.migrationsDir = options.migrationsDir || './migrations';
-        this.migrationsTable = options.migrationsTable || 'migrations';
-        this.ensureMigrationsDir();
-    }
-    ensureMigrationsDir() {
-        if (!fs_1.default.existsSync(this.migrationsDir)) {
-            fs_1.default.mkdirSync(this.migrationsDir, { recursive: true });
-        }
-    }
-    async ensureMigrationsTable() {
-        try {
-            await this.db.selectOne(this.migrationsTable, {});
-        }
-        catch (error) {
-            if (this.db.constructor.name === 'MySQLDatabase') {
-                await this.db.query(`CREATE TABLE IF NOT EXISTS ${this.migrationsTable} (id INTEGER PRIMARY KEY AUTO_INCREMENT, name VARCHAR(255) NOT NULL UNIQUE, executed_at DATETIME DEFAULT CURRENT_TIMESTAMP)`);
-            }
-            else if (this.db.constructor.name === 'PostgreSQLDatabase') {
-                await this.db.query(`CREATE TABLE IF NOT EXISTS ${this.migrationsTable} (id SERIAL PRIMARY KEY, name VARCHAR(255) NOT NULL UNIQUE, executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP)`);
-            }
-            else {
-                await this.db.query(`CREATE TABLE IF NOT EXISTS ${this.migrationsTable} (id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR(255) NOT NULL UNIQUE, executed_at DATETIME DEFAULT CURRENT_TIMESTAMP)`);
-            }
-        }
-    }
-    createMigration(name, description = '') {
-        const timestamp = Date.now();
-        const filename = `${timestamp}_${name}.ts`;
-        const filePath = path_1.default.join(this.migrationsDir, filename);
-        const template = `import { IDatabase } from "../database/IDatabase";\n\nexport const up = async (db: IDatabase) => {\n  // Migration logic here\n};\n\nexport const down = async (db: IDatabase) => {\n  // Rollback logic here\n};\n`;
-        fs_1.default.writeFileSync(filePath, template);
-        return filename;
-    }
-    getMigrationFiles() {
-        return fs_1.default.readdirSync(this.migrationsDir)
-            .filter(file => file.endsWith('.ts') || file.endsWith('.js'))
-            .sort()
-            .map(file => ({ name: file, path: path_1.default.join(this.migrationsDir, file) }));
-    }
-    async getExecutedMigrations() {
-        await this.ensureMigrationsTable();
-        try {
-            const executed = await this.db.select(this.migrationsTable, {});
-            return executed.map((row) => row.name);
-        }
-        catch {
-            return [];
-        }
-    }
-    async getPendingMigrations() {
-        const all = this.getMigrationFiles();
-        const executed = await this.getExecutedMigrations();
-        return all.filter(m => !executed.includes(m.name));
-    }
-    async runMigration(migrationFile, direction = 'up') {
-        try {
-            const migration = require(path_1.default.resolve(migrationFile.path));
-            if (typeof migration[direction] !== 'function')
-                throw new Error(`Migration ${migrationFile.name} has no ${direction} method`);
-            await migration[direction](this.db);
-            if (direction === 'up')
-                await this.db.insert(this.migrationsTable, { name: migrationFile.name });
-            else
-                await this.db.delete(this.migrationsTable, { name: migrationFile.name });
-            return true;
-        }
-        catch (error) {
-            console.error(`Migration ${migrationFile.name} error:`, error);
-            throw error;
-        }
-    }
-    async migrate() {
-        const pending = await this.getPendingMigrations();
-        for (const m of pending)
-            await this.runMigration(m, 'up');
-    }
-    async rollback(steps = 1) {
-        const executed = await this.getExecutedMigrations();
-        const all = this.getMigrationFiles();
-        const toRollback = executed.slice(-steps).reverse().map(name => all.find(m => m.name === name)).filter((m) => !!m);
-        for (const m of toRollback)
-            await this.runMigration(m, 'down');
-    }
-}
-exports.MigrationManager = MigrationManager;
-exports.default = MigrationManager;

package/dist/database/mongodb.d.ts

@@ -1,26 +0,0 @@
-import { IDatabase } from './IDatabase';
-import { MongoDBConfig } from './types';
-export declare class MongoDBDatabase extends IDatabase {
-    private client;
-    private db;
-    private _isConnected;
-    private _queue;
-    constructor(config: MongoDBConfig);
-    private _connect;
-    private _flushQueue;
-    private _flushQueueWithError;
-    private _execute;
-    insert(collection: string, data: any): Promise<string>;
-    update(collection: string, data: any, where: any): Promise<number>;
-    delete(collection: string, where: any): Promise<number>;
-    select<T = any>(collection: string, where?: any): Promise<T[]>;
-    selectOne<T = any>(collection: string, where?: any): Promise<T | null>;
-    set(collection: string, data: any, where: any): Promise<any>;
-    bulkInsert(collection: string, dataArray: any[]): Promise<number>;
-    increment(collection: string, incs: Record<string, number>, where?: any): Promise<number>;
-    decrement(collection: string, decs: Record<string, number>, where?: any): Promise<number>;
-    close(): Promise<void>;
-    private _formatQuery;
-    private _serialize;
-}
-export default MongoDBDatabase;

package/dist/database/mongodb.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoDBDatabase = void 0;
-const IDatabase_1 = require("./IDatabase");
-const mongodb_1 = require("mongodb");
-class MongoDBDatabase extends IDatabase_1.IDatabase {
-    constructor(config) {
-        super();
-        this.db = null;
-        this._isConnected = false;
-        this._queue = [];
-        const uri = config.url || (config.uri ?? `mongodb://${config.host || 'localhost'}:${config.port || 27017}`);
-        this.client = new mongodb_1.MongoClient(uri, {
-            serverSelectionTimeoutMS: 5000, // Fail fast if no server
-            connectTimeoutMS: 5000
-        });
-        this._connect(config.database || 'test');
-    }
-    async _connect(dbName) {
-        try {
-            await this.client.connect();
-            this.db = this.client.db(dbName);
-            this._isConnected = true;
-            this._flushQueue();
-        }
-        catch (error) {
-            this._flushQueueWithError(error);
-            // Opsiyonel: Yeniden bağlanma mantığı buraya eklenebilir,
-            // ama testler için fail-fast daha iyidir.
-        }
-    }
-    _flushQueue() {
-        while (this._queue.length > 0) {
-            const item = this._queue.shift();
-            if (item) {
-                item.operation().then(item.resolve).catch(item.reject);
-            }
-        }
-    }
-    _flushQueueWithError(error) {
-        while (this._queue.length > 0) {
-            const item = this._queue.shift();
-            if (item)
-                item.reject(error);
-        }
-    }
-    async _execute(fn) {
-        if (this._isConnected) {
-            return fn();
-        }
-        return new Promise((resolve, reject) => {
-            this._queue.push({ operation: fn, resolve, reject });
-        });
-    }
-    // --- Implementations ---
-    async insert(collection, data) {
-        await this.runHooks('beforeInsert', collection, data);
-        return this._execute(async () => {
-            const res = await this.db.collection(collection).insertOne(data);
-            const newId = res.insertedId.toString();
-            const finalData = { _id: newId, ...data };
-            await this.runHooks('afterInsert', collection, finalData);
-            return newId;
-        });
-    }
-    async update(collection, data, where) {
-        await this.runHooks('beforeUpdate', collection, { data, where });
-        const formattedWhere = this._formatQuery(where);
-        return this._execute(async () => {
-            const res = await this.db.collection(collection).updateMany(formattedWhere, { $set: data });
-            return res.modifiedCount;
-        });
-    }
-    async delete(collection, where) {
-        await this.runHooks('beforeDelete', collection, where);
-        const formattedWhere = this._formatQuery(where);
-        return this._execute(async () => {
-            const res = await this.db.collection(collection).deleteMany(formattedWhere);
-            return res.deletedCount;
-        });
-    }
-    async select(collection, where = {}) {
-        const formattedWhere = this._formatQuery(where);
-        return this._execute(async () => {
-            const docs = await this.db.collection(collection).find(formattedWhere).toArray();
-            return docs.map(doc => this._serialize(doc));
-        });
-    }
-    async selectOne(collection, where = {}) {
-        const formattedWhere = this._formatQuery(where);
-        return this._execute(async () => {
-            const doc = await this.db.collection(collection).findOne(formattedWhere);
-            return doc ? this._serialize(doc) : null;
-        });
-    }
-    async set(collection, data, where) {
-        const ex = await this.selectOne(collection, where);
-        return ex ? this.update(collection, data, where) : this.insert(collection, { ...where, ...data });
-    }
-    async bulkInsert(collection, dataArray) {
-        if (!dataArray.length)
-            return 0;
-        return this._execute(async () => {
-            const res = await this.db.collection(collection).insertMany(dataArray);
-            return res.insertedCount;
-        });
-    }
-    async increment(collection, incs, where = {}) {
-        const formattedWhere = this._formatQuery(where);
-        return this._execute(async () => {
-            const res = await this.db.collection(collection).updateMany(formattedWhere, { $inc: incs });
-            return res.modifiedCount;
-        });
-    }
-    async decrement(collection, decs, where = {}) {
-        const incs = {};
-        for (const k in decs)
-            incs[k] = -decs[k];
-        return this.increment(collection, incs, where);
-    }
-    async close() {
-        if (this.client)
-            await this.client.close();
-        this._isConnected = false;
-    }
-    // Helper: _id handling and query formatting
-    _formatQuery(where) {
-        if (!where)
-            return {};
-        const query = { ...where };
-        if (query._id && typeof query._id === 'string' && mongodb_1.ObjectId.isValid(query._id)) {
-            query._id = new mongodb_1.ObjectId(query._id);
-        }
-        return query;
-    }
-    _serialize(doc) {
-        if (!doc)
-            return doc;
-        const { _id, ...rest } = doc;
-        // _id'yi string olarak döndür, ZeroHelper standardı
-        return { _id: _id.toString(), ...rest };
-    }
-}
-exports.MongoDBDatabase = MongoDBDatabase;
-exports.default = MongoDBDatabase;

package/dist/database/mysql.d.ts

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