mvcc-api 1.0.2 → 1.1.0

package/dist/types/core/async/Strategy.d.ts

@@ -1,7 +1,7 @@
 import { MVCCStrategy } from '../base';
-export declare abstract class AsyncMVCCStrategy<T> extends MVCCStrategy<T> {
-    abstract read(key: string): Promise<T>;
-    abstract write(key: string, value: T): Promise<void>;
-    abstract delete(key: string): Promise<void>;
-    abstract exists(key: string): Promise<boolean>;
+export declare abstract class AsyncMVCCStrategy<K, T> extends MVCCStrategy<K, T> {
+    abstract read(key: K): Promise<T>;
+    abstract write(key: K, value: T): Promise<void>;
+    abstract delete(key: K): Promise<void>;
+    abstract exists(key: K): Promise<boolean>;
 }

package/dist/types/core/async/Transaction.d.ts

@@ -1,7 +1,15 @@
 import type { AsyncMVCCStrategy } from './Strategy';
-import type { AsyncMVCCManager } from './Manager';
 import { MVCCTransaction } from '../base';
-export declare class AsyncMVCCTransaction<T, S extends AsyncMVCCStrategy<T>, M extends AsyncMVCCManager<T, S>> extends MVCCTransaction<T, S, M> {
-    read(key: string): Promise<T | null>;
+export declare class AsyncMVCCTransaction<S extends AsyncMVCCStrategy<K, T>, K, T> extends MVCCTransaction<S, K, T> {
+    private lock;
+    private writeLock;
+    createNested(): this;
+    read(key: K): Promise<T | null>;
+    _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Promise<T | null>;
     commit(): Promise<this>;
+    _merge(child: MVCCTransaction<S, K, T>): Promise<void>;
+    _diskWrite(key: K, value: T, version: number): Promise<void>;
+    _diskRead(key: K, snapshotVersion: number): Promise<T | null>;
+    _diskDelete(key: K, snapshotVersion: number): Promise<void>;
+    _cleanupDeletedCache(): void;
 }

package/dist/types/core/async/index.d.ts

@@ -1,3 +1,2 @@
-export * from './Manager';
 export * from './Strategy';
 export * from './Transaction';

package/dist/types/core/base/Strategy.d.ts

@@ -3,30 +3,31 @@ import type { Deferred } from '../../types';
  * MVCC Strategy abstract class.
  * Defines the interface for data storage strategies (e.g., File System, In-Memory).
  * To implement a new storage backend, extend this class and implement the abstract methods.
+ * @template K The type of key used for data storage (e.g., string).
  * @template T The type of data stored (e.g., string, Buffer, object).
  */
-export declare abstract class MVCCStrategy<T> {
+export declare abstract class MVCCStrategy<K, T> {
     /**
      * Reads a value from the storage.
      * @param key The key to read.
      * @returns The value corresponding to the key.
      */
-    abstract read(key: string): Deferred<T>;
+    abstract read(key: K): Deferred<T>;
     /**
      * Writes a value to the storage.
      * @param key The key to write.
      * @param value The value to write.
      */
-    abstract write(key: string, value: T): Deferred<void>;
+    abstract write(key: K, value: T): Deferred<void>;
     /**
      * Deletes a value from the storage.
      * @param key The key to delete.
      */
-    abstract delete(key: string): Deferred<void>;
+    abstract delete(key: K): Deferred<void>;
     /**
      * Checks if a key exists in the storage.
      * @param key The key to check.
      * @returns True if the key exists, false otherwise.
      */
-    abstract exists(key: string): Deferred<boolean>;
+    abstract exists(key: K): Deferred<boolean>;
 }

package/dist/types/core/base/Transaction.d.ts

@@ -1,21 +1,36 @@
 import type { Deferred } from '../../types';
-import type { MVCCManager } from './Manager';
 import type { MVCCStrategy } from './Strategy';
 /**
  * MVCC Transaction abstract class.
  * Represents a logical unit of work that isolates changes until commit.
- * It manages its own write/delete buffers and enforces Snapshot Isolation.
- * @template T The type of data stored.
- * @template S The strategy type used by the manager.
- * @template M The manager type that created this transaction.
+ * It can be a RootTransaction (interacting with storage) or a NestedTransaction (interacting with parent).
+ * @template S The strategy type used by the root transaction.
+ * @template K The type of key used for data storage (e.g., string).
+ * @template T The type of data stored (e.g., string, Buffer, object).
  */
-export declare abstract class MVCCTransaction<T, S extends MVCCStrategy<T>, M extends MVCCManager<T, S>> {
-    protected readonly manager: M;
-    protected committed: boolean;
+export declare abstract class MVCCTransaction<S extends MVCCStrategy<K, T>, K, T> {
+    committed: boolean;
     readonly snapshotVersion: number;
-    readonly writeBuffer: Map<string, T>;
-    readonly deleteBuffer: Set<string>;
-    constructor(manager: M, snapshotVersion: number);
+    readonly snapshotLocalVersion: number;
+    readonly writeBuffer: Map<K, T>;
+    readonly deleteBuffer: Set<K>;
+    readonly parent?: MVCCTransaction<S, K, T>;
+    localVersion: number;
+    readonly keyVersions: Map<K, number>;
+    readonly root: MVCCTransaction<S, K, T>;
+    protected strategy?: S;
+    protected version: number;
+    protected versionIndex: Map<K, Array<{
+        version: number;
+        exists: boolean;
+    }>>;
+    protected deletedCache: Map<K, Array<{
+        value: T;
+        deletedAtVersion: number;
+    }>>;
+    protected activeTransactions: Set<MVCCTransaction<S, K, T>>;
+    constructor(strategy?: S, parent?: MVCCTransaction<S, K, T>, snapshotVersion?: number);
+    isRoot(): boolean;
     /**
      * Schedules a creation (insert) of a key-value pair.
      * Throws if the transaction is already committed.
@@ -23,7 +38,7 @@ export declare abstract class MVCCTransaction<T, S extends MVCCStrategy<T>, M ex
      * @param value The value to store.
      * @returns The transaction instance for chaining.
      */
-    create(key: string, value: T): this;
+    create(key: K, value: T): this;
     /**
      * Schedules a write (update) of a key-value pair.
      * Overwrites any existing value in the buffer.
@@ -31,13 +46,13 @@ export declare abstract class MVCCTransaction<T, S extends MVCCStrategy<T>, M ex
      * @param value The value to store.
      * @returns The transaction instance for chaining.
      */
-    write(key: string, value: T): this;
+    write(key: K, value: T): this;
     /**
      * Schedules a deletion of a key.
      * @param key The key to delete.
      * @returns The transaction instance for chaining.
      */
-    delete(key: string): this;
+    delete(key: K): this;
     /**
      * Rolls back the transaction.
      * Clears all buffers and marks the transaction as finished.
@@ -49,11 +64,30 @@ export declare abstract class MVCCTransaction<T, S extends MVCCStrategy<T>, M ex
      * @param key The key to read.
      * @returns The value, or null if not found.
      */
-    abstract read(key: string): Deferred<T | null>;
+    abstract read(key: K): Deferred<T | null>;
     /**
      * Commits the transaction.
-     * Applies buffered changes to the permanent storage via the manager.
+     * If root, persists to storage.
+     * If nested, merges to parent.
      * @returns The transaction instance.
      */
     abstract commit(): Deferred<this>;
+    /**
+     * Creates a nested transaction (child) from this transaction.
+     * @returns A new nested transaction instance.
+     */
+    abstract createNested(): MVCCTransaction<S, K, T>;
+    /**
+     * Merges a child transaction's changes into this transaction.
+     * @param child The committed child transaction.
+     */
+    abstract _merge(child: MVCCTransaction<S, K, T>): Deferred<void>;
+    /**
+     * Reads a value at a specific snapshot version.
+     * Used by child transactions to read from parent respecting the child's snapshot.
+     * @param key The key to read.
+     * @param snapshotVersion The global version to read at.
+     * @param snapshotLocalVersion The local version within the parent's buffer to read at.
+     */
+    abstract _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): Deferred<T | null>;
 }

package/dist/types/core/base/index.d.ts

@@ -1,3 +1,2 @@
-export * from './Manager';
 export * from './Strategy';
 export * from './Transaction';

package/dist/types/core/sync/Strategy.d.ts

@@ -1,7 +1,7 @@
 import { MVCCStrategy } from '../base';
-export declare abstract class SyncMVCCStrategy<T> extends MVCCStrategy<T> {
-    abstract read(key: string): T;
-    abstract write(key: string, value: T): void;
-    abstract delete(key: string): void;
-    abstract exists(key: string): boolean;
+export declare abstract class SyncMVCCStrategy<K, T> extends MVCCStrategy<K, T> {
+    abstract read(key: K): T;
+    abstract write(key: K, value: T): void;
+    abstract delete(key: K): void;
+    abstract exists(key: K): boolean;
 }

package/dist/types/core/sync/Transaction.d.ts

@@ -1,7 +1,13 @@
 import type { SyncMVCCStrategy } from './Strategy';
-import type { SyncMVCCManager } from './Manager';
 import { MVCCTransaction } from '../base';
-export declare class SyncMVCCTransaction<T, S extends SyncMVCCStrategy<T>, M extends SyncMVCCManager<T, S>> extends MVCCTransaction<T, S, M> {
-    read(key: string): T | null;
+export declare class SyncMVCCTransaction<S extends SyncMVCCStrategy<K, T>, K, T> extends MVCCTransaction<S, K, T> {
+    createNested(): this;
+    read(key: K): T | null;
+    _readSnapshot(key: K, snapshotVersion: number, snapshotLocalVersion?: number): T | null;
     commit(): this;
+    _merge(child: MVCCTransaction<S, K, T>): void;
+    _diskWrite(key: K, value: T, version: number): void;
+    _diskRead(key: K, snapshotVersion: number): T | null;
+    _diskDelete(key: K, snapshotVersion: number): void;
+    _cleanupDeletedCache(): void;
 }

package/dist/types/core/sync/index.d.ts

@@ -1,3 +1,2 @@
-export * from './Manager';
 export * from './Strategy';
 export * from './Transaction';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvcc-api",
-  "version": "1.0.2",
+  "version": "1.1.0",
   "description": "Multiversion Concurrency Control (MVCC) API for TypeScript",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -19,7 +19,7 @@
   ],
   "scripts": {
     "test": "jest",
-    "build": "node build/index.mjs && tsc"
+    "build": "node build/index.js && tsc"
   },
   "keywords": [
     "mvcc",

package/dist/types/core/async/Manager.d.ts

@@ -1,14 +0,0 @@
-import type { AsyncMVCCStrategy } from './Strategy';
-import { Ryoiki } from 'ryoiki';
-import { MVCCManager } from '../base';
-import { AsyncMVCCTransaction } from './Transaction';
-export declare class AsyncMVCCManager<T, S extends AsyncMVCCStrategy<T>> extends MVCCManager<T, S> {
-    readonly lock: Ryoiki;
-    constructor(strategy: S);
-    createTransaction(): AsyncMVCCTransaction<T, S, this>;
-    writeLock<R>(fn: () => Promise<R>): Promise<R>;
-    _diskWrite(key: string, value: T, version: number): Promise<void>;
-    _diskRead(key: string, snapshotVersion: number): Promise<T | null>;
-    _diskDelete(key: string, snapshotVersion: number): Promise<void>;
-    _commit(tx: AsyncMVCCTransaction<T, S, this>): Promise<void>;
-}

package/dist/types/core/base/Manager.d.ts

@@ -1,58 +0,0 @@
-import type { Deferred, DeleteEntry } from '../../types';
-import type { MVCCStrategy } from './Strategy';
-import type { MVCCTransaction } from './Transaction';
-/**
- * MVCC Manager abstract class.
- * Orchestrates transactions, manages the version index, and handles garbage collection.
- * It is responsible for maintaining the consistency of the data and version history.
- * @template T The type of data stored.
- * @template S The strategy type used for persistence.
- */
-export declare abstract class MVCCManager<T, S extends MVCCStrategy<T>> {
-    version: number;
-    readonly strategy: S;
-    protected readonly versionIndex: Map<string, {
-        version: number;
-        exists: boolean;
-    }[]>;
-    protected readonly activeTransactions: Set<MVCCTransaction<T, S, this>>;
-    protected readonly deletedCache: Map<string, DeleteEntry<T>[]>;
-    constructor(strategy: S);
-    /**
-     * Creates a new transaction with the current version.
-     * @returns A new accessible transaction instance.
-     */
-    abstract createTransaction(): MVCCTransaction<T, S, this>;
-    /**
-     * Writes data to the persistent storage and indexes the new version.
-     * @internal This method is for internal use only and should not be called directly.
-     * @param key The key to write.
-     * @param value The value to write.
-     * @param version The version number for this write.
-     */
-    abstract _diskWrite(key: string, value: T, version: number): Deferred<void>;
-    /**
-     * Reads data from the persistent storage for a specific snapshot version.
-     * @internal This method is for internal use only and should not be called directly.
-     * @param key The key to read.
-     * @param shapshotVersion The transaction's snapshot version.
-     * @returns The data visible to the snapshot version, or null.
-     */
-    abstract _diskRead(key: string, shapshotVersion: number): Deferred<T | null>;
-    /**
-     * Deletes data from the persistent storage (records a deletion version).
-     * @internal This method is for internal use only and should not be called directly.
-     * @param key The key to delete.
-     * @param snapshotVersion The version at which the deletion occurs.
-     */
-    abstract _diskDelete(key: string, snapshotVersion: number): Deferred<void>;
-    /**
-     * Commits a transaction.
-     * Validates conflicts and applies the transaction's changes.
-     * @internal This method is for internal use only and should not be called directly.
-     * @param tx The transaction to commit.
-     */
-    abstract _commit(tx: MVCCTransaction<T, S, this>): Deferred<void>;
-    _removeTransaction(tx: MVCCTransaction<T, S, this>): void;
-    protected _cleanupDeletedCache(): void;
-}

package/dist/types/core/sync/Manager.d.ts

@@ -1,11 +0,0 @@
-import type { SyncMVCCStrategy } from './Strategy';
-import { MVCCManager } from '../base';
-import { SyncMVCCTransaction } from './Transaction';
-export declare class SyncMVCCManager<T, S extends SyncMVCCStrategy<T>> extends MVCCManager<T, S> {
-    constructor(strategy: S);
-    createTransaction(): SyncMVCCTransaction<T, S, this>;
-    _diskWrite(key: string, value: T, version: number): void;
-    _diskRead(key: string, snapshotVersion: number): T | null;
-    _diskDelete(key: string, snapshotVersion: number): void;
-    _commit(tx: SyncMVCCTransaction<T, S, this>): void;
-}