@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/database/sqlite.js

@@ -0,0 +1,273 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQLiteDatabase = void 0;
+const IDatabase_1 = require("./IDatabase");
+const sqlite3_1 = __importDefault(require("sqlite3"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class SQLiteDatabase extends IDatabase_1.IDatabase {
+    constructor(config) {
+        super();
+        if (!config || !config.filename) {
+            throw new Error('SQLite yapılandırması için "filename" gereklidir.');
+        }
+        const dir = path_1.default.dirname(config.filename);
+        if (!fs_1.default.existsSync(dir)) {
+            fs_1.default.mkdirSync(dir, { recursive: true });
+        }
+        this.db = new sqlite3_1.default.Database(config.filename, (err) => {
+            if (err) {
+                console.error("SQLite connection error:", err.message);
+            }
+        });
+    }
+    _detectColumnType(value) {
+        if (value === null || value === undefined)
+            return 'TEXT';
+        if (typeof value === 'boolean')
+            return 'BOOLEAN';
+        if (typeof value === 'number')
+            return Number.isInteger(value) ? 'INTEGER' : 'REAL';
+        if (value instanceof Date)
+            return 'DATETIME';
+        if (typeof value === 'string') {
+            if (value.trim() === '')
+                return 'TEXT';
+            if (/^-?\d+$/.test(value.trim()))
+                return 'INTEGER';
+            if (/^-?\d+\.\d+$/.test(value.trim()))
+                return 'REAL';
+            const lowerValue = value.toLowerCase().trim();
+            if (lowerValue === 'true' || lowerValue === 'false')
+                return 'BOOLEAN';
+            if (value.match(/^\d{4}-\d{2}-\d{2}/))
+                return 'DATETIME';
+        }
+        return 'TEXT';
+    }
+    _determineBestColumnType(values) {
+        const types = values.map(v => this._detectColumnType(v));
+        const typePriority = { 'INTEGER': 1, 'REAL': 2, 'BOOLEAN': 3, 'DATETIME': 4, 'TEXT': 5 };
+        const maxPriority = Math.max(...types.map(t => typePriority[t] || 5));
+        return Object.keys(typePriority).find(t => typePriority[t] === maxPriority) || 'TEXT';
+    }
+    async _ensureMissingColumns(table, data) {
+        const columnsInfo = await this.query(`PRAGMA table_info(\`${table}\`)
+`);
+        const existingNames = columnsInfo.map(col => col.name);
+        for (const key of Object.keys(data)) {
+            if (!existingNames.includes(key)) {
+                const columnType = this._detectColumnType(data[key]);
+                await this.query(`ALTER TABLE 
+            }
+        }
+    }
+    query(sql, params = []) {
+        return new Promise((resolve, reject) => {
+            const upperSql = sql.trim().toUpperCase();
+            if (upperSql.startsWith('SELECT') || upperSql.startsWith('PRAGMA')) {
+                this.db.all(sql, params, (err, rows) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve(rows);
+                });
+            }
+            else {
+                this.db.run(sql, params, function (err) {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve({ changes: this.changes, lastInsertRowid: this.lastID });
+                });
+            }
+        });
+    }
+    async ensureTable(table, data = {}) {
+        try {
+            await this.query(`SELECT 1 FROM 
+        }
+        catch (error) {
+            if (error.message.includes('no such table')) {
+                const columnDefinitions = Object.keys(data).map(col => {
+                    const columnType = this._detectColumnType(data[col]);
+                    return `reverse{col}
+                });
+                const columnsPart = columnDefinitions.length > 0 ? ', ' + columnDefinitions.join(", ") : '';
+                const createTableSQL = `CREATE TABLE 
+                await this.query(createTableSQL);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    _serializeValue(value) {
+        if (value instanceof Date)
+            return value.toISOString();
+        if (Array.isArray(value) || (typeof value === 'object' && value !== null))
+            return JSON.stringify(value);
+        return value;
+    }
+    _deserializeValue(value) {
+        if (typeof value === 'string' && (value.startsWith('[') || value.startsWith('{'))) {
+            try {
+                const parsed = JSON.parse(value);
+                if (typeof parsed === 'object' && parsed !== null)
+                    return parsed;
+            }
+            catch (e) { }
+        }
+        return value;
+    }
+    async insert(table, data) {
+        const copy = { ...data };
+        await this.ensureTable(table, copy);
+        await this._ensureMissingColumns(table, copy);
+        const keys = Object.keys(copy);
+        const placeholders = keys.map(() => '?').join(',');
+        const values = Object.values(copy).map(v => this._serializeValue(v));
+        const sql = `INSERT INTO 
+        const result = await this.query(sql, values);
+        return result.lastInsertRowid;
+    }
+    async update(table, data, where) {
+        await this.ensureTable(table, { ...data, ...where });
+        await this._ensureMissingColumns(table, { ...data, ...where });
+        const setString = Object.keys(data).map(k => `reverse{k}
+        const whereString = Object.keys(where).map(k => `reverse{k}
+        const sql = `UPDATE 
+        const result = await this.query(sql, [...Object.values(data).map(v => this._serializeValue(v)), ...Object.values(where).map(v => this._serializeValue(v))]);
+        return result.changes;
+    }
+    async delete(table, where) {
+        if (!where || Object.keys(where).length === 0)
+            return 0;
+        await this.ensureTable(table, { ...where });
+        await this._ensureMissingColumns(table, where);
+        const whereString = Object.keys(where).map(k => `reverse{k}
+        const sql = `DELETE FROM 
+        const result = await this.query(sql, Object.values(where).map(v => this._serializeValue(v)));
+        return result.changes;
+    }
+    async select(table, where = null) {
+        await this.ensureTable(table, where || {});
+        if (where && Object.keys(where).length > 0) {
+            await this._ensureMissingColumns(table, where);
+        }
+        let sql = `SELECT * FROM 
+        let params = [];
+        if (where && Object.keys(where).length > 0) {
+            const whereString = Object.keys(where).map(k => `reverse{k}
+            sql += ` WHERE ${whereString}`;
+            params = Object.values(where).map(v => this._serializeValue(v));
+        }
+        const rows = await this.query(sql, params);
+        return rows.map((row) => {
+            const newRow = {};
+            for (const key in row) {
+                newRow[key] = this._deserializeValue(row[key]);
+            }
+            return newRow;
+        });
+    }
+    async set(table, data, where) {
+        const existing = await this.select(table, where);
+        if (existing.length === 0) {
+            return await this.insert(table, { ...where, ...data });
+        }
+        else {
+            return await 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, dataArray[0]);
+        const allKeys = new Set();
+        dataArray.forEach(obj => Object.keys(obj).forEach(key => allKeys.add(key)));
+        for (const key of allKeys) {
+            const columnsInfo = await this.query(`PRAGMA table_info(
+            if (!columnsInfo.map(col => col.name).includes(key)) {
+                const columnValues = dataArray.map(obj => obj[key]).filter(val => val !== undefined && val !== null);
+                const columnType = columnValues.length > 0 ? this._determineBestColumnType(columnValues) : 'TEXT';
+                await this.query(`ALTER TABLE 
+            }
+        }
+        const keys = Array.from(allKeys);
+        const sql = `INSERT INTO 
+        return new Promise((resolve, reject) => {
+            this.db.serialize(() => {
+                this.db.run("BEGIN TRANSACTION;");
+                let completed = 0;
+                let hasError = false;
+                const stmt = this.db.prepare(sql);
+                for (const item of dataArray) {
+                    if (hasError)
+                        break;
+                    stmt.run(keys.map(k => this._serializeValue(item[k])), (err) => {
+                        if (err && !hasError) {
+                            hasError = true;
+                            this.db.run("ROLLBACK;");
+                            reject(err);
+                        }
+                        completed++;
+                        if (completed === dataArray.length && !hasError) {
+                            this.db.run("COMMIT;", (err) => {
+                                if (err)
+                                    reject(err);
+                                else {
+                                    stmt.finalize();
+                                    resolve(dataArray.length);
+                                }
+                            });
+                        }
+                    });
+                }
+            });
+        });
+    }
+    async increment(table, increments, where = {}) {
+        const incrementClauses = Object.keys(increments).map(field => `reverse{field}
+        const incrementValues = Object.values(increments);
+        const { whereClause, values: whereValues } = this._buildWhereClause(where);
+        const sql = `UPDATE 
+        const result = await this.query(sql, [...incrementValues, ...whereValues]);
+        return result.changes;
+    }
+    async decrement(table, decrements, where = {}) {
+        const decrementClauses = Object.keys(decrements).map(field => `reverse{field}
+        const decrementValues = Object.values(decrements);
+        const { whereClause, values: whereValues } = this._buildWhereClause(where);
+        const sql = `UPDATE 
+        const result = await this.query(sql, [...decrementValues, ...whereValues]);
+        return result.changes;
+    }
+    _buildWhereClause(where = {}) {
+        const conditions = Object.keys(where);
+        if (conditions.length === 0)
+            return { whereClause: '', values: [] };
+        const whereClause = ' WHERE ' + conditions.map(key => `reverse{key}
+        const values = Object.values(where).map(v => this._serializeValue(v));
+        return { whereClause, values };
+    }
+    async close() {
+        return new Promise((resolve, reject) => {
+            this.db.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    }
+}
+exports.SQLiteDatabase = SQLiteDatabase;
+exports.default = SQLiteDatabase;

package/dist/database/types.d.ts

@@ -0,0 +1,76 @@
+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;
+    cache?: CacheConfig;
+}
+export interface PostgreSQLConfig {
+    host: string;
+    user: string;
+    password?: string;
+    database: string;
+    port?: number;
+    connectionLimit?: number;
+    cache?: CacheConfig;
+}
+export interface RedisConfig {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+    keyPrefix?: string;
+    cache?: CacheConfig;
+}
+export interface JsonConfig {
+    filePath: string;
+    saveInterval?: number;
+    cache?: CacheConfig;
+}
+export interface ZPackConfig {
+    filePath: string;
+    autoFlush?: boolean;
+    cache?: CacheConfig;
+}
+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;
+};
+export type AdapterType = DatabaseOptions['adapter'];

package/dist/database/types.js

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

package/dist/database/zpack.d.ts

@@ -0,0 +1,59 @@
+import { IDatabase } from './IDatabase';
+import { ZPackConfig } from './types';
+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;
+    constructor(filePath: string, options?: {
+        autoFlush?: boolean;
+    });
+    open(): Promise<void>;
+    close(): 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 _encodeTombstone;
+    private _peekDocMeta;
+    private _decodeDocument;
+    private _tryLoadIndexFromFooter;
+    private _scanAndRebuildIndex;
+}
+export declare class ZPackAdapter extends IDatabase {
+    private db;
+    private initPromise;
+    private tableMaxId;
+    private keyIndex;
+    private rowCache;
+    private secondary;
+    constructor(config: ZPackConfig);
+    private _init;
+    ensureTable(table: string): Promise<void>;
+    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>;
+    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 ZPackAdapter;