@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/database/json.js

@@ -0,0 +1,210 @@
+"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.filePath)
+            throw new Error('Yapılandırma içinde "filePath" belirtilmelidir.');
+        this.filePath = config.filePath;
+        this.saveInterval = 500;
+        process.on('exit', () => this.flushSync());
+        this.initPromise = this._load();
+    }
+    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("Veritabanı dosyasına yazılırken hata:", error);
+        }
+    }
+    flushSync() {
+        if (this.isDirty) {
+            try {
+                (0, fs_1.writeFileSync)(this.filePath, JSON.stringify(this.db, null, 2));
+                this.isDirty = false;
+            }
+            catch (error) { }
+        }
+    }
+    _matches(row, where) {
+        return Object.keys(where).every(key => row[key] === where[key]);
+    }
+    async ensureTable(table) {
+        await this.initPromise;
+        if (!this.db[table]) {
+            return this._queueRequest(() => {
+                this.db[table] = [];
+            });
+        }
+    }
+    async insert(table, data) {
+        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);
+            return newId;
+        });
+    }
+    async update(table, data, where) {
+        await this.ensureTable(table);
+        return this._queueRequest(() => {
+            let affectedRows = 0;
+            this.db[table].forEach(row => {
+                if (this._matches(row, where)) {
+                    Object.assign(row, data);
+                    affectedRows++;
+                }
+            });
+            return affectedRows;
+        });
+    }
+    async delete(table, where) {
+        await this.ensureTable(table);
+        return this._queueRequest(() => {
+            const initialLength = this.db[table].length;
+            this.db[table] = this.db[table].filter(row => !this._matches(row, where));
+            return initialLength - this.db[table].length;
+        });
+    }
+    async select(table, where = null) {
+        await this.initPromise;
+        const tableData = this.db[table] || [];
+        let results = tableData;
+        if (where && Object.keys(where).length > 0) {
+            results = results.filter(row => this._matches(row, where));
+        }
+        return JSON.parse(JSON.stringify(results));
+    }
+    async set(table, data, where) {
+        const existing = await this.select(table, where);
+        if (existing.length === 0) {
+            return this.insert(table, { ...where, ...data });
+        }
+        else {
+            return 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) {
+        if (!Array.isArray(dataArray) || dataArray.length === 0)
+            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, increments, where = {}) {
+        await this.ensureTable(table);
+        return this._queueRequest(() => {
+            let affectedCount = 0;
+            this.db[table].forEach(row => {
+                if (this._matches(row, where)) {
+                    for (const [field, value] of Object.entries(increments)) {
+                        row[field] = (Number(row[field]) || 0) + value;
+                    }
+                    affectedCount++;
+                }
+            });
+            return affectedCount;
+        });
+    }
+    async decrement(table, decrements, where = {}) {
+        await this.ensureTable(table);
+        return this._queueRequest(() => {
+            let affectedCount = 0;
+            this.db[table].forEach(row => {
+                if (this._matches(row, where)) {
+                    for (const [field, value] of Object.entries(decrements)) {
+                        row[field] = (Number(row[field]) || 0) - value;
+                    }
+                    affectedCount++;
+                }
+            });
+            return affectedCount;
+        });
+    }
+    async close() {
+        await this._saveNow();
+    }
+}
+exports.JsonDatabase = JsonDatabase;
+exports.default = JsonDatabase;

package/dist/database/migration.d.ts

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,97 @@
+"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

@@ -0,0 +1,24 @@
+import { IDatabase } from './IDatabase';
+export declare class MongoDBDatabase extends IDatabase {
+    private config;
+    private client;
+    private db;
+    private _queue;
+    private _connected;
+    private _connectionPromise;
+    constructor(config: any);
+    private _queueRequest;
+    private _processQueue;
+    ensureCollection(collection: string): Promise<void>;
+    insert(collection: string, data: Record<string, any>): Promise<any>;
+    bulkInsert(collection: string, dataArray: Record<string, any>[]): Promise<number>;
+    update(collection: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
+    delete(collection: string, where: Record<string, any>): Promise<number>;
+    select<T = any>(collection: string, where?: Record<string, any>): Promise<T[]>;
+    selectOne<T = any>(collection: string, where?: Record<string, any>): Promise<T | null>;
+    set(collection: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
+    increment(collection: string, increments: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    decrement(collection: string, decrements: Record<string, number>, where?: Record<string, any>): Promise<number>;
+    close(): Promise<void>;
+}
+export default MongoDBDatabase;

package/dist/database/mongodb.js

@@ -0,0 +1,153 @@
+"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._queue = [];
+        this._connected = false;
+        this.config = config;
+        this.client = new mongodb_1.MongoClient(config.url || config.uri);
+        this._connectionPromise = new Promise(async (resolve, reject) => {
+            try {
+                await this.client.connect();
+                this.db = this.client.db(config.database || config.dbName);
+                this._connected = true;
+                resolve(this.db);
+                this._processQueue();
+            }
+            catch (error) {
+                console.error("MongoDB connection error:", error);
+                reject(error);
+            }
+        });
+    }
+    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 ensureCollection(collection) {
+        return this._queueRequest(async () => {
+            const db = await this._connectionPromise;
+            const collections = await db.listCollections({ name: collection }).toArray();
+            if (collections.length === 0) {
+                await db.createCollection(collection);
+            }
+        });
+    }
+    async insert(collection, data) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).insertOne(data);
+            return result.insertedId;
+        });
+    }
+    async bulkInsert(collection, dataArray) {
+        return this._queueRequest(async () => {
+            if (!Array.isArray(dataArray) || dataArray.length === 0)
+                return 0;
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).insertMany(dataArray);
+            return result.insertedCount;
+        });
+    }
+    async update(collection, data, where) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).updateMany(where, { $set: data });
+            return Number(result.modifiedCount);
+        });
+    }
+    async delete(collection, where) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).deleteMany(where);
+            return result.deletedCount;
+        });
+    }
+    async select(collection, where = {}) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const results = await db.collection(collection).find(where).toArray();
+            return results;
+        });
+    }
+    async selectOne(collection, where = {}) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).findOne(where);
+            return result;
+        });
+    }
+    async set(collection, data, where) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const existing = await db.collection(collection).findOne(where);
+            if (!existing) {
+                const result = await db.collection(collection).insertOne({ ...where, ...data });
+                return result.insertedId;
+            }
+            else {
+                const result = await db.collection(collection).updateOne(where, { $set: data });
+                return result.modifiedCount;
+            }
+        });
+    }
+    async increment(collection, increments, where = {}) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const result = await db.collection(collection).updateMany(where, { $inc: increments });
+            return Number(result.modifiedCount);
+        });
+    }
+    async decrement(collection, decrements, where = {}) {
+        return this._queueRequest(async () => {
+            await this.ensureCollection(collection);
+            const db = await this._connectionPromise;
+            const negativeIncrements = {};
+            for (const [key, value] of Object.entries(decrements)) {
+                negativeIncrements[key] = -value;
+            }
+            const result = await db.collection(collection).updateMany(where, { $inc: negativeIncrements });
+            return Number(result.modifiedCount);
+        });
+    }
+    async close() {
+        await this.client.close();
+    }
+}
+exports.MongoDBDatabase = MongoDBDatabase;
+exports.default = MongoDBDatabase;

package/dist/database/mysql.d.ts

@@ -0,0 +1,31 @@
+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 _getColumnType;
+    private _getBestColumnType;
+    private _ensureMissingColumns;
+    private _queueRequest;
+    private _processQueue;
+    query(sql: string, params?: any[]): Promise<any>;
+    ensureTable(table: string, data?: Record<string, 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[]>;
+    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>;
+    close(): Promise<void>;
+    private _serializeValue;
+    private _deserializeValue;
+    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;
+}
+export default MySQLDatabase;