@onurege3467/zerohelper 10.2.6 → 11.0.0

package/dist/database/toon.js

@@ -1,244 +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.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');
-            const parsed = (0, toon_1.parse)(content);
-            if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
-                this.db = {};
-            }
-            else {
-                this.db = {};
-                for (const [key, value] of Object.entries(parsed)) {
-                    this.db[key] = Array.isArray(value) ? value : [];
-                }
-            }
-        }
-        catch (error) {
-            console.error("ToonDB load error:", error);
-            this.db = {};
-        }
-    }
-    _getTable(table) {
-        const data = this.db[table];
-        return Array.isArray(data) ? data : [];
-    }
-    _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 (!Array.isArray(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 tableData = this._getTable(table);
-                const maxId = tableData.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;
-                const tableData = this._getTable(table);
-                tableData.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 tableData = this._getTable(table);
-                const initial = tableData.length;
-                this.db[table] = tableData.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 tableData = this._getTable(table);
-            const results = where && Object.keys(where).length > 0
-                ? tableData.filter(row => Object.keys(where).every(k => String(row[k]) === String(where[k])))
-                : tableData;
-            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) {
-        await this.initPromise;
-        await this.ensureTable(table);
-        const ex = await this.selectOne(table, where);
-        if (ex) {
-            // Kayıt varsa güncelle
-            await this.update(table, data, where);
-            return ex._id;
-        }
-        else {
-            // Kayıt yoksa ekle
-            return 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(() => {
-                const tableData = this._getTable(table);
-                let maxId = tableData.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;
-                const tableData = this._getTable(table);
-                tableData.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,71 +0,0 @@
-export interface BaseConfig {
-    cache?: CacheConfig;
-}
-export interface NetworkConfig extends BaseConfig {
-    host?: string;
-    port?: number;
-    username?: string;
-    password?: string;
-    database?: string;
-    url?: string;
-    uri?: 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;
-}
-export interface JsonConfig extends FileConfig {
-    saveInterval?: number;
-}
-export interface ZPackConfig extends FileConfig {
-    autoFlush?: boolean;
-    indexFields?: Record<string, string[]>;
-}
-export interface ToonConfig extends FileConfig {
-    saveInterval?: number;
-}
-export interface CacheConfig {
-    type: 'memory' | 'redis';
-    ttl?: number;
-    max?: number;
-    host?: string;
-    port?: number;
-    password?: string;
-}
-export type DatabaseOptions = {
-    adapter: 'mysql';
-    config: MySQLConfig;
-} | {
-    adapter: 'sqlite';
-    config: SQLiteConfig;
-} | {
-    adapter: 'mongodb';
-    config: MongoDBConfig;
-} | {
-    adapter: 'postgres';
-    config: PostgreSQLConfig;
-} | {
-    adapter: 'json';
-    config: JsonConfig;
-} | {
-    adapter: 'redis';
-    config: RedisConfig;
-} | {
-    adapter: 'zpack';
-    config: ZPackConfig;
-} | {
-    adapter: 'toon';
-    config: ToonConfig;
-};
-export type AdapterType = DatabaseOptions['adapter'];

package/dist/database/types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/database/zpack.d.ts

@@ -1,75 +0,0 @@
-import { IDatabase } from './IDatabase';
-import { ZPackConfig } from './types';
-/**
- * ZPackDatabase: Low-level Binary Storage
- */
-export declare class ZPackDatabase {
-    filePath: string;
-    private fd;
-    private fileSize;
-    private index;
-    private deleted;
-    private version;
-    private _nextId;
-    private _writeQueue;
-    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>;
-    get(docId: number): Promise<Record<string, any> | null>;
-    keys(): number[];
-    private _ensureOpen;
-    private _enqueue;
-    private _internalWriteFooter;
-    private _writeFooter;
-    private _encodeDocument;
-    private _decodeDocument;
-    private _encodeTombstone;
-    private _peekDocMeta;
-    private _tryLoadIndexFromFooter;
-    private _scanAndRebuildIndex;
-}
-/**
- * ZPackAdapter: IDatabase Implementation
- */
-export declare class ZPackAdapter extends IDatabase {
-    private db;
-    private initPromise;
-    private tableMaxId;
-    private keyIndex;
-    private rowCache;
-    private secondary;
-    private indexedFields;
-    private _isClosing;
-    private _executing;
-    constructor(config: ZPackConfig);
-    private _init;
-    private _execute;
-    private _rawSelect;
-    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>;
-    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, 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;