@liorandb/core 1.0.11 → 1.0.13

package/dist/index.d.ts

@@ -8,100 +8,97 @@ declare class Collection<T = any> {
     dir: string;
     db: ClassicLevel<string, string>;
     private queue;
-    private walPath;
     private schema?;
-    private walCounter;
     constructor(dir: string, schema?: ZodSchema<T>);
     setSchema(schema: ZodSchema<T>): void;
     private validate;
-    private writeWAL;
-    private clearWAL;
-    private maybeCheckpoint;
-    private recoverFromWAL;
     private _enqueue;
-    private _exec;
     close(): Promise<void>;
+    _exec(op: string, args: any[]): Promise<any>;
     insertOne(doc: T & {
         _id?: string;
-    }): Promise<T>;
+    }): Promise<any>;
     insertMany(docs?: (T & {
         _id?: string;
-    })[]): Promise<T[]>;
-    find(query?: any): Promise<T[]>;
-    findOne(query?: any): Promise<T | null>;
-    updateOne(filter?: any, update?: any, options?: UpdateOptions$1): Promise<T | null>;
-    updateMany(filter?: any, update?: any): Promise<T[]>;
-    deleteOne(filter?: any): Promise<boolean>;
-    deleteMany(filter?: any): Promise<number>;
-    countDocuments(filter?: any): Promise<number>;
+    })[]): Promise<any>;
+    find(query?: any): Promise<any>;
+    findOne(query?: any): Promise<any>;
+    updateOne(filter: any, update: any, options?: UpdateOptions$1): Promise<any>;
+    updateMany(filter: any, update: any): Promise<any>;
+    deleteOne(filter: any): Promise<any>;
+    deleteMany(filter: any): Promise<any>;
+    countDocuments(filter?: any): Promise<any>;
     private _insertOne;
     private _insertMany;
     private _findOne;
     private _updateOne;
-    private _deleteOne;
     private _updateMany;
     private _find;
+    private _deleteOne;
     private _deleteMany;
     private _countDocuments;
 }
 
+type TXOp = {
+    tx: number;
+    col: string;
+    op: string;
+    args: any[];
+};
+type TXCommit = {
+    tx: number;
+    commit: true;
+};
+type TXApplied = {
+    tx: number;
+    applied: true;
+};
+type WALEntry = TXOp | TXCommit | TXApplied;
+declare class DBTransactionContext {
+    private db;
+    readonly txId: number;
+    private ops;
+    constructor(db: LioranDB, txId: number);
+    collection(name: string): {};
+    commit(): Promise<void>;
+}
 declare class LioranDB {
     basePath: string;
     dbName: string;
     manager: LioranManager;
     collections: Map<string, Collection>;
+    private walPath;
+    private static TX_SEQ;
     constructor(basePath: string, dbName: string, manager: LioranManager);
+    writeWAL(entries: WALEntry[]): Promise<void>;
+    clearWAL(): Promise<void>;
+    private recoverFromWAL;
+    applyTransaction(ops: TXOp[]): Promise<void>;
     collection<T = any>(name: string, schema?: ZodSchema<T>): Collection<T>;
-    createCollection<T = any>(name: string, schema?: ZodSchema<T>): Promise<Collection<T>>;
-    deleteCollection(name: string): Promise<boolean>;
-    renameCollection(oldName: string, newName: string): Promise<boolean>;
-    dropCollection(name: string): Promise<boolean>;
-    listCollections(): Promise<string[]>;
+    transaction<T>(fn: (tx: DBTransactionContext) => Promise<T>): Promise<T>;
     close(): Promise<void>;
-    getStats(): {
-        dbName: string;
-        basePath: string;
-        collections: string[];
-    };
 }
 
 interface LioranManagerOptions$1 {
     rootPath?: string;
     encryptionKey?: string | Buffer;
-    ipc?: boolean;
 }
 declare class LioranManager {
     rootPath: string;
     openDBs: Map<string, LioranDB>;
     private closed;
-    private ipc;
+    private mode;
+    private lockFd?;
+    private ipcServer?;
     constructor(options?: LioranManagerOptions$1);
+    private isProcessAlive;
+    private tryAcquireLock;
     db(name: string): Promise<LioranDB>;
-    createDatabase(name: string): Promise<LioranDB>;
     openDatabase(name: string): Promise<LioranDB>;
-    closeDatabase(name: string): Promise<void>;
-    /**
-     * Gracefully shuts down everything.
-     * - Closes all databases
-     * - Terminates IPC worker if running
-     */
     closeAll(): Promise<void>;
-    /**
-     * Alias for closeAll() (clean public API)
-     */
     close(): Promise<void>;
     private _registerShutdownHooks;
     private _assertOpen;
-    renameDatabase(oldName: string, newName: string): Promise<boolean>;
-    deleteDatabase(name: string): Promise<boolean>;
-    dropDatabase(name: string): Promise<boolean>;
-    listDatabases(): Promise<string[]>;
-    getStats(): {
-        rootPath: string;
-        openDatabases: string[];
-        ipc: boolean;
-        closed: boolean;
-    };
 }
 
 declare function getBaseDBFolder(): string;