@liorandb/core 1.0.12 → 1.0.14

package/dist/index.d.ts

@@ -1,6 +1,26 @@
 import { ClassicLevel } from 'classic-level';
 import { ZodSchema } from 'zod';
 
+interface IndexOptions {
+    unique?: boolean;
+}
+declare class Index {
+    readonly field: string;
+    readonly unique: boolean;
+    readonly dir: string;
+    readonly db: ClassicLevel<string, string>;
+    constructor(baseDir: string, field: string, options?: IndexOptions);
+    private normalizeKey;
+    private getRaw;
+    private setRaw;
+    private delRaw;
+    insert(doc: any): Promise<void>;
+    delete(doc: any): Promise<void>;
+    update(oldDoc: any, newDoc: any): Promise<void>;
+    find(value: any): Promise<string[]>;
+    close(): Promise<void>;
+}
+
 interface UpdateOptions$1 {
     upsert?: boolean;
 }
@@ -9,7 +29,10 @@ declare class Collection<T = any> {
     db: ClassicLevel<string, string>;
     private queue;
     private schema?;
+    private indexes;
     constructor(dir: string, schema?: ZodSchema<T>);
+    registerIndex(index: Index): void;
+    getIndex(field: string): Index | undefined;
     setSchema(schema: ZodSchema<T>): void;
     private validate;
     private _enqueue;
@@ -28,6 +51,7 @@ declare class Collection<T = any> {
     deleteOne(filter: any): Promise<any>;
     deleteMany(filter: any): Promise<any>;
     countDocuments(filter?: any): Promise<any>;
+    private _updateIndexes;
     private _insertOne;
     private _insertMany;
     private _findOne;
@@ -49,7 +73,11 @@ type TXCommit = {
     tx: number;
     commit: true;
 };
-type WALEntry = TXOp | TXCommit;
+type TXApplied = {
+    tx: number;
+    applied: true;
+};
+type WALEntry = TXOp | TXCommit | TXApplied;
 declare class DBTransactionContext {
     private db;
     readonly txId: number;
@@ -64,13 +92,18 @@ declare class LioranDB {
     manager: LioranManager;
     collections: Map<string, Collection>;
     private walPath;
+    private metaPath;
+    private meta;
     private static TX_SEQ;
     constructor(basePath: string, dbName: string, manager: LioranManager);
+    private loadMeta;
+    private saveMeta;
     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>;
+    createIndex(collection: string, field: string, options?: IndexOptions): Promise<void>;
     transaction<T>(fn: (tx: DBTransactionContext) => Promise<T>): Promise<T>;
     close(): Promise<void>;
 }
@@ -78,40 +111,23 @@ declare class LioranDB {
 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;
@@ -127,5 +143,35 @@ interface UpdateOptions {
 type Query<T = any> = Partial<T> & {
     [key: string]: any;
 };
+type IndexType = "hash" | "btree";
+interface IndexDefinition<T = any> {
+    field: keyof T | string;
+    unique?: boolean;
+    sparse?: boolean;
+    type?: IndexType;
+}
+interface IndexMetadata {
+    field: string;
+    unique: boolean;
+    sparse: boolean;
+    type: IndexType;
+    createdAt: number;
+}
+interface QueryExplainPlan {
+    indexUsed?: string;
+    indexType?: IndexType;
+    scannedDocuments: number;
+    returnedDocuments: number;
+    executionTimeMs: number;
+}
+interface CollectionIndexAPI<T = any> {
+    createIndex(def: IndexDefinition<T>): Promise<void>;
+    dropIndex(field: keyof T | string): Promise<void>;
+    listIndexes(): Promise<IndexMetadata[]>;
+    rebuildIndexes(): Promise<void>;
+}
+interface DatabaseIndexAPI {
+    rebuildAllIndexes(): Promise<void>;
+}
 
-export { LioranDB, LioranManager, type LioranManagerOptions, type Query, type UpdateOptions, getBaseDBFolder };
+export { type CollectionIndexAPI, type DatabaseIndexAPI, type IndexDefinition, type IndexMetadata, type IndexType, LioranDB, LioranManager, type LioranManagerOptions, type Query, type QueryExplainPlan, type UpdateOptions, getBaseDBFolder };