lmcs-db 1.0.3 → 2.0.0

package/dist/core/collection.js

@@ -0,0 +1,287 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Collection = void 0;
+const manager_1 = require("../crypto/manager");
+const uuid_1 = require("uuid");
+class Collection {
+    name;
+    storage;
+    data = new Map();
+    indexes = new Map();
+    crypto = new manager_1.CryptoManager(); // Instância sem chave para hash apenas
+    constructor(name, storage) {
+        this.name = name;
+        this.storage = storage;
+        this.loadFromStorage().catch(console.error);
+    }
+    async loadFromStorage() {
+        try {
+            if (!this.storage.readStream) {
+                throw new Error("Storage does not support streaming");
+            }
+            const stream = this.storage.readStream();
+            for await (const entry of stream) {
+                this.applyLogEntry(entry);
+            }
+        }
+        catch (err) {
+            console.error(`Failed to load collection ${this.name}:`, err);
+        }
+    }
+    applyLogEntry(entry) {
+        if (entry.collection !== this.name)
+            return;
+        const id = entry.id;
+        switch (entry.op) {
+            case "INSERT":
+            case "UPDATE":
+                const existing = this.data.get(id);
+                if (existing) {
+                    this.removeFromIndexes(id, existing);
+                }
+                this.data.set(id, entry.data);
+                this.addToIndexes(id, entry.data);
+                break;
+            case "DELETE":
+                const old = this.data.get(id);
+                if (old) {
+                    this.removeFromIndexes(id, old);
+                }
+                this.data.delete(id);
+                break;
+        }
+    }
+    addToIndexes(id, doc) {
+        for (const [field, index] of this.indexes) {
+            const value = doc[field];
+            if (value !== undefined) {
+                if (!index.has(value))
+                    index.set(value, new Set());
+                index.get(value).add(id);
+            }
+        }
+    }
+    removeFromIndexes(id, doc) {
+        for (const [field, index] of this.indexes) {
+            const value = doc[field];
+            if (value !== undefined) {
+                index.get(value)?.delete(id);
+            }
+        }
+    }
+    async insert(doc) {
+        const id = doc._id || (0, uuid_1.v7)();
+        if (this.data.has(id)) {
+            throw new Error(`Document with id ${id} already exists`);
+        }
+        const fullDoc = { ...doc, _id: id };
+        await this.storage.append({
+            op: "INSERT",
+            collection: this.name,
+            id,
+            data: fullDoc,
+            checksum: "",
+            timestamp: Date.now(),
+        });
+        this.data.set(id, fullDoc);
+        this.addToIndexes(id, fullDoc);
+        return fullDoc;
+    }
+    async update(filter, updates) {
+        let count = 0;
+        for (const [id, doc] of this.data.entries()) {
+            if (this.matchesFilter(doc, filter)) {
+                const newDoc = { ...doc, ...updates, _id: id };
+                await this.storage.append({
+                    op: "UPDATE",
+                    collection: this.name,
+                    id,
+                    data: newDoc,
+                    checksum: "",
+                    timestamp: Date.now(),
+                });
+                this.removeFromIndexes(id, doc);
+                this.data.set(id, newDoc);
+                this.addToIndexes(id, newDoc);
+                count++;
+            }
+        }
+        return count;
+    }
+    async delete(filter) {
+        let count = 0;
+        const toDelete = [];
+        for (const [id, doc] of this.data.entries()) {
+            if (this.matchesFilter(doc, filter)) {
+                toDelete.push(id);
+            }
+        }
+        for (const id of toDelete) {
+            const doc = this.data.get(id);
+            await this.storage.append({
+                op: "DELETE",
+                collection: this.name,
+                id,
+                checksum: "",
+                timestamp: Date.now(),
+            });
+            this.removeFromIndexes(id, doc);
+            this.data.delete(id);
+            count++;
+        }
+        return count;
+    }
+    async findOne(filter) {
+        // Tenta usar índice primeiro
+        const indexedId = this.queryByIndex(filter);
+        if (indexedId) {
+            return this.data.get(indexedId) || null;
+        }
+        for (const doc of this.data.values()) {
+            if (this.matchesFilter(doc, filter))
+                return doc;
+        }
+        return null;
+    }
+    async findAll(options = {}) {
+        let results = Array.from(this.data.values());
+        if (options.filter) {
+            results = results.filter((d) => this.matchesFilter(d, options.filter));
+        }
+        if (options.sort) {
+            results.sort((a, b) => {
+                for (const [field, dir] of Object.entries(options.sort)) {
+                    const aVal = a[field];
+                    const bVal = b[field];
+                    if (aVal < bVal)
+                        return dir === 1 ? -1 : 1;
+                    if (aVal > bVal)
+                        return dir === 1 ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+        if (options.skip)
+            results = results.slice(options.skip);
+        if (options.limit)
+            results = results.slice(0, options.limit);
+        return results;
+    }
+    async *findStream(options = {}) {
+        if (options.sort) {
+            const all = await this.findAll(options);
+            for (const doc of all)
+                yield doc;
+            return;
+        }
+        let count = 0;
+        let skipped = 0;
+        for (const doc of this.data.values()) {
+            if (options.filter && !this.matchesFilter(doc, options.filter))
+                continue;
+            if (options.skip && skipped < options.skip) {
+                skipped++;
+                continue;
+            }
+            if (options.limit && count >= options.limit)
+                break;
+            yield doc;
+            count++;
+        }
+    }
+    createIndex(field) {
+        if (this.indexes.has(field))
+            return;
+        this.indexes.set(field, new Map());
+        // Indexa existentes
+        for (const [id, doc] of this.data.entries()) {
+            this.addToIndexes(id, doc);
+        }
+    }
+    matchesFilter(doc, filter) {
+        for (const [key, value] of Object.entries(filter)) {
+            if (key === "$or") {
+                if (!Array.isArray(value))
+                    return false;
+                if (!value.some((condition) => this.matchesFilter(doc, condition)))
+                    return false;
+                continue;
+            }
+            if (key === "$and") {
+                if (!Array.isArray(value))
+                    return false;
+                if (!value.every((condition) => this.matchesFilter(doc, condition)))
+                    return false;
+                continue;
+            }
+            // Handle dot notation for nested fields
+            const docValue = this.getNestedValue(doc, key);
+            if (typeof value === "object" && value !== null) {
+                // Handle operators like $gt, $lt, etc.
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case "$gt":
+                            if (!(docValue > opValue))
+                                return false;
+                            break;
+                        case "$gte":
+                            if (!(docValue >= opValue))
+                                return false;
+                            break;
+                        case "$lt":
+                            if (!(docValue < opValue))
+                                return false;
+                            break;
+                        case "$lte":
+                            if (!(docValue <= opValue))
+                                return false;
+                            break;
+                        case "$ne":
+                            if (docValue === opValue)
+                                return false;
+                            break;
+                        case "$in":
+                            if (!Array.isArray(opValue) || !opValue.includes(docValue))
+                                return false;
+                            break;
+                        case "$nin":
+                            if (Array.isArray(opValue) && opValue.includes(docValue))
+                                return false;
+                            break;
+                        default:
+                            // If it's not an operator, treat as equality check for object
+                            if (JSON.stringify(docValue) !== JSON.stringify(value))
+                                return false;
+                    }
+                }
+            }
+            else {
+                // Direct equality
+                if (docValue !== value)
+                    return false;
+            }
+        }
+        return true;
+    }
+    getNestedValue(obj, path) {
+        return path.split('.').reduce((o, p) => (o ? o[p] : undefined), obj);
+    }
+    queryByIndex(filter) {
+        const entries = Object.entries(filter);
+        if (entries.length !== 1)
+            return null;
+        const [field, value] = entries[0];
+        const index = this.indexes.get(field);
+        if (!index)
+            return null;
+        const ids = index.get(value);
+        if (ids && ids.size > 0) {
+            return Array.from(ids)[0];
+        }
+        return null;
+    }
+    count() {
+        return this.data.size;
+    }
+}
+exports.Collection = Collection;

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