lmcs-db 1.0.4 → 2.0.0

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

package/dist/utils/lock.js

@@ -0,0 +1,75 @@
+"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.FileLocker = void 0;
+const lockfile = __importStar(require("proper-lockfile"));
+class FileLocker {
+    locks = new Map();
+    queues = new Map();
+    async acquire(filePath, options) {
+        const release = await lockfile.lock(filePath, {
+            retries: options?.retries ?? 5,
+            stale: 5000,
+            realpath: false
+        });
+        this.locks.set(filePath, release);
+    }
+    async release(filePath) {
+        const release = this.locks.get(filePath);
+        if (release) {
+            await release();
+            this.locks.delete(filePath);
+        }
+    }
+    async withLock(filePath, fn) {
+        // Serialize access within the same process
+        const currentQueue = this.queues.get(filePath) || Promise.resolve();
+        let result;
+        const nextPromise = currentQueue.then(async () => {
+            await this.acquire(filePath);
+            try {
+                result = await fn();
+            }
+            finally {
+                await this.release(filePath);
+            }
+        });
+        // Update queue, catching errors to ensure the chain continues
+        this.queues.set(filePath, nextPromise.catch(() => { }));
+        await nextPromise;
+        return result;
+    }
+}
+exports.FileLocker = FileLocker;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "lmcs-db",
-  "version": "1.0.4",
-  "description": "LmcsDb is a database with multiple storage engines and criptography",
+  "version": "2.0.0",
+  "description": "Lightweight Modular Collection Storage - Secure & Transactional",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
-    "test": "ts-node test/demo.ts"
+    "test": "jest"
   },
   "keywords": [
     "database",
@@ -37,11 +37,17 @@
   },
   "homepage": "https://github.com/leandroasilva/lmcs-db#readme",
   "dependencies": {
+    "proper-lockfile": "^4.1.2",
     "uuid": "^11.1.0"
   },
   "devDependencies": {
-    "@types/node": "^18.0.0",
-    "ts-node": "^10.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^20.0.0",
+    "@types/proper-lockfile": "^4.1.4",
+    "@types/uuid": "^9.0.8",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "tsx": "^4.21.0",
     "typescript": "^5.0.0"
   }
 }