@onurege3467/zerohelper 9.0.0 → 9.2.0

package/dist/database/toon.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToonDatabase = 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"));
+const toon_1 = require("../functions/toon");
+class ToonDatabase 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('ToonDB: "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);
+            if (!(0, fs_1.existsSync)(dir))
+                await promises_1.default.mkdir(dir, { recursive: true });
+            if (!(0, fs_1.existsSync)(this.filePath)) {
+                this.db = {};
+                await this._saveNow();
+                return;
+            }
+            const content = await promises_1.default.readFile(this.filePath, 'utf-8');
+            this.db = (0, toon_1.parse)(content);
+        }
+        catch (error) {
+            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, (0, toon_1.stringify)(this.db));
+            this.isDirty = false;
+        }
+        catch (error) {
+            console.error("ToonDB save error:", error);
+        }
+    }
+    flushSync() {
+        if (this.isDirty) {
+            try {
+                (0, fs_1.writeFileSync)(this.filePath, (0, toon_1.stringify)(this.db));
+                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.ToonDatabase = ToonDatabase;
+exports.default = ToonDatabase;

package/dist/database/types.d.ts

@@ -1,47 +1,38 @@
-export interface MySQLConfig {
-    host: string;
-    user: string;
-    password?: string;
-    database: string;
-    port?: number;
-    connectionLimit?: number;
-    cache?: CacheConfig;
-}
-export interface SQLiteConfig {
-    filename: string;
-    cache?: CacheConfig;
-}
-export interface MongoDBConfig {
-    uri: string;
-    dbName: string;
+export interface BaseConfig {
     cache?: CacheConfig;
 }
-export interface PostgreSQLConfig {
-    host: string;
-    user: string;
-    password?: string;
-    database: string;
-    port?: number;
-    connectionLimit?: number;
-    cache?: CacheConfig;
-}
-export interface RedisConfig {
+export interface NetworkConfig extends BaseConfig {
     host?: string;
     port?: number;
+    username?: string;
     password?: string;
-    db?: number;
+    database?: string;
+    url?: string;
+    poolSize?: number;
+}
+export interface FileConfig extends BaseConfig {
+    path: string;
+}
+export interface MySQLConfig extends NetworkConfig {
+}
+export interface PostgreSQLConfig extends NetworkConfig {
+}
+export interface SQLiteConfig extends FileConfig {
+}
+export interface MongoDBConfig extends NetworkConfig {
+}
+export interface RedisConfig extends NetworkConfig {
     keyPrefix?: string;
-    cache?: CacheConfig;
 }
-export interface JsonConfig {
-    filePath: string;
+export interface JsonConfig extends FileConfig {
     saveInterval?: number;
-    cache?: CacheConfig;
 }
-export interface ZPackConfig {
-    filePath: string;
+export interface ZPackConfig extends FileConfig {
     autoFlush?: boolean;
-    cache?: CacheConfig;
+    indexFields?: Record<string, string[]>;
+}
+export interface ToonConfig extends FileConfig {
+    saveInterval?: number;
 }
 export interface CacheConfig {
     type: 'memory' | 'redis';
@@ -72,5 +63,8 @@ export type DatabaseOptions = {
 } | {
     adapter: 'zpack';
     config: ZPackConfig;
+} | {
+    adapter: 'toon';
+    config: ToonConfig;
 };
 export type AdapterType = DatabaseOptions['adapter'];

package/dist/database/zpack.d.ts

@@ -12,11 +12,14 @@ export declare class ZPackDatabase {
     private _closed;
     private _autoFlush;
     private _contentEnd;
+    private _compression;
     constructor(filePath: string, options?: {
         autoFlush?: boolean;
+        compression?: boolean;
     });
     open(): Promise<void>;
     close(): Promise<void>;
+    vacuum(): Promise<void>;
     insert(document: Record<string, any>, docId?: number): Promise<number>;
     insertBatch(documents: Record<string, any>[]): Promise<number[]>;
     delete(docId: number): Promise<void>;
@@ -27,9 +30,9 @@ export declare class ZPackDatabase {
     private _internalWriteFooter;
     private _writeFooter;
     private _encodeDocument;
+    private _decodeDocument;
     private _encodeTombstone;
     private _peekDocMeta;
-    private _decodeDocument;
     private _tryLoadIndexFromFooter;
     private _scanAndRebuildIndex;
 }
@@ -40,20 +43,23 @@ export declare class ZPackAdapter extends IDatabase {
     private keyIndex;
     private rowCache;
     private secondary;
+    private indexedFields;
     constructor(config: ZPackConfig);
     private _init;
     ensureTable(table: string): Promise<void>;
+    private _updateSecondaryIndex;
     private _coerce;
     private _matches;
     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<number>;
     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>;
+    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, increments: Record<string, number>, where?: Record<string, any>): Promise<number>;
-    decrement(table: string, decrements: Record<string, number>, where?: 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>;
+    vacuum(): Promise<void>;
     close(): Promise<void>;
 }
 export default ZPackAdapter;