@onurege3467/zerohelper 8.0.0 → 9.0.0

package/dist/database/zpack.js

@@ -0,0 +1,462 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZPackAdapter = exports.ZPackDatabase = void 0;
+const IDatabase_1 = require("./IDatabase");
+const fs_1 = __importDefault(require("fs"));
+const fsp = fs_1.default.promises;
+class ZPackDatabase {
+    constructor(filePath, options = {}) {
+        this.fd = null;
+        this.fileSize = 0n;
+        this.index = new Map();
+        this.deleted = new Set();
+        this.version = 1;
+        this._nextId = 1;
+        this._writeQueue = Promise.resolve();
+        this._closed = false;
+        this._contentEnd = 0n;
+        if (!filePath || typeof filePath !== "string")
+            throw new Error("ZPackDatabase: 'filePath' zorunludur.");
+        this.filePath = filePath;
+        this._autoFlush = options.autoFlush === true;
+    }
+    async open() {
+        if (this.fd)
+            return;
+        try {
+            this.fd = await fsp.open(this.filePath, fs_1.default.constants.O_RDWR);
+        }
+        catch (err) {
+            if (err && err.code === "ENOENT") {
+                this.fd = await fsp.open(this.filePath, fs_1.default.constants.O_RDWR | fs_1.default.constants.O_CREAT);
+            }
+            else
+                throw err;
+        }
+        const stat = await this.fd.stat();
+        this.fileSize = BigInt(stat.size);
+        this._contentEnd = this.fileSize;
+        if (!(await this._tryLoadIndexFromFooter()))
+            await this._scanAndRebuildIndex();
+        if (this.index.size > 0) {
+            let maxId = 0;
+            for (const docId of this.index.keys())
+                if (docId > maxId)
+                    maxId = docId;
+            this._nextId = maxId + 1;
+        }
+    }
+    async close() {
+        if (this._closed || !this.fd)
+            return;
+        await this._writeFooter();
+        await this.fd.close();
+        this._closed = true;
+    }
+    async insert(document, docId) {
+        this._ensureOpen();
+        const payload = this._encodeDocument(document, docId);
+        return this._enqueue(async () => {
+            const writeOffset = this.fileSize;
+            await this.fd.write(payload, 0, payload.length, writeOffset);
+            this.fileSize = writeOffset + BigInt(payload.length);
+            this._contentEnd = this.fileSize;
+            const parsed = this._peekDocMeta(payload);
+            if (parsed.fieldCount === 0) {
+                this.index.delete(parsed.docId);
+                this.deleted.add(parsed.docId);
+            }
+            else {
+                this.index.set(parsed.docId, writeOffset);
+                this.deleted.delete(parsed.docId);
+                if (parsed.docId >= this._nextId)
+                    this._nextId = parsed.docId + 1;
+            }
+            if (this._autoFlush)
+                await this._internalWriteFooter();
+            return parsed.docId;
+        });
+    }
+    async insertBatch(documents) {
+        this._ensureOpen();
+        if (!Array.isArray(documents) || documents.length === 0)
+            return [];
+        const payloads = [];
+        const metas = [];
+        for (const doc of documents) {
+            const buf = this._encodeDocument(doc);
+            payloads.push(buf);
+            metas.push(this._peekDocMeta(buf));
+        }
+        const totalLen = payloads.reduce((s, b) => s + b.length, 0);
+        const buffer = Buffer.alloc(totalLen);
+        let pos = 0;
+        for (const b of payloads) {
+            b.copy(buffer, pos);
+            pos += b.length;
+        }
+        return this._enqueue(async () => {
+            const writeOffset = this.fileSize;
+            await this.fd.write(buffer, 0, buffer.length, writeOffset);
+            let cur = writeOffset;
+            const ids = [];
+            for (let i = 0; i < payloads.length; i++) {
+                const meta = metas[i];
+                if (meta.fieldCount === 0) {
+                    this.index.delete(meta.docId);
+                    this.deleted.add(meta.docId);
+                }
+                else {
+                    this.index.set(meta.docId, cur);
+                    this.deleted.delete(meta.docId);
+                    if (meta.docId >= this._nextId)
+                        this._nextId = meta.docId + 1;
+                }
+                ids.push(meta.docId);
+                cur += BigInt(payloads[i].length);
+            }
+            this.fileSize = writeOffset + BigInt(buffer.length);
+            this._contentEnd = this.fileSize;
+            if (this._autoFlush)
+                await this._internalWriteFooter();
+            return ids;
+        });
+    }
+    async delete(docId) {
+        if (!Number.isInteger(docId) || docId <= 0)
+            throw new Error("delete: 'docId' pozitif bir tamsayı olmalıdır.");
+        const tomb = this._encodeTombstone(docId);
+        await this._enqueue(async () => {
+            const writeOffset = this.fileSize;
+            await this.fd.write(tomb, 0, tomb.length, writeOffset);
+            this.fileSize = writeOffset + BigInt(tomb.length);
+            this._contentEnd = this.fileSize;
+            this.index.delete(docId);
+            this.deleted.add(docId);
+            if (this._autoFlush)
+                await this._internalWriteFooter();
+        });
+    }
+    async get(docId) {
+        this._ensureOpen();
+        const offset = this.index.get(docId);
+        if (offset === undefined)
+            return null;
+        const header = Buffer.alloc(6);
+        if (offset + BigInt(header.length) > this._contentEnd)
+            return null;
+        const { bytesRead: hread } = await this.fd.read(header, 0, header.length, offset);
+        if (hread !== header.length)
+            return null;
+        const docLength = header.readUInt16LE(0);
+        const totalSize = 2 + docLength;
+        if (docLength < 4 || offset + BigInt(totalSize) > this._contentEnd)
+            return null;
+        const buf = Buffer.alloc(totalSize);
+        const { bytesRead } = await this.fd.read(buf, 0, totalSize, offset);
+        if (bytesRead !== totalSize)
+            return null;
+        const parsed = this._decodeDocument(buf);
+        return parsed.fieldCount === 0 ? null : parsed.document;
+    }
+    keys() { return Array.from(this.index.keys()); }
+    _ensureOpen() {
+        if (!this.fd)
+            throw new Error("ZPackDatabase: önce 'open()' çağrılmalı.");
+        if (this._closed)
+            throw new Error("ZPackDatabase: dosya kapalı.");
+    }
+    _enqueue(taskFn) {
+        this._writeQueue = this._writeQueue.then(taskFn, taskFn);
+        return this._writeQueue;
+    }
+    async _internalWriteFooter() {
+        const entries = Array.from(this.index.entries());
+        const footerSize = 9 + entries.length * 12;
+        const footer = Buffer.alloc(footerSize + 4);
+        footer.write("ZPCK", 0, "utf8");
+        footer.writeUInt8(this.version, 4);
+        footer.writeUInt32LE(entries.length, 5);
+        let p = 9;
+        for (const [id, off] of entries) {
+            footer.writeUInt32LE(id, p);
+            p += 4;
+            footer.writeUInt32LE(Number(off & 0xffffffffn), p);
+            p += 4;
+            footer.writeUInt32LE(Number((off >> 32n) & 0xffffffffn), p);
+            p += 4;
+        }
+        footer.writeUInt32LE(footerSize, p);
+        const writeOffset = this.fileSize;
+        await this.fd.write(footer, 0, footer.length, writeOffset);
+        this._contentEnd = writeOffset;
+        this.fileSize = writeOffset + BigInt(footer.length);
+    }
+    async _writeFooter() {
+        await this._enqueue(() => this._internalWriteFooter());
+    }
+    _encodeDocument(document, docId) {
+        let id = docId ?? this._nextId++;
+        const fieldBuffers = [];
+        for (const [key, value] of Object.entries(document)) {
+            const keyBuf = Buffer.from(String(key), "utf8");
+            const valBuf = Buffer.from(String(value), "utf8");
+            const fb = Buffer.alloc(2 + keyBuf.length + valBuf.length);
+            fb.writeUInt8(keyBuf.length, 0);
+            keyBuf.copy(fb, 1);
+            fb.writeUInt8(valBuf.length, 1 + keyBuf.length);
+            valBuf.copy(fb, 2 + keyBuf.length);
+            fieldBuffers.push(fb);
+        }
+        const payloadSize = 4 + fieldBuffers.reduce((s, b) => s + b.length, 0);
+        const buf = Buffer.alloc(2 + payloadSize);
+        buf.writeUInt16LE(payloadSize, 0);
+        buf.writeUInt32LE(id, 2);
+        let offset = 6;
+        for (const b of fieldBuffers) {
+            b.copy(buf, offset);
+            offset += b.length;
+        }
+        return buf;
+    }
+    _encodeTombstone(docId) {
+        const buf = Buffer.alloc(6);
+        buf.writeUInt16LE(4, 0);
+        buf.writeUInt32LE(docId, 2);
+        return buf;
+    }
+    _peekDocMeta(encodedBuf) {
+        const payloadSize = encodedBuf.readUInt16LE(0);
+        const docId = encodedBuf.readUInt32LE(2);
+        const fieldBytes = payloadSize - 4;
+        let p = 6, consumed = 0, fields = 0;
+        while (consumed < fieldBytes) {
+            const klen = encodedBuf.readUInt8(p);
+            p += 1 + klen;
+            consumed += 1 + klen;
+            if (consumed >= fieldBytes)
+                break;
+            const vlen = encodedBuf.readUInt8(p);
+            p += 1 + vlen;
+            consumed += 1 + vlen;
+            fields += 1;
+        }
+        return { docId, fieldCount: fields };
+    }
+    _decodeDocument(buf) {
+        const payloadSize = buf.readUInt16LE(0);
+        const docId = buf.readUInt32LE(2);
+        let p = 6;
+        const end = 2 + payloadSize;
+        const obj = {};
+        let fields = 0;
+        while (p < end) {
+            const klen = buf.readUInt8(p);
+            p += 1;
+            const key = buf.toString("utf8", p, p + klen);
+            p += klen;
+            if (p >= end)
+                break;
+            const vlen = buf.readUInt8(p);
+            p += 1;
+            const val = buf.toString("utf8", p, p + vlen);
+            p += vlen;
+            obj[key] = val;
+            fields += 1;
+        }
+        return { docId, fieldCount: fields, document: obj };
+    }
+    async _tryLoadIndexFromFooter() {
+        if (this.fileSize < 13n)
+            return false;
+        const sizeBuf = Buffer.alloc(4);
+        await this.fd.read(sizeBuf, 0, 4, this.fileSize - 4n);
+        const footerSize = sizeBuf.readUInt32LE(0);
+        if (footerSize < 9 || BigInt(footerSize) + 4n > this.fileSize)
+            return false;
+        const footerStart = this.fileSize - 4n - BigInt(footerSize);
+        const footer = Buffer.alloc(footerSize);
+        await this.fd.read(footer, 0, footerSize, footerStart);
+        if (footer.toString("utf8", 0, 4) !== "ZPCK" || footer.readUInt8(4) !== this.version)
+            return false;
+        const count = footer.readUInt32LE(5);
+        let p = 9;
+        this.index.clear();
+        for (let i = 0; i < count; i++) {
+            const id = footer.readUInt32LE(p);
+            p += 4;
+            const lo = footer.readUInt32LE(p);
+            p += 4;
+            const hi = footer.readUInt32LE(p);
+            p += 4;
+            this.index.set(id, (BigInt(hi) << 32n) + BigInt(lo));
+        }
+        this._contentEnd = footerStart;
+        return true;
+    }
+    async _scanAndRebuildIndex() {
+        this.index.clear();
+        this.deleted.clear();
+        let offset = 0n;
+        const headerBuf = Buffer.alloc(2);
+        while (offset + 2n <= this.fileSize) {
+            const { bytesRead } = await this.fd.read(headerBuf, 0, 2, offset);
+            if (bytesRead < 2)
+                break;
+            const payloadSize = headerBuf.readUInt16LE(0);
+            const idBuf = Buffer.alloc(4);
+            await this.fd.read(idBuf, 0, 4, offset + 2n);
+            const docId = idBuf.readUInt32LE(0);
+            if (payloadSize === 4)
+                this.index.delete(docId);
+            else
+                this.index.set(docId, offset);
+            offset += BigInt(2 + payloadSize);
+        }
+    }
+}
+exports.ZPackDatabase = ZPackDatabase;
+class ZPackAdapter extends IDatabase_1.IDatabase {
+    constructor(config) {
+        super();
+        this.tableMaxId = new Map();
+        this.keyIndex = new Map();
+        this.rowCache = new Map();
+        this.secondary = new Map();
+        this.db = new ZPackDatabase(config.filePath, { autoFlush: !!config.autoFlush });
+        this.initPromise = this._init();
+    }
+    async _init() {
+        await this.db.open();
+        for (const physicalDocId of this.db.keys()) {
+            const doc = await this.db.get(physicalDocId);
+            if (!doc || !doc.t || !Number.isFinite(Number(doc._id)))
+                continue;
+            const table = String(doc.t), idNum = Number(doc._id);
+            if (!this.keyIndex.has(table)) {
+                this.keyIndex.set(table, new Map());
+                this.tableMaxId.set(table, 0);
+                this.rowCache.set(table, new Map());
+                this.secondary.set(table, new Map());
+            }
+            this.keyIndex.get(table).set(idNum, physicalDocId);
+            if (idNum > (this.tableMaxId.get(table) || 0))
+                this.tableMaxId.set(table, idNum);
+        }
+    }
+    async ensureTable(table) {
+        await this.initPromise;
+        if (!this.tableMaxId.has(table)) {
+            this.tableMaxId.set(table, 0);
+            this.keyIndex.set(table, new Map());
+            this.rowCache.set(table, new Map());
+            this.secondary.set(table, new Map());
+        }
+    }
+    _coerce(table, data, id) {
+        const out = { t: table, _id: String(id) };
+        for (const [k, v] of Object.entries(data || {})) {
+            if (k !== 't' && k !== '_id')
+                out[k] = typeof v === 'string' ? v : JSON.stringify(v);
+        }
+        return out;
+    }
+    _matches(row, where) {
+        if (!where)
+            return true;
+        return Object.entries(where).every(([k, v]) => String(row[k]) === String(v));
+    }
+    async select(table, where = null) {
+        await this.ensureTable(table);
+        const results = [];
+        for (const [logicalId, physicalId] of this.keyIndex.get(table).entries()) {
+            let row = this.rowCache.get(table).get(logicalId);
+            if (!row) {
+                const doc = await this.db.get(physicalId);
+                if (!doc)
+                    continue;
+                row = { _id: Number(doc._id) };
+                for (const [k, v] of Object.entries(doc))
+                    if (k !== 't' && k !== '_id')
+                        row[k] = v;
+                this.rowCache.get(table).set(logicalId, row);
+            }
+            if (this._matches(row, where))
+                results.push({ ...row });
+        }
+        return results;
+    }
+    async selectOne(table, where = null) {
+        const res = await this.select(table, where);
+        return res[0] || null;
+    }
+    async insert(table, data) {
+        await this.ensureTable(table);
+        const nextId = (this.tableMaxId.get(table) || 0) + 1;
+        const record = this._coerce(table, data, nextId);
+        const physicalId = await this.db.insert(record);
+        this.tableMaxId.set(table, nextId);
+        this.keyIndex.get(table).set(nextId, physicalId);
+        const row = { _id: nextId, ...data };
+        this.rowCache.get(table).set(nextId, row);
+        return nextId;
+    }
+    async update(table, data, where) {
+        const rows = await this.select(table, where);
+        for (const row of rows) {
+            const merged = { ...row, ...data };
+            const record = this._coerce(table, merged, row._id);
+            const physicalId = await this.db.insert(record);
+            this.keyIndex.get(table).set(row._id, physicalId);
+            this.rowCache.get(table).set(row._id, merged);
+        }
+        return rows.length;
+    }
+    async set(table, data, where) {
+        const existing = await this.selectOne(table, where);
+        return existing ? this.update(table, data, where) : this.insert(table, { ...where, ...data });
+    }
+    async delete(table, where) {
+        const rows = await this.select(table, where);
+        for (const row of rows) {
+            const physicalId = this.keyIndex.get(table).get(row._id);
+            if (physicalId !== undefined) {
+                await this.db.delete(physicalId);
+                this.keyIndex.get(table).delete(row._id);
+                this.rowCache.get(table).delete(row._id);
+            }
+        }
+        return rows.length;
+    }
+    async bulkInsert(table, dataArray) {
+        for (const data of dataArray)
+            await this.insert(table, data);
+        return dataArray.length;
+    }
+    async increment(table, increments, where = {}) {
+        const rows = await this.select(table, where);
+        for (const row of rows) {
+            const updated = { ...row };
+            for (const [f, v] of Object.entries(increments))
+                updated[f] = (Number(updated[f]) || 0) + v;
+            await this.update(table, updated, { _id: row._id });
+        }
+        return rows.length;
+    }
+    async decrement(table, decrements, where = {}) {
+        const rows = await this.select(table, where);
+        for (const row of rows) {
+            const updated = { ...row };
+            for (const [f, v] of Object.entries(decrements))
+                updated[f] = (Number(updated[f]) || 0) - v;
+            await this.update(table, updated, { _id: row._id });
+        }
+        return rows.length;
+    }
+    async close() { await this.db.close(); }
+}
+exports.ZPackAdapter = ZPackAdapter;
+exports.default = ZPackAdapter;

package/dist/functions/index.d.ts

@@ -0,0 +1,183 @@
+export declare function makeUniqueId(): string;
+export declare function randomArray<T>(arr: T[]): T;
+export declare function randomText(length?: number): string;
+export declare function randomNumber(min?: number, max?: number): number;
+export declare function randomEmoji(): string;
+export declare function randomHex(): string;
+export declare function randomFloat(min: number, max: number): number;
+export declare function titleCase(sentence: string): string;
+export declare function generateRandomString(length: number): string;
+export declare function generateSlug(text: string): string;
+export declare function wordCount(text: string): number;
+export declare function shuffleArray<T>(array: T[]): T[];
+export declare function flattenArray(arr: any[]): any[];
+export declare function removeFalsyValues<T>(arr: T[]): T[];
+export declare function groupBy<T>(arr: T[], key: keyof T): Record<string, T[]>;
+export declare function pluck<T, K extends keyof T>(arr: T[], key: K): T[K][];
+export declare function sortBy<T>(arr: T[], key: keyof T): T[];
+export declare function filterObjectByKey<T extends object>(obj: T, keys: string[]): Partial<T>;
+export declare function deepMerge(obj1: any, obj2: any): any;
+export declare function encryptText(text: string, secret: string): {
+    encryptedText: string;
+    iv: string;
+};
+export declare function decryptText(encryptedText: string, secret: string, ivHex: string): string;
+export declare function hashPassword(password: string): string;
+export declare function verifyPassword(password: string, hash: string): boolean;
+export declare function generateJWT(payload: object, secret: string): string;
+export declare function verifyJWT(token: string, secret: string): any;
+export declare function generateSalt(): string;
+export declare function validateUUID(uuid: string): boolean;
+export declare function isPasswordStrong(password: string): boolean;
+export declare function mean(arr: number[]): number;
+export declare function median(arr: number[]): number;
+export declare function variance(arr: number[]): number;
+export declare function standardDeviation(arr: number[]): number;
+export declare function sum(arr: number[]): number;
+export declare function max(arr: number[]): number;
+export declare function min(arr: number[]): number;
+export declare function range(start: number, end: number): number[];
+export declare function isPrime(num: number): boolean;
+export declare function factorial(n: number): number;
+export declare function combination(n: number, r: number): number;
+export declare function permutation(n: number, r: number): number;
+export declare function formatDate(date: Date, format?: string): string;
+export declare function dateDifference(date1: Date, date2: Date): number;
+export declare function addDays(date: Date, days: number): Date;
+export declare function subtractDays(date: Date, days: number): Date;
+export declare function fetchData(url: string): Promise<any>;
+export declare function postData(url: string, data: any): Promise<any>;
+export declare function isEmail(email: string): boolean;
+export declare function isPhone(phone: string): boolean;
+export declare function isURL(url: string): boolean;
+export declare function sanitizeHTML(html: string): string;
+export declare function validateCreditCard(cardNumber: string): boolean;
+export interface ValidationSchema {
+    [key: string]: {
+        required?: boolean;
+        type?: string;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: RegExp;
+        min?: number;
+        max?: number;
+    };
+}
+export declare function validateSchema(data: any, schema: ValidationSchema): {
+    isValid: boolean;
+    errors: string[];
+};
+export declare function sanitizeInput(input: any, options?: {
+    trim?: boolean;
+    removeHTML?: boolean;
+    escape?: boolean;
+}): any;
+export type LogLevel = 'error' | 'warn' | 'info' | 'debug';
+export interface LoggerOptions {
+    level?: LogLevel;
+    enableColors?: boolean;
+    enableTimestamp?: boolean;
+    logFile?: string | null;
+}
+export declare class Logger {
+    private level;
+    private enableColors;
+    private enableTimestamp;
+    private logFile;
+    private levels;
+    private colors;
+    constructor(options?: LoggerOptions);
+    private shouldLog;
+    private formatMessage;
+    private writeToFile;
+    log(level: LogLevel, message: string, data?: any): void;
+    error(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    debug(message: string, data?: any): void;
+    setLevel(level: LogLevel): void;
+    getLevel(): LogLevel;
+}
+export declare function createLogger(options?: LoggerOptions): Logger;
+export declare function logInfo(message: string, data?: any): void;
+export declare function logError(message: string, data?: any): void;
+export declare function logWarn(message: string, data?: any): void;
+export declare function logDebug(message: string, data?: any): void;
+export declare const http_module: {
+    fetchData: typeof fetchData;
+    postData: typeof postData;
+};
+export declare const date_module: {
+    formatDate: typeof formatDate;
+    dateDifference: typeof dateDifference;
+    addDays: typeof addDays;
+    subtractDays: typeof subtractDays;
+};
+export declare const random_module: {
+    makeUniqueId: typeof makeUniqueId;
+    randomArray: typeof randomArray;
+    randomText: typeof randomText;
+    randomNumber: typeof randomNumber;
+    randomEmoji: typeof randomEmoji;
+    randomHex: typeof randomHex;
+    randomFloat: typeof randomFloat;
+};
+export declare const string_module: {
+    titleCase: typeof titleCase;
+    generateRandomString: typeof generateRandomString;
+    generateSlug: typeof generateSlug;
+    wordCount: typeof wordCount;
+};
+export declare const array_module: {
+    shuffleArray: typeof shuffleArray;
+    flattenArray: typeof flattenArray;
+    removeFalsyValues: typeof removeFalsyValues;
+    groupBy: typeof groupBy;
+    pluck: typeof pluck;
+    sortBy: typeof sortBy;
+};
+export declare const object_module: {
+    filterObjectByKey: typeof filterObjectByKey;
+    deepMerge: typeof deepMerge;
+};
+export declare const crypto_module: {
+    encryptText: typeof encryptText;
+    decryptText: typeof decryptText;
+    hashPassword: typeof hashPassword;
+    verifyPassword: typeof verifyPassword;
+    generateJWT: typeof generateJWT;
+    verifyJWT: typeof verifyJWT;
+    generateSalt: typeof generateSalt;
+    validateUUID: typeof validateUUID;
+    isPasswordStrong: typeof isPasswordStrong;
+};
+export declare const math_module: {
+    mean: typeof mean;
+    median: typeof median;
+    variance: typeof variance;
+    standardDeviation: typeof standardDeviation;
+    sum: typeof sum;
+    max: typeof max;
+    min: typeof min;
+    range: typeof range;
+    isPrime: typeof isPrime;
+    combination: typeof combination;
+    permutation: typeof permutation;
+};
+export declare const validation_module: {
+    isEmail: typeof isEmail;
+    isPhone: typeof isPhone;
+    isURL: typeof isURL;
+    sanitizeHTML: typeof sanitizeHTML;
+    validateCreditCard: typeof validateCreditCard;
+    validateSchema: typeof validateSchema;
+    sanitizeInput: typeof sanitizeInput;
+};
+export declare const logger_module: {
+    createLogger: typeof createLogger;
+    Logger: typeof Logger;
+    info: typeof logInfo;
+    error: typeof logError;
+    warn: typeof logWarn;
+    debug: typeof logDebug;
+};