lmcs-db 1.0.4 → 2.0.0

package/dist/crypto/vault.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoVault = void 0;
+const crypto_1 = require("crypto");
+class CryptoVault {
+    derivedKey;
+    ALGORITHM = 'aes-256-gcm';
+    VERSION = 1;
+    ITERATIONS = 100000;
+    salt;
+    constructor(password, existingSalt) {
+        if (!password || typeof password !== 'string') {
+            throw new Error('Password must be a non-empty string');
+        }
+        const saltBuffer = existingSalt
+            ? Buffer.from(existingSalt, 'hex')
+            : (0, crypto_1.randomBytes)(32);
+        this.salt = saltBuffer.toString('hex');
+        this.derivedKey = (0, crypto_1.pbkdf2Sync)(password, saltBuffer, this.ITERATIONS, 32, 'sha256');
+    }
+    encrypt(data) {
+        const iv = (0, crypto_1.randomBytes)(16);
+        const cipher = (0, crypto_1.createCipheriv)(this.ALGORITHM, this.derivedKey, iv);
+        let ciphertext = cipher.update(data, 'utf8', 'hex');
+        ciphertext += cipher.final('hex');
+        return {
+            ciphertext,
+            iv: iv.toString('hex'),
+            authTag: cipher.getAuthTag().toString('hex'),
+            salt: this.salt,
+            iterations: this.ITERATIONS,
+            version: this.VERSION
+        };
+    }
+    decrypt(payload) {
+        const key = (0, crypto_1.pbkdf2Sync)(this.derivedKey.toString('hex'), Buffer.from(payload.salt, 'hex'), payload.iterations, 32, 'sha256');
+        const decipher = (0, crypto_1.createDecipheriv)(this.ALGORITHM, key, Buffer.from(payload.iv, 'hex'));
+        decipher.setAuthTag(Buffer.from(payload.authTag, 'hex'));
+        let decrypted = decipher.update(payload.ciphertext, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+}
+exports.CryptoVault = CryptoVault;

package/dist/index.d.ts

@@ -1,2 +1,5 @@
-export { default as DatabaseFactory } from './DatabaseFactory';
-export { DatabaseStorageType } from './interfaces';
+export { Database, createDatabase, DatabaseOptions, StorageType } from './core/database';
+export { Collection, QueryOptions } from './core/collection';
+export { CryptoManager, EncryptedData } from './crypto/manager';
+export { AOLStorage } from './storage/aol';
+export { BinaryStorage } from './storage/binary';

package/dist/index.js

@@ -1,11 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseStorageType = exports.DatabaseFactory = void 0;
-var DatabaseFactory_1 = require("./DatabaseFactory");
-Object.defineProperty(exports, "DatabaseFactory", { enumerable: true, get: function () { return __importDefault(DatabaseFactory_1).default; } });
-var interfaces_1 = require("./interfaces");
-Object.defineProperty(exports, "DatabaseStorageType", { enumerable: true, get: function () { return interfaces_1.DatabaseStorageType; } });
-//# sourceMappingURL=index.js.map
+exports.BinaryStorage = exports.AOLStorage = exports.CryptoManager = exports.Collection = exports.createDatabase = exports.Database = void 0;
+var database_1 = require("./core/database");
+Object.defineProperty(exports, "Database", { enumerable: true, get: function () { return database_1.Database; } });
+Object.defineProperty(exports, "createDatabase", { enumerable: true, get: function () { return database_1.createDatabase; } });
+var collection_1 = require("./core/collection");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return collection_1.Collection; } });
+var manager_1 = require("./crypto/manager");
+Object.defineProperty(exports, "CryptoManager", { enumerable: true, get: function () { return manager_1.CryptoManager; } });
+var aol_1 = require("./storage/aol");
+Object.defineProperty(exports, "AOLStorage", { enumerable: true, get: function () { return aol_1.AOLStorage; } });
+var binary_1 = require("./storage/binary");
+Object.defineProperty(exports, "BinaryStorage", { enumerable: true, get: function () { return binary_1.BinaryStorage; } });

package/dist/persistence/AsyncWriteWorker.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 class AsyncWriteWorker {
+    writing = false;
+    pendingPayload;
+    resolveIdle;
+    writeFn;
+    enqueuedCount = 0;
+    writesCount = 0;
+    lastDurationMs = 0;
+    lastBytes = 0;
+    totalBytes = 0;
+    lastStartedAt;
+    lastFinishedAt;
     constructor(writeFn) {
-        this.writing = false;
-        this.enqueuedCount = 0;
-        this.writesCount = 0;
-        this.lastDurationMs = 0;
-        this.lastBytes = 0;
-        this.totalBytes = 0;
         this.writeFn = writeFn;
     }
     enqueue(data) {
@@ -69,4 +74,3 @@ class AsyncWriteWorker {
     }
 }
 exports.default = AsyncWriteWorker;
-//# sourceMappingURL=AsyncWriteWorker.js.map

package/dist/storage/aol.d.ts

@@ -0,0 +1,26 @@
+import { BaseStorage, LogEntry, StorageConfig } from "./base";
+export declare class AOLStorage extends BaseStorage {
+    private buffer;
+    private crypto?;
+    private locker;
+    private bufferSize;
+    private compactionTimer?;
+    private isInitialized;
+    private writeCount;
+    constructor(config: StorageConfig & {
+        compactionInterval?: number;
+        bufferSize?: number;
+    });
+    initialize(): Promise<void>;
+    append(entry: LogEntry): Promise<void>;
+    flush(): Promise<void>;
+    readStream(): AsyncGenerator<LogEntry>;
+    compact(): Promise<void>;
+    close(): Promise<void>;
+    getStats(): {
+        buffered: number;
+        totalWrites: number;
+    };
+    clear?(): Promise<void>;
+}
+export { LogEntry };

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>;
+}