lmcs-db 1.0.4 → 2.0.0

package/dist/core/database.d.ts

@@ -0,0 +1,35 @@
+import { Collection } from './collection';
+import { TransactionContext } from './transaction-context';
+export type StorageType = 'memory' | 'json' | 'aol' | 'binary';
+export interface DatabaseOptions {
+    storageType: StorageType;
+    databaseName: string;
+    encryptionKey?: string;
+    customPath?: string;
+    compactionInterval?: number;
+    bufferSize?: number;
+    autosaveInterval?: number;
+    enableChecksums?: boolean;
+}
+export declare class Database {
+    private options;
+    private storage;
+    private collections;
+    private locker;
+    private lockPath;
+    private initialized;
+    private txManager?;
+    private txLock;
+    constructor(options: DatabaseOptions);
+    initialize(): Promise<void>;
+    collection<T extends Record<string, any>>(name: string): Collection<T>;
+    transaction<T>(fn: (trx: TransactionContext) => Promise<T>): Promise<T>;
+    save(): Promise<void>;
+    compact(): Promise<void>;
+    close(): Promise<void>;
+    get stats(): {
+        collections: number;
+        storage: StorageType;
+    };
+}
+export declare function createDatabase(options: DatabaseOptions): Promise<Database>;

package/dist/core/database.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Database = void 0;
+exports.createDatabase = createDatabase;
+const path_1 = require("path");
+const promises_1 = require("fs/promises");
+const storage_1 = require("../storage");
+const collection_1 = require("./collection");
+const transaction_1 = require("./transaction");
+const transaction_context_1 = require("./transaction-context");
+const lock_1 = require("../utils/lock");
+class Database {
+    options;
+    storage;
+    collections = new Map();
+    locker;
+    lockPath;
+    initialized = false;
+    txManager;
+    txLock = Promise.resolve();
+    constructor(options) {
+        this.options = options;
+        const basePath = options.customPath || './data';
+        const config = {
+            dbPath: basePath,
+            dbName: options.databaseName,
+            encryptionKey: options.encryptionKey,
+            enableChecksums: options.enableChecksums ?? false
+        };
+        // Factory switch
+        switch (options.storageType) {
+            case 'memory':
+                this.storage = new storage_1.MemoryStorage(config);
+                break;
+            case 'json':
+                this.storage = new storage_1.JSONStorage(config, options.autosaveInterval);
+                break;
+            case 'aol':
+                this.storage = new storage_1.AOLStorage({
+                    ...config,
+                    compactionInterval: options.compactionInterval,
+                    bufferSize: options.bufferSize
+                });
+                break;
+            case 'binary':
+                this.storage = new storage_1.BinaryStorage(config);
+                break;
+            default:
+                throw new Error(`Unknown storage type: ${options.storageType}`);
+        }
+        this.lockPath = (0, path_1.join)(basePath, `${options.databaseName}.lock`);
+        this.locker = new lock_1.FileLocker();
+        // Enable transactions by default or if configured
+        this.txManager = new transaction_1.TransactionManager(this.storage);
+    }
+    async initialize() {
+        if (this.initialized)
+            return;
+        const lockDir = (0, path_1.dirname)(this.lockPath);
+        await (0, promises_1.mkdir)(lockDir, { recursive: true });
+        try {
+            await (0, promises_1.access)(this.lockPath);
+        }
+        catch {
+            await (0, promises_1.writeFile)(this.lockPath, '', 'utf8');
+        }
+        await this.locker.acquire(this.lockPath);
+        await this.storage.initialize();
+        if (this.txManager) {
+            await this.txManager.recover();
+        }
+        this.initialized = true;
+    }
+    collection(name) {
+        if (!this.initialized)
+            throw new Error('Database not initialized');
+        if (!this.collections.has(name)) {
+            this.collections.set(name, new collection_1.Collection(name, this.storage));
+        }
+        return this.collections.get(name);
+    }
+    async transaction(fn) {
+        // Acquire lock for transaction serialization
+        let releaseLock;
+        const acquire = new Promise(resolve => releaseLock = resolve);
+        const currentLock = this.txLock;
+        this.txLock = this.txLock.then(() => acquire);
+        await currentLock;
+        try {
+            if (!this.txManager) {
+                throw new Error('Transactions not enabled');
+            }
+            const txId = await this.txManager.begin();
+            const context = new transaction_context_1.TransactionContext(txId, this.txManager, this.storage, async (col, id) => {
+                return this.collection(col).findOne({ _id: id });
+            });
+            try {
+                const result = await fn(context);
+                const ops = await this.txManager.commit(txId);
+                // Update in-memory state
+                for (const op of ops) {
+                    const collection = this.collections.get(op.collection);
+                    if (collection) {
+                        let logOp;
+                        switch (op.type) {
+                            case 'insert':
+                                logOp = 'INSERT';
+                                break;
+                            case 'update':
+                                logOp = 'UPDATE';
+                                break;
+                            case 'delete':
+                                logOp = 'DELETE';
+                                break;
+                            default: continue;
+                        }
+                        collection.applyLogEntry({
+                            op: logOp,
+                            collection: op.collection,
+                            id: op.id,
+                            data: op.newData,
+                            checksum: '',
+                            timestamp: Date.now(),
+                            txId
+                        });
+                    }
+                }
+                return result;
+            }
+            catch (error) {
+                await this.txManager.rollback(txId);
+                throw error;
+            }
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    async save() {
+        await this.storage.flush();
+    }
+    async compact() {
+        if (this.storage.compact) {
+            await this.storage.compact();
+        }
+    }
+    async close() {
+        await this.storage.close();
+        await this.locker.release(this.lockPath);
+        this.initialized = false;
+    }
+    get stats() {
+        return {
+            collections: this.collections.size,
+            storage: this.options.storageType
+        };
+    }
+}
+exports.Database = Database;
+// Factory function para conveniência
+async function createDatabase(options) {
+    const db = new Database(options);
+    await db.initialize();
+    return db;
+}

package/dist/core/indexer.d.ts

@@ -0,0 +1,20 @@
+export interface IndexDefinition {
+    fields: string[];
+    unique: boolean;
+    sparse: boolean;
+    name: string;
+}
+export declare class IndexManager {
+    private indexes;
+    private indexDefs;
+    createIndex(collection: string, fields: string | string[], options?: {
+        unique?: boolean;
+        sparse?: boolean;
+    }): void;
+    indexDocument(collection: string, id: string, doc: Record<string, any>): void;
+    removeDocument(collection: string, id: string, doc: Record<string, any>): void;
+    queryByIndex(collection: string, filter: Record<string, any>): Set<string> | null;
+    private extractKeyValue;
+    private getNestedValue;
+    getIndexDefinitions(collection: string): IndexDefinition[];
+}

package/dist/core/indexer.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexManager = void 0;
+class IndexManager {
+    indexes = new Map();
+    indexDefs = new Map();
+    createIndex(collection, fields, options) {
+        const fieldArray = Array.isArray(fields) ? fields : [fields];
+        const key = fieldArray.join(':');
+        if (!this.indexes.has(collection)) {
+            this.indexes.set(collection, new Map());
+            this.indexDefs.set(collection, []);
+        }
+        const colIndexes = this.indexes.get(collection);
+        if (colIndexes.has(key)) {
+            throw new Error(`Index already exists on ${key}`);
+        }
+        colIndexes.set(key, new Map());
+        this.indexDefs.get(collection).push({
+            fields: fieldArray,
+            unique: options?.unique ?? false,
+            sparse: options?.sparse ?? false,
+            name: key
+        });
+    }
+    indexDocument(collection, id, doc) {
+        const colIndexes = this.indexes.get(collection);
+        if (!colIndexes)
+            return;
+        for (const [key, indexMap] of colIndexes) {
+            const value = this.extractKeyValue(doc, key);
+            if (value === undefined)
+                continue;
+            const valueKey = JSON.stringify(value);
+            if (!indexMap.has(valueKey)) {
+                indexMap.set(valueKey, new Set());
+            }
+            indexMap.get(valueKey).add(id);
+        }
+    }
+    removeDocument(collection, id, doc) {
+        const colIndexes = this.indexes.get(collection);
+        if (!colIndexes)
+            return;
+        for (const [key, indexMap] of colIndexes) {
+            const value = this.extractKeyValue(doc, key);
+            if (value === undefined)
+                continue;
+            const valueKey = JSON.stringify(value);
+            const set = indexMap.get(valueKey);
+            if (set) {
+                set.delete(id);
+                if (set.size === 0)
+                    indexMap.delete(valueKey);
+            }
+        }
+    }
+    queryByIndex(collection, filter) {
+        const colIndexes = this.indexes.get(collection);
+        if (!colIndexes)
+            return null;
+        const candidates = [];
+        for (const [key, indexMap] of colIndexes) {
+            const filterValue = this.extractKeyValue(filter, key);
+            if (filterValue !== undefined) {
+                const result = indexMap.get(JSON.stringify(filterValue));
+                if (result && result.size > 0)
+                    candidates.push(new Set(result));
+            }
+        }
+        if (candidates.length === 0)
+            return null;
+        if (candidates.length === 1)
+            return candidates[0];
+        return candidates.reduce((a, b) => new Set([...a].filter(x => b.has(x))));
+    }
+    extractKeyValue(doc, key) {
+        const fields = key.split(':');
+        const values = fields.map(f => this.getNestedValue(doc, f));
+        return fields.length === 1 ? values[0] : values;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((o, p) => o?.[p], obj);
+    }
+    getIndexDefinitions(collection) {
+        return this.indexDefs.get(collection) || [];
+    }
+}
+exports.IndexManager = IndexManager;

package/dist/core/transaction-context.d.ts

@@ -0,0 +1,13 @@
+import { IStorage } from '../storage/base';
+import { TransactionManager } from './transaction';
+export declare class TransactionContext {
+    private txId;
+    private txManager;
+    private storage;
+    private getData;
+    constructor(txId: string, txManager: TransactionManager, storage: IStorage, getData: (collection: string, id: string) => Promise<any>);
+    get id(): string;
+    insert(collection: string, data: any): Promise<void>;
+    update(collection: string, id: string, data: any): Promise<void>;
+    delete(collection: string, id: string): Promise<void>;
+}

package/dist/core/transaction-context.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionContext = void 0;
+const uuid_1 = require("uuid");
+class TransactionContext {
+    txId;
+    txManager;
+    storage;
+    getData;
+    constructor(txId, txManager, storage, getData) {
+        this.txId = txId;
+        this.txManager = txManager;
+        this.storage = storage;
+        this.getData = getData;
+    }
+    get id() {
+        return this.txId;
+    }
+    async insert(collection, data) {
+        await this.txManager.addOperation(this.txId, {
+            type: 'insert',
+            collection,
+            id: data._id || (0, uuid_1.v7)(),
+            newData: data
+        });
+    }
+    async update(collection, id, data) {
+        const current = await this.getData(collection, id);
+        if (!current) {
+            throw new Error(`Document with id ${id} not found in collection ${collection}`);
+        }
+        const newData = { ...current, ...data };
+        await this.txManager.addOperation(this.txId, {
+            type: 'update',
+            collection,
+            id,
+            newData: newData
+        });
+    }
+    async delete(collection, id) {
+        await this.txManager.addOperation(this.txId, {
+            type: 'delete',
+            collection,
+            id
+        });
+    }
+}
+exports.TransactionContext = TransactionContext;

package/dist/core/transaction.d.ts

@@ -0,0 +1,25 @@
+import { IStorage } from '../storage/base';
+export interface Transaction {
+    id: string;
+    operations: Operation[];
+    status: 'pending' | 'committed' | 'aborted';
+    timestamp: number;
+}
+export interface Operation {
+    type: 'insert' | 'update' | 'delete';
+    collection: string;
+    id: string;
+    previousData?: unknown;
+    newData?: unknown;
+}
+export declare class TransactionManager {
+    private activeTransactions;
+    private storage;
+    constructor(storage: IStorage);
+    begin(): Promise<string>;
+    addOperation(txId: string, op: Operation): Promise<void>;
+    commit(txId: string): Promise<Operation[]>;
+    rollback(txId: string): Promise<void>;
+    getTransaction(txId: string): Transaction | undefined;
+    recover(): Promise<void>;
+}

package/dist/core/transaction.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionManager = void 0;
+const errors_1 = require("../utils/errors");
+const uuid_1 = require("uuid");
+class TransactionManager {
+    activeTransactions = new Map();
+    storage;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    async begin() {
+        const txId = (0, uuid_1.v4)();
+        const tx = {
+            id: txId,
+            operations: [],
+            status: 'pending',
+            timestamp: Date.now()
+        };
+        this.activeTransactions.set(txId, tx);
+        await this.storage.append({
+            op: 'BEGIN',
+            collection: '_transactions',
+            id: txId,
+            checksum: '',
+            timestamp: tx.timestamp,
+            txId
+        });
+        return txId;
+    }
+    async addOperation(txId, op) {
+        const tx = this.activeTransactions.get(txId);
+        if (!tx)
+            throw new errors_1.TransactionError('Transaction not found');
+        if (tx.status !== 'pending')
+            throw new errors_1.TransactionError('Transaction already finalized');
+        tx.operations.push(op);
+    }
+    async commit(txId) {
+        const tx = this.activeTransactions.get(txId);
+        if (!tx)
+            throw new errors_1.TransactionError('Transaction not found');
+        // Apply operations to storage
+        for (const op of tx.operations) {
+            let storageOp;
+            switch (op.type) {
+                case 'insert':
+                    storageOp = 'INSERT';
+                    break;
+                case 'update':
+                    storageOp = 'UPDATE';
+                    break;
+                case 'delete':
+                    storageOp = 'DELETE';
+                    break;
+                default: continue;
+            }
+            await this.storage.append({
+                op: storageOp,
+                collection: op.collection,
+                id: op.id,
+                data: op.newData || {},
+                checksum: '',
+                timestamp: Date.now(),
+                txId: txId
+            });
+        }
+        await this.storage.append({
+            op: 'COMMIT',
+            collection: '_transactions',
+            id: txId,
+            checksum: '',
+            timestamp: Date.now(),
+            txId
+        });
+        const operations = [...tx.operations];
+        tx.status = 'committed';
+        this.activeTransactions.delete(txId);
+        return operations;
+    }
+    async rollback(txId) {
+        const tx = this.activeTransactions.get(txId);
+        if (!tx)
+            return;
+        await this.storage.append({
+            op: 'ROLLBACK',
+            collection: '_transactions',
+            id: txId,
+            checksum: '',
+            timestamp: Date.now(),
+            txId
+        });
+        tx.status = 'aborted';
+        this.activeTransactions.delete(txId);
+    }
+    getTransaction(txId) {
+        return this.activeTransactions.get(txId);
+    }
+    async recover() {
+        const pendingTxs = new Map();
+        for await (const entry of this.storage.readStream()) {
+            if (entry.collection !== '_transactions')
+                continue;
+            if (entry.op === 'BEGIN') {
+                pendingTxs.set(entry.id, {
+                    id: entry.id,
+                    operations: [],
+                    status: 'pending',
+                    timestamp: entry.timestamp
+                });
+            }
+            else if (entry.op === 'COMMIT' || entry.op === 'ROLLBACK') {
+                pendingTxs.delete(entry.id);
+            }
+        }
+        for (const [txId, tx] of pendingTxs) {
+            console.log(`Recovering incomplete transaction ${txId}`);
+            await this.rollback(txId);
+        }
+    }
+}
+exports.TransactionManager = TransactionManager;

package/dist/crypto/key-derivation.js

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

package/dist/crypto/manager.d.ts

@@ -0,0 +1,22 @@
+export interface EncryptedData {
+    data: string;
+    iv: string;
+    tag: string;
+    salt: string;
+    version: number;
+}
+export declare class CryptoManager {
+    private masterKey?;
+    private password?;
+    private _salt?;
+    private static readonly ALGORITHM;
+    private static readonly ITERATIONS;
+    private static readonly KEYLEN;
+    private static readonly VERSION;
+    constructor(password?: string);
+    private deriveKey;
+    encrypt(text: string): EncryptedData;
+    decrypt(encrypted: EncryptedData): string;
+    validateKey(testData?: EncryptedData): Promise<boolean>;
+    static hash(data: string): string;
+}

package/dist/crypto/manager.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CryptoManager = void 0;
+const crypto_1 = require("crypto");
+class CryptoManager {
+    masterKey;
+    password;
+    _salt;
+    static ALGORITHM = 'aes-256-gcm';
+    static ITERATIONS = 100000;
+    static KEYLEN = 32;
+    static VERSION = 1;
+    constructor(password) {
+        if (password) {
+            this.password = password;
+            // Derivação inicial - salt aleatório gerado aqui
+            const salt = (0, crypto_1.randomBytes)(32);
+            this.masterKey = this.deriveKey(password, salt);
+            this._salt = salt.toString('hex'); // Guarda para referência
+        }
+    }
+    deriveKey(password, salt) {
+        return (0, crypto_1.pbkdf2Sync)(password, salt, CryptoManager.ITERATIONS, CryptoManager.KEYLEN, 'sha256');
+    }
+    encrypt(text) {
+        if (!this.masterKey)
+            throw new Error('CryptoManager not initialized with password');
+        const iv = (0, crypto_1.randomBytes)(16);
+        const cipher = (0, crypto_1.createCipheriv)(CryptoManager.ALGORITHM, this.masterKey, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return {
+            data: encrypted,
+            iv: iv.toString('hex'),
+            tag: cipher.getAuthTag().toString('hex'),
+            salt: this._salt,
+            version: CryptoManager.VERSION
+        };
+    }
+    decrypt(encrypted) {
+        if (!this.masterKey && !this.password)
+            throw new Error('CryptoManager not initialized with password');
+        let key = this.masterKey;
+        // Se o salt do dado for diferente do atual, e temos a senha, re-derivamos a chave
+        if (encrypted.salt && this._salt && encrypted.salt !== this._salt && this.password) {
+            key = this.deriveKey(this.password, Buffer.from(encrypted.salt, 'hex'));
+        }
+        else if (!key && this.password && encrypted.salt) {
+            // Caso onde só temos senha mas não inicializamos chave padrão (não deve ocorrer pelo construtor, mas por segurança)
+            key = this.deriveKey(this.password, Buffer.from(encrypted.salt, 'hex'));
+        }
+        if (!key)
+            throw new Error('Cannot decrypt: missing key or password');
+        const decipher = (0, crypto_1.createDecipheriv)(CryptoManager.ALGORITHM, key, Buffer.from(encrypted.iv, 'hex'));
+        decipher.setAuthTag(Buffer.from(encrypted.tag, 'hex'));
+        let decrypted = decipher.update(encrypted.data, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+    }
+    // Valida se a chave fornecida pode descriptografar os dados existentes
+    async validateKey(testData) {
+        if (!this.masterKey || !testData)
+            return false;
+        try {
+            this.decrypt(testData);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    static hash(data) {
+        return (0, crypto_1.createHash)('sha256').update(data).digest('hex');
+    }
+}
+exports.CryptoManager = CryptoManager;

package/dist/crypto/vault.d.ts

@@ -0,0 +1,18 @@
+export interface EncryptedPayload {
+    ciphertext: string;
+    iv: string;
+    authTag: string;
+    salt: string;
+    iterations: number;
+    version: number;
+}
+export declare class CryptoVault {
+    private derivedKey;
+    private readonly ALGORITHM;
+    private readonly VERSION;
+    private readonly ITERATIONS;
+    private salt;
+    constructor(password: string, existingSalt?: string);
+    encrypt(data: string): EncryptedPayload;
+    decrypt(payload: EncryptedPayload): string;
+}