lmcs-db 1.0.3 → 2.0.0

package/dist/storage/aol.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AOLStorage = void 0;
+const base_1 = require("./base");
+const manager_1 = require("../crypto/manager");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const lock_1 = require("../utils/lock");
+const crypto_1 = require("crypto");
+class AOLStorage extends base_1.BaseStorage {
+    buffer = [];
+    crypto;
+    locker = new lock_1.FileLocker();
+    bufferSize = 100;
+    compactionTimer;
+    isInitialized = false;
+    writeCount = 0;
+    constructor(config) {
+        super(config);
+        if (config.encryptionKey) {
+            this.crypto = new manager_1.CryptoManager(config.encryptionKey);
+        }
+        this.bufferSize = config.bufferSize || 100;
+        if (config.compactionInterval && config.compactionInterval > 0) {
+            this.compactionTimer = setInterval(() => {
+                this.compact().catch(console.error);
+            }, config.compactionInterval);
+        }
+    }
+    async initialize() {
+        const filePath = this.getFilePath("aol");
+        await (0, promises_1.mkdir)((0, path_1.dirname)(filePath), { recursive: true });
+        this.isInitialized = true;
+    }
+    async append(entry) {
+        if (!this.isInitialized)
+            throw new Error("Storage not initialized");
+        if (this.config.enableChecksums) {
+            const entryForChecksum = { ...entry };
+            delete entryForChecksum.checksum;
+            entry.checksum = (0, crypto_1.createHash)("sha256")
+                .update(JSON.stringify(entryForChecksum))
+                .digest("hex");
+        }
+        this.buffer.push(entry);
+        this.writeCount++;
+        if (this.buffer.length >= this.bufferSize) {
+            await this.flush();
+        }
+    }
+    async flush() {
+        if (this.buffer.length === 0 || !this.isInitialized)
+            return;
+        const filePath = this.getFilePath("aol");
+        const lockPath = `${filePath}.lock`;
+        await this.locker.withLock(lockPath, async () => {
+            const lines = this.buffer.map((entry) => {
+                const line = JSON.stringify(entry);
+                if (this.crypto) {
+                    return JSON.stringify(this.crypto.encrypt(line));
+                }
+                return line;
+            });
+            await (0, promises_1.appendFile)(filePath, lines.join("\n") + "\n", "utf8");
+            // fsync para durabilidade
+            const fd = await (0, promises_1.open)(filePath, "a");
+            try {
+                await fd.sync();
+            }
+            finally {
+                await fd.close();
+            }
+        });
+        this.buffer = [];
+    }
+    async *readStream() {
+        await this.flush();
+        const filePath = this.getFilePath("aol");
+        try {
+            const content = await (0, promises_1.readFile)(filePath, "utf8");
+            const lines = content.split("\n").filter((l) => l.trim());
+            for (const line of lines) {
+                try {
+                    let jsonStr;
+                    if (this.crypto) {
+                        const encrypted = JSON.parse(line);
+                        jsonStr = this.crypto.decrypt(encrypted);
+                    }
+                    else {
+                        jsonStr = line;
+                    }
+                    const entry = JSON.parse(jsonStr);
+                    // Verifica checksum
+                    if (this.config.enableChecksums && entry.checksum) {
+                        const expected = entry.checksum;
+                        const checkEntry = { ...entry };
+                        delete checkEntry.checksum;
+                        const actual = (0, crypto_1.createHash)("sha256")
+                            .update(JSON.stringify(checkEntry))
+                            .digest("hex");
+                        if (actual !== expected) {
+                            console.warn(`Checksum mismatch for entry ${entry.id}, skipping`);
+                            continue;
+                        }
+                    }
+                    yield entry;
+                }
+                catch (err) {
+                    console.warn("Corrupted log entry skipped:", err);
+                }
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    async compact() {
+        await this.flush();
+        const filePath = this.getFilePath("aol");
+        const tempFile = `${filePath}.tmp`;
+        const state = new Map();
+        for await (const entry of this.readStream()) {
+            const key = `${entry.collection}:${entry.id}`;
+            if (entry.op === "DELETE") {
+                state.delete(key);
+            }
+            else if (entry.op !== "BEGIN" &&
+                entry.op !== "COMMIT" &&
+                entry.op !== "ROLLBACK") {
+                state.set(key, entry);
+            }
+        }
+        const entries = Array.from(state.values());
+        if (entries.length === 0) {
+            await (0, promises_1.writeFile)(filePath, "", "utf8");
+            return;
+        }
+        const lines = entries.map((e) => {
+            const line = JSON.stringify(e);
+            return this.crypto ? JSON.stringify(this.crypto.encrypt(line)) : line;
+        });
+        await (0, promises_1.writeFile)(tempFile, lines.join("\n"), "utf8");
+        const lockPath = `${filePath}.lock`;
+        await this.locker.withLock(lockPath, async () => {
+            await (0, promises_1.rename)(tempFile, filePath);
+        });
+        console.log(`Compaction complete: ${this.writeCount} writes -> ${entries.length} entries`);
+    }
+    async close() {
+        await this.flush();
+        if (this.compactionTimer)
+            clearInterval(this.compactionTimer);
+        this.isInitialized = false;
+    }
+    getStats() {
+        return {
+            buffered: this.buffer.length,
+            totalWrites: this.writeCount,
+        };
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.AOLStorage = AOLStorage;

package/dist/storage/base.d.ts

@@ -0,0 +1,36 @@
+export interface IStorage {
+    initialize(): Promise<void>;
+    append(entry: LogEntry): Promise<void>;
+    readStream(): AsyncGenerator<LogEntry>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    clear?(): Promise<void>;
+    compact?(): Promise<void>;
+}
+export interface LogEntry {
+    op: 'INSERT' | 'UPDATE' | 'DELETE' | 'BEGIN' | 'COMMIT' | 'ROLLBACK';
+    collection: string;
+    id: string;
+    data?: unknown;
+    checksum: string;
+    timestamp: number;
+    txId?: string;
+}
+export interface StorageConfig {
+    dbPath: string;
+    dbName: string;
+    encryptionKey?: string;
+    enableChecksums?: boolean;
+}
+export declare abstract class BaseStorage implements IStorage {
+    protected config: StorageConfig;
+    constructor(config: StorageConfig);
+    abstract initialize(): Promise<void>;
+    abstract append(entry: LogEntry): Promise<void>;
+    abstract readStream(): AsyncGenerator<LogEntry>;
+    abstract flush(): Promise<void>;
+    abstract close(): Promise<void>;
+    abstract clear?(): Promise<void>;
+    abstract compact?(): Promise<void>;
+    protected getFilePath(extension: string): string;
+}

package/dist/storage/base.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseStorage = void 0;
+class BaseStorage {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    getFilePath(extension) {
+        return `${this.config.dbPath}/${this.config.dbName}.${extension}`;
+    }
+}
+exports.BaseStorage = BaseStorage;

package/dist/storage/binary.d.ts

@@ -0,0 +1,21 @@
+import { BaseStorage, LogEntry, StorageConfig } from "./base";
+export declare class BinaryStorage extends BaseStorage {
+    private data;
+    private locker;
+    private crypto?;
+    private filePath;
+    private lockPath;
+    private readonly MAGIC;
+    private readonly VERSION;
+    constructor(config: StorageConfig);
+    initialize(): Promise<void>;
+    append(entry: LogEntry): Promise<void>;
+    readAll(): Promise<LogEntry[]>;
+    readStream(): AsyncGenerator<LogEntry>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    clear(): Promise<void>;
+    compact(): Promise<void>;
+    private serialize;
+    private deserialize;
+}

package/dist/storage/binary.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryStorage = void 0;
+const base_1 = require("./base");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const crypto_1 = require("crypto");
+const lock_1 = require("../utils/lock");
+const manager_1 = require("../crypto/manager");
+class BinaryStorage extends base_1.BaseStorage {
+    data = [];
+    locker = new lock_1.FileLocker();
+    crypto;
+    filePath;
+    lockPath;
+    MAGIC = "LMCS";
+    VERSION = 1;
+    constructor(config) {
+        super(config);
+        this.filePath = this.getFilePath("bin");
+        this.lockPath = `${config.dbPath}/${config.dbName}.bin.lock`;
+        if (config.encryptionKey) {
+            this.crypto = new manager_1.CryptoManager(config.encryptionKey);
+        }
+    }
+    async initialize() {
+        await (0, promises_1.mkdir)((0, path_1.dirname)(this.filePath), { recursive: true });
+        try {
+            await (0, promises_1.access)(this.filePath);
+            const buffer = await (0, promises_1.readFile)(this.filePath);
+            if (buffer.length > 0) {
+                const payload = this.deserialize(buffer);
+                this.data = payload;
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT")
+                throw err;
+        }
+    }
+    async append(entry) {
+        this.data.push(entry);
+        // Binary always does full rewrite (not append-only)
+        await this.flush();
+    }
+    async readAll() {
+        return [...this.data];
+    }
+    async *readStream() {
+        for (const entry of this.data) {
+            yield entry;
+        }
+    }
+    async flush() {
+        await this.locker.withLock(this.lockPath, async () => {
+            const buffer = this.serialize(this.data);
+            await (0, promises_1.writeFile)(this.filePath, buffer);
+        });
+    }
+    async close() {
+        await this.flush();
+        this.data = [];
+    }
+    async clear() {
+        this.data = [];
+        await this.flush();
+    }
+    async compact() {
+        // Binary storage rewrites on every append, so it's always compact
+        return Promise.resolve();
+    }
+    serialize(entries) {
+        const jsonStr = JSON.stringify(entries);
+        const compressed = Buffer.from(jsonStr); // Placeholder for compression
+        const header = {
+            magic: this.MAGIC,
+            version: this.VERSION,
+            checksum: (0, crypto_1.createHash)("sha256").update(compressed).digest("hex"),
+            encrypted: !!this.crypto,
+        };
+        let payload = compressed;
+        if (this.crypto) {
+            const encrypted = this.crypto.encrypt(jsonStr);
+            payload = Buffer.from(JSON.stringify(encrypted));
+        }
+        const headerBuf = Buffer.from(JSON.stringify(header));
+        const headerLen = Buffer.alloc(4);
+        headerLen.writeUInt32BE(headerBuf.length);
+        const payloadLen = Buffer.alloc(4);
+        payloadLen.writeUInt32BE(payload.length);
+        return Buffer.concat([headerLen, headerBuf, payloadLen, payload]);
+    }
+    deserialize(buffer) {
+        try {
+            let offset = 0;
+            const headerLen = buffer.readUInt32BE(offset);
+            offset += 4;
+            const headerBuf = buffer.slice(offset, offset + headerLen);
+            offset += headerLen;
+            const header = JSON.parse(headerBuf.toString());
+            if (header.magic !== this.MAGIC)
+                throw new Error("Invalid file format");
+            const payloadLen = buffer.readUInt32BE(offset);
+            offset += 4;
+            const payload = buffer.slice(offset, offset + payloadLen);
+            let jsonStr;
+            if (header.encrypted) {
+                if (!this.crypto)
+                    throw new Error("File is encrypted but no key provided");
+                const encrypted = JSON.parse(payload.toString());
+                jsonStr = this.crypto.decrypt(encrypted);
+            }
+            else {
+                jsonStr = payload.toString();
+            }
+            return JSON.parse(jsonStr);
+        }
+        catch (error) {
+            console.error("Failed to deserialize binary storage:", error);
+            return [];
+        }
+    }
+}
+exports.BinaryStorage = BinaryStorage;

package/dist/storage/index.d.ts

@@ -0,0 +1,5 @@
+export { BaseStorage, IStorage, LogEntry, StorageConfig } from './base';
+export { MemoryStorage } from './memory';
+export { JSONStorage } from './json';
+export { AOLStorage } from './aol';
+export { BinaryStorage } from './binary';

package/dist/storage/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BinaryStorage = exports.AOLStorage = exports.JSONStorage = exports.MemoryStorage = exports.BaseStorage = void 0;
+var base_1 = require("./base");
+Object.defineProperty(exports, "BaseStorage", { enumerable: true, get: function () { return base_1.BaseStorage; } });
+var memory_1 = require("./memory");
+Object.defineProperty(exports, "MemoryStorage", { enumerable: true, get: function () { return memory_1.MemoryStorage; } });
+var json_1 = require("./json");
+Object.defineProperty(exports, "JSONStorage", { enumerable: true, get: function () { return json_1.JSONStorage; } });
+var aol_1 = require("./aol");
+Object.defineProperty(exports, "AOLStorage", { enumerable: true, get: function () { return aol_1.AOLStorage; } });
+var binary_1 = require("./binary");
+Object.defineProperty(exports, "BinaryStorage", { enumerable: true, get: function () { return binary_1.BinaryStorage; } });

package/dist/storage/json.d.ts

@@ -0,0 +1,18 @@
+import { BaseStorage, LogEntry, StorageConfig } from "./base";
+export declare class JSONStorage extends BaseStorage {
+    private autosaveInterval;
+    private cache;
+    private crypto?;
+    private locker;
+    private dirty;
+    private autosaveTimer?;
+    private isInitialized;
+    constructor(config: StorageConfig, autosaveInterval?: number);
+    initialize(): Promise<void>;
+    append(entry: LogEntry): Promise<void>;
+    readStream(): AsyncGenerator<LogEntry>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    compact(): Promise<void>;
+    clear?(): Promise<void>;
+}

package/dist/storage/json.js

@@ -0,0 +1,153 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONStorage = void 0;
+const base_1 = require("./base");
+const manager_1 = require("../crypto/manager");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const lock_1 = require("../utils/lock");
+class JSONStorage extends base_1.BaseStorage {
+    autosaveInterval;
+    cache = [];
+    crypto;
+    locker = new lock_1.FileLocker();
+    dirty = false;
+    autosaveTimer;
+    isInitialized = false;
+    constructor(config, autosaveInterval = 5000) {
+        super(config);
+        this.autosaveInterval = autosaveInterval;
+        if (config.encryptionKey) {
+            this.crypto = new manager_1.CryptoManager(config.encryptionKey);
+        }
+    }
+    async initialize() {
+        const filePath = this.getFilePath("json");
+        await (0, promises_1.mkdir)((0, path_1.dirname)(filePath), { recursive: true });
+        try {
+            await (0, promises_1.access)(filePath);
+            const content = await (0, promises_1.readFile)(filePath, "utf8");
+            if (content.trim()) {
+                let jsonContent;
+                if (this.crypto) {
+                    const encrypted = JSON.parse(content);
+                    jsonContent = this.crypto.decrypt(encrypted);
+                }
+                else {
+                    jsonContent = content;
+                }
+                this.cache = JSON.parse(jsonContent);
+            }
+        }
+        catch (err) {
+            if (err.code !== "ENOENT") {
+                // Se falhar na descriptografia, limpa (chave errada)
+                console.warn("Failed to load existing data, starting fresh");
+                this.cache = [];
+            }
+        }
+        // Autosave
+        if (this.autosaveInterval > 0) {
+            this.autosaveTimer = setInterval(() => {
+                if (this.dirty)
+                    this.flush().catch(console.error);
+            }, this.autosaveInterval);
+        }
+        this.isInitialized = true;
+    }
+    async append(entry) {
+        if (!this.isInitialized)
+            throw new Error("Storage not initialized");
+        // Calcula checksum se necessário
+        if (this.config.enableChecksums) {
+            const { createHash } = await Promise.resolve().then(() => __importStar(require("crypto")));
+            entry.checksum = createHash("sha256")
+                .update(JSON.stringify({ ...entry, checksum: "" }))
+                .digest("hex");
+        }
+        this.cache.push(entry);
+        this.dirty = true;
+    }
+    async *readStream() {
+        for (const entry of this.cache) {
+            yield entry;
+        }
+    }
+    async flush() {
+        if (!this.dirty || !this.isInitialized)
+            return;
+        const filePath = this.getFilePath("json");
+        const lockPath = `${filePath}.lock`;
+        await this.locker.withLock(lockPath, async () => {
+            const content = JSON.stringify(this.cache, null, 2);
+            if (this.crypto) {
+                const encrypted = this.crypto.encrypt(content);
+                await (0, promises_1.writeFile)(filePath, JSON.stringify(encrypted), "utf8");
+            }
+            else {
+                await (0, promises_1.writeFile)(filePath, content, "utf8");
+            }
+            this.dirty = false;
+        });
+    }
+    async close() {
+        if (this.autosaveTimer)
+            clearInterval(this.autosaveTimer);
+        await this.flush();
+        this.cache = [];
+        this.isInitialized = false;
+    }
+    async compact() {
+        // Remove duplicados (mantém último estado)
+        const seen = new Map();
+        for (const entry of this.cache) {
+            const key = `${entry.collection}:${entry.id}`;
+            if (entry.op === "DELETE") {
+                seen.delete(key);
+            }
+            else {
+                seen.set(key, entry);
+            }
+        }
+        this.cache = Array.from(seen.values());
+        this.dirty = true;
+        await this.flush();
+    }
+    clear() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.JSONStorage = JSONStorage;

package/dist/storage/memory.d.ts

@@ -0,0 +1,14 @@
+import { BaseStorage, LogEntry, StorageConfig } from "./base";
+export declare class MemoryStorage extends BaseStorage {
+    private logs;
+    private isInitialized;
+    constructor(config: StorageConfig);
+    initialize(): Promise<void>;
+    append(entry: LogEntry): Promise<void>;
+    readStream(): AsyncGenerator<LogEntry>;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+    clear(): Promise<void>;
+    getSize(): number;
+    compact?(): Promise<void>;
+}

package/dist/storage/memory.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+const base_1 = require("./base");
+class MemoryStorage extends base_1.BaseStorage {
+    logs = [];
+    isInitialized = false;
+    constructor(config) {
+        super(config);
+    }
+    async initialize() {
+        this.isInitialized = true;
+        this.logs = [];
+    }
+    async append(entry) {
+        if (!this.isInitialized)
+            throw new Error("Storage not initialized");
+        this.logs.push({ ...entry });
+    }
+    async *readStream() {
+        for (const entry of this.logs) {
+            yield entry;
+        }
+    }
+    async flush() {
+        // Nada a fazer em memória
+    }
+    async close() {
+        this.logs = [];
+        this.isInitialized = false;
+    }
+    async clear() {
+        this.logs = [];
+    }
+    getSize() {
+        return this.logs.length;
+    }
+    compact() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MemoryStorage = MemoryStorage;

package/dist/utils/checksum.js

@@ -0,0 +1 @@
+"use strict";

package/dist/utils/errors.d.ts

@@ -0,0 +1,16 @@
+export declare class LMCSError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class ValidationError extends LMCSError {
+    constructor(message: string);
+}
+export declare class CorruptionError extends LMCSError {
+    constructor(message: string);
+}
+export declare class ConcurrencyError extends LMCSError {
+    constructor(message: string);
+}
+export declare class TransactionError extends LMCSError {
+    constructor(message: string);
+}

package/dist/utils/errors.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionError = exports.ConcurrencyError = exports.CorruptionError = exports.ValidationError = exports.LMCSError = void 0;
+class LMCSError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}
+exports.LMCSError = LMCSError;
+class ValidationError extends LMCSError {
+    constructor(message) {
+        super(message, 'VALIDATION_ERROR');
+    }
+}
+exports.ValidationError = ValidationError;
+class CorruptionError extends LMCSError {
+    constructor(message) {
+        super(message, 'DATA_CORRUPTION');
+    }
+}
+exports.CorruptionError = CorruptionError;
+class ConcurrencyError extends LMCSError {
+    constructor(message) {
+        super(message, 'CONCURRENCY_ERROR');
+    }
+}
+exports.ConcurrencyError = ConcurrencyError;
+class TransactionError extends LMCSError {
+    constructor(message) {
+        super(message, 'TRANSACTION_ERROR');
+    }
+}
+exports.TransactionError = TransactionError;

package/dist/utils/lock.d.ts

@@ -0,0 +1,9 @@
+export declare class FileLocker {
+    private locks;
+    private queues;
+    acquire(filePath: string, options?: {
+        retries?: number;
+    }): Promise<void>;
+    release(filePath: string): Promise<void>;
+    withLock<T>(filePath: string, fn: () => Promise<T>): Promise<T>;
+}