@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/database/IDatabase.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Tüm veritabanı adaptörlerinin uyması gereken ortak arayüzü tanımlar.
+ */
+export declare abstract class IDatabase {
+    /**
+     * Belirtilen koşullara göre birden çok kayıt seçer.
+     * @param table - Verinin seçileceği tablo veya koleksiyonun adı.
+     * @param where - (Opsiyonel) Kayıtları filtrelemek için kullanılacak koşul nesnesi.
+     * @returns Koşullara uyan kayıtların bir dizisini içeren bir Promise.
+     */
+    abstract select<T = any>(table: string, where?: Record<string, any> | null): Promise<T[]>;
+    /**
+     * Belirtilen koşullara göre tek bir kayıt seçer.
+     * @param table - Verinin seçileceği tablo veya koleksiyonun adı.
+     * @param where - (Opsiyonel) Kaydı filtrelemek için kullanılacak koşul nesnesi.
+     * @returns Koşula uyan ilk kaydı veya bulunamazsa `null` içeren bir Promise.
+     */
+    abstract selectOne<T = any>(table: string, where?: Record<string, any> | null): Promise<T | null>;
+    /**
+     * Yeni bir kayıt ekler.
+     * @param table - Verinin ekleneceği tablo veya koleksiyonun adı.
+     * @param data - Eklenecek veriyi içeren nesne.
+     * @returns Eklenen yeni kaydın ID'sini içeren bir Promise.
+     */
+    abstract insert(table: string, data: Record<string, any>): Promise<number | string | any>;
+    /**
+     * Belirtilen koşullara uyan kayıtları günceller.
+     * @param table - Verinin güncelleneceği tablo veya koleksiyonun adı.
+     * @param data - Güncellenecek yeni verileri içeren nesne.
+     * @param where - Hangi kayıtların güncelleneceğini belirleyen koşul nesnesi.
+     * @returns Etkilenen (güncellenen) kayıt sayısını içeren bir Promise.
+     */
+    abstract update(table: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
+    /**
+     * Bir kaydı günceller veya yoksa yeni bir kayıt olarak ekler (Upsert).
+     * @param table - İşlem yapılacak tablo veya koleksiyonun adı.
+     * @param data - Ayarlanacak veya güncellenecek veriyi içeren nesne.
+     * @param where - Kaydın varlığını kontrol etmek ve güncellemek için kullanılacak koşul nesnesi.
+     * @returns Ekleme durumunda yeni ID'yi, güncelleme durumunda etkilenen satır sayısını içeren bir Promise.
+     */
+    abstract set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
+    /**
+     * Belirtilen koşullara uyan kayıtları siler.
+     * @param table - Verinin silineceği tablo veya koleksiyonun adı.
+     * @param where - Hangi kayıtların silineceğini belirleyen koşul nesnesi.
+     * @returns Silinen kayıt sayısını içeren bir Promise.
+     */
+    abstract delete(table: string, where: Record<string, any>): Promise<number>;
+    /**
+     * Birden çok kaydı toplu olarak ekler.
+     * @param table - Verilerin ekleneceği tablo veya koleksiyonun adı.
+     * @param dataArray - Eklenecek kayıtları içeren bir dizi.
+     * @returns Eklenen kayıt sayısını içeren bir Promise.
+     */
+    abstract bulkInsert(table: string, dataArray: Record<string, any>[]): Promise<number>;
+    /**
+     * Numerik alanları artırır (increment).
+     * @param table - Verinin güncelleneceği tablo veya koleksiyonun adı.
+     * @param increments - Artırılacak alanlar ve miktarları (örn: { views: 1, likes: 2 }).
+     * @param where - Hangi kayıtların güncelleneceğini belirleyen koşul nesnesi.
+     * @returns Etkilenen kayıt sayısını içeren bir Promise.
+     */
+    abstract increment(table: string, increments: Record<string, number>, where: Record<string, any>): Promise<number>;
+    /**
+     * Numerik alanları azaltır (decrement).
+     * @param table - Verinin güncelleneceği tablo veya koleksiyonun adı.
+     * @param decrements - Azaltılacak alanlar ve miktarları (örn: { stock: 1, count: 5 }).
+     * @param where - Hangi kayıtların güncelleneceğini belirleyen koşul nesnesi.
+     * @returns Etkilenen kayıt sayısını içeren bir Promise.
+     */
+    abstract decrement(table: string, decrements: Record<string, number>, where: Record<string, any>): Promise<number>;
+    /**
+     * Veritabanı bağlantısını güvenli bir şekilde sonlandırır.
+     */
+    abstract close(): Promise<void>;
+}
+export default IDatabase;

package/dist/database/IDatabase.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IDatabase = void 0;
+/**
+ * Tüm veritabanı adaptörlerinin uyması gereken ortak arayüzü tanımlar.
+ */
+class IDatabase {
+}
+exports.IDatabase = IDatabase;
+exports.default = IDatabase;

package/dist/database/cacheWrapper.d.ts

@@ -0,0 +1,31 @@
+import { IDatabase } from './IDatabase';
+export declare class CacheWrapper extends IDatabase {
+    db: IDatabase;
+    private cacheType;
+    private tableCaches;
+    private redisClient;
+    private redisAvailable;
+    private ttl;
+    private keyPrefix;
+    private cache;
+    constructor(databaseInstance: IDatabase, options?: any);
+    private _initMemoryCache;
+    private _initRedisCache;
+    private _getCache;
+    private _generateKey;
+    private _getCacheValue;
+    private _setCacheValue;
+    private _clearCache;
+    private _updateCacheByWhere;
+    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>;
+    insert(table: string, data: Record<string, any>): Promise<any>;
+    update(table: string, data: Record<string, any>, where: Record<string, any>): Promise<number>;
+    set(table: string, data: Record<string, any>, where: Record<string, any>): Promise<any>;
+    delete(table: string, where: Record<string, any>): Promise<number>;
+    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 CacheWrapper;

package/dist/database/cacheWrapper.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheWrapper = void 0;
+const IDatabase_1 = require("./IDatabase");
+const lru_cache_1 = require("lru-cache");
+const redis_1 = require("redis");
+class CacheWrapper extends IDatabase_1.IDatabase {
+    constructor(databaseInstance, options = {}) {
+        super();
+        this.tableCaches = {};
+        this.redisClient = null;
+        this.redisAvailable = false;
+        this.ttl = 300;
+        this.keyPrefix = 'db_cache:';
+        this.cache = null;
+        this.db = databaseInstance;
+        this.cacheType = options.type || 'memory';
+        if (this.cacheType === 'redis') {
+            this._initRedisCache(options);
+        }
+        else {
+            this._initMemoryCache(options);
+        }
+    }
+    _initMemoryCache(options) {
+        this.cache = new lru_cache_1.LRUCache({
+            max: options.max || 500,
+            ttl: options.ttl || 1000 * 60 * 5,
+        });
+        this.redisAvailable = false;
+    }
+    async _initRedisCache(options) {
+        const redisConfig = {
+            socket: {
+                host: options.host || '127.0.0.1',
+                port: options.port || 6379,
+                connectTimeout: options.connectTimeout || 5000,
+            },
+            password: options.password,
+            database: options.db || 0,
+        };
+        this.redisClient = (0, redis_1.createClient)(redisConfig);
+        this.ttl = (options.ttl || 300000) / 1000;
+        this.keyPrefix = options.keyPrefix || 'db_cache:';
+        this.redisClient.on('error', (err) => {
+            this.redisAvailable = false;
+        });
+        this.redisClient.on('ready', () => {
+            this.redisAvailable = true;
+        });
+        try {
+            await this.redisClient.connect();
+            this.redisAvailable = true;
+        }
+        catch (error) {
+            this._initMemoryCache(options);
+        }
+    }
+    _getCache(table) {
+        if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient)
+            return this.redisClient;
+        if (!this.tableCaches[table]) {
+            this.tableCaches[table] = new lru_cache_1.LRUCache({
+                max: this.cache?.max || 500,
+                ttl: this.cache?.ttl || 300000,
+            });
+        }
+        return this.tableCaches[table];
+    }
+    _generateKey(table, where) {
+        const sortedWhere = where ? Object.keys(where).sort().reduce((acc, key) => {
+            acc[key] = where[key];
+            return acc;
+        }, {}) : {};
+        const key = `${table}:${JSON.stringify(sortedWhere)}`;
+        return this.cacheType === 'redis' ? `${this.keyPrefix}${key}` : key;
+    }
+    async _getCacheValue(cache, key, table) {
+        if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+            try {
+                const value = await cache.get(key);
+                return value ? JSON.parse(value) : null;
+            }
+            catch {
+                this.redisAvailable = false;
+                return this._getCache(table).get(key);
+            }
+        }
+        return cache.get(key);
+    }
+    async _setCacheValue(cache, key, value, table) {
+        if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+            try {
+                await cache.setEx(key, Math.floor(this.ttl), JSON.stringify(value));
+            }
+            catch {
+                this.redisAvailable = false;
+                this._getCache(table).set(key, value);
+            }
+        }
+        else {
+            cache.set(key, value);
+        }
+    }
+    async _clearCache(table) {
+        if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+            try {
+                const keys = await this.redisClient.keys(`${this.keyPrefix}${table}:*`);
+                if (keys.length)
+                    await this.redisClient.del(keys);
+            }
+            catch {
+                this.redisAvailable = false;
+            }
+        }
+        if (this.tableCaches[table])
+            this.tableCaches[table].clear();
+    }
+    async _updateCacheByWhere(table, where, newData = null) {
+        if (!where || Object.keys(where).length === 0) {
+            await this._clearCache(table);
+            return;
+        }
+        if (this.cacheType === 'redis' && this.redisAvailable && this.redisClient) {
+            try {
+                const keys = await this.redisClient.keys(`${this.keyPrefix}${table}:*`);
+                for (const fullKey of keys) {
+                    const cacheData = await this.redisClient.get(fullKey);
+                    if (cacheData) {
+                        const parsedData = JSON.parse(cacheData);
+                        if (Object.entries(where).every(([k, v]) => parsedData[k] === v)) {
+                            if (newData)
+                                await this.redisClient.setEx(fullKey, Math.floor(this.ttl), JSON.stringify(newData));
+                            else
+                                await this.redisClient.del(fullKey);
+                        }
+                    }
+                }
+            }
+            catch {
+                await this._clearCache(table);
+            }
+        }
+        const cache = this._getCache(table);
+        if (cache instanceof lru_cache_1.LRUCache) {
+            const keysToDelete = [];
+            cache.forEach((value, key) => {
+                if (Object.entries(where).every(([k, v]) => value[k] === v)) {
+                    if (newData)
+                        cache.set(key, newData);
+                    else
+                        keysToDelete.push(key);
+                }
+            });
+            keysToDelete.forEach(k => cache.delete(k));
+        }
+    }
+    async select(table, where = null) {
+        const cache = this._getCache(table);
+        const key = this._generateKey(table, where);
+        let data = await this._getCacheValue(cache, key, table);
+        if (data !== null && data !== undefined)
+            return data;
+        data = await this.db.select(table, where);
+        if (data !== null && data !== undefined)
+            await this._setCacheValue(cache, key, data, table);
+        return data;
+    }
+    async selectOne(table, where = null) {
+        const cache = this._getCache(table);
+        const key = this._generateKey(table + '_one', where);
+        let data = await this._getCacheValue(cache, key, table);
+        if (data !== null && data !== undefined)
+            return data;
+        data = await this.db.selectOne(table, where);
+        if (data !== null && data !== undefined)
+            await this._setCacheValue(cache, key, data, table);
+        return data;
+    }
+    async insert(table, data) {
+        const result = await this.db.insert(table, data);
+        await this._clearCache(table);
+        return result;
+    }
+    async update(table, data, where) {
+        const result = await this.db.update(table, data, where);
+        if (result > 0)
+            await this._updateCacheByWhere(table, where, null);
+        return result;
+    }
+    async set(table, data, where) {
+        const result = await this.db.set(table, data, where);
+        await this._updateCacheByWhere(table, where, null);
+        return result;
+    }
+    async delete(table, where) {
+        const result = await this.db.delete(table, where);
+        if (result > 0)
+            await this._updateCacheByWhere(table, where, null);
+        return result;
+    }
+    async bulkInsert(table, dataArray) {
+        const result = await this.db.bulkInsert(table, dataArray);
+        await this._clearCache(table);
+        return result;
+    }
+    async increment(table, increments, where = {}) {
+        const result = await this.db.increment(table, increments, where);
+        if (result > 0)
+            await this._updateCacheByWhere(table, where, null);
+        return result;
+    }
+    async decrement(table, decrements, where = {}) {
+        const result = await this.db.decrement(table, decrements, where);
+        if (result > 0)
+            await this._updateCacheByWhere(table, where, null);
+        return result;
+    }
+    async close() {
+        if (this.redisClient) {
+            await this.redisClient.quit();
+            this.redisClient = null;
+        }
+        await this.db.close();
+    }
+}
+exports.CacheWrapper = CacheWrapper;
+exports.default = CacheWrapper;

package/dist/database/index.d.ts

@@ -0,0 +1,11 @@
+import { IDatabase } from './IDatabase';
+import { DatabaseOptions } from './types';
+import MigrationManager from './migration';
+import ZPackAdapter, { ZPackDatabase } from './zpack';
+/**
+ * Belirtilen adaptör tipine göre bir veritabanı örneği oluşturur ve döndürür.
+ * Bu bir "Fabrika Fonksiyonu"dur.
+ */
+export declare function createDatabase(options: DatabaseOptions): IDatabase;
+export { MigrationManager, ZPackDatabase, ZPackAdapter };
+export default createDatabase;

package/dist/database/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZPackAdapter = exports.ZPackDatabase = exports.MigrationManager = void 0;
+exports.createDatabase = createDatabase;
+const mysql_1 = __importDefault(require("./mysql"));
+const sqlite_1 = __importDefault(require("./sqlite"));
+const mongodb_1 = __importDefault(require("./mongodb"));
+const json_1 = __importDefault(require("./json"));
+const pg_1 = __importDefault(require("./pg"));
+const redis_1 = __importDefault(require("./redis"));
+const cacheWrapper_1 = __importDefault(require("./cacheWrapper"));
+const migration_1 = __importDefault(require("./migration"));
+exports.MigrationManager = migration_1.default;
+const zpack_1 = __importStar(require("./zpack"));
+exports.ZPackAdapter = zpack_1.default;
+Object.defineProperty(exports, "ZPackDatabase", { enumerable: true, get: function () { return zpack_1.ZPackDatabase; } });
+const adapters = {
+    mysql: mysql_1.default,
+    sqlite: sqlite_1.default,
+    mongodb: mongodb_1.default,
+    postgres: pg_1.default,
+    json: json_1.default,
+    redis: redis_1.default,
+    zpack: zpack_1.default,
+};
+/**
+ * Belirtilen adaptör tipine göre bir veritabanı örneği oluşturur ve döndürür.
+ * Bu bir "Fabrika Fonksiyonu"dur.
+ */
+function createDatabase(options) {
+    const { adapter, config } = options;
+    if (!adapter || !adapters[adapter]) {
+        throw new Error(`Geçersiz veya desteklenmeyen adaptör: ${adapter}. Desteklenenler: ${Object.keys(adapters).join(', ')}`);
+    }
+    if (!config) {
+        throw new Error(`'${adapter}' adaptörü için yapılandırma (config) gereklidir.`);
+    }
+    const DatabaseClass = adapters[adapter];
+    const dbInstance = new DatabaseClass(config);
+    if (config.cache) {
+        const wrapper = new cacheWrapper_1.default(dbInstance, config.cache);
+        return new Proxy(wrapper, {
+            get: (target, prop) => {
+                if (typeof target[prop] !== 'undefined') {
+                    return target[prop];
+                }
+                else if (typeof target.db[prop] === 'function') {
+                    return target.db[prop].bind(target.db);
+                }
+                else {
+                    return target.db[prop];
+                }
+            }
+        });
+    }
+    return dbInstance;
+}
+exports.default = createDatabase;

package/dist/database/json.d.ts

@@ -0,0 +1,32 @@
+import { IDatabase } from './IDatabase';
+import { JsonConfig } from './types';
+export declare class JsonDatabase extends IDatabase {
+    private filePath;
+    private db;
+    private isDirty;
+    private isWriting;
+    private writeQueue;
+    private saveDebounceTimeout;
+    private saveInterval;
+    private initPromise;
+    constructor(config: JsonConfig);
+    private _load;
+    private _queueRequest;
+    private _processQueue;
+    private _scheduleSave;
+    private _saveNow;
+    private flushSync;
+    private _matches;
+    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[]>;
+    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>;
+    close(): Promise<void>;
+}
+export default JsonDatabase;