mvcc-api 1.0.2 → 1.0.3

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

@@ -2,13 +2,13 @@ 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> {
+export declare class AsyncMVCCManager<S extends AsyncMVCCStrategy<K, T>, K, T> extends MVCCManager<S, K, T> {
     readonly lock: Ryoiki;
     constructor(strategy: S);
-    createTransaction(): AsyncMVCCTransaction<T, S, this>;
+    createTransaction(): AsyncMVCCTransaction<S, K, T, 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>;
+    _diskWrite(key: K, value: T, version: number): Promise<void>;
+    _diskRead(key: K, snapshotVersion: number): Promise<T | null>;
+    _diskDelete(key: K, snapshotVersion: number): Promise<void>;
+    _commit(tx: AsyncMVCCTransaction<S, K, T, this>): Promise<void>;
 }

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,7 @@
 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, M extends AsyncMVCCManager<S, K, T>> extends MVCCTransaction<S, K, T, M> {
+    read(key: K): Promise<T | null>;
     commit(): Promise<this>;
 }

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

@@ -5,24 +5,25 @@ 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.
+ * @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 MVCCManager<T, S extends MVCCStrategy<T>> {
+export declare abstract class MVCCManager<S extends MVCCStrategy<K, T>, K, T> {
     version: number;
     readonly strategy: S;
-    protected readonly versionIndex: Map<string, {
+    protected readonly versionIndex: Map<K, {
         version: number;
         exists: boolean;
     }[]>;
-    protected readonly activeTransactions: Set<MVCCTransaction<T, S, this>>;
-    protected readonly deletedCache: Map<string, DeleteEntry<T>[]>;
+    protected readonly activeTransactions: Set<MVCCTransaction<S, K, T, this>>;
+    protected readonly deletedCache: Map<K, 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>;
+    abstract createTransaction(): MVCCTransaction<S, K, T, 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.
@@ -30,7 +31,7 @@ export declare abstract class MVCCManager<T, S extends MVCCStrategy<T>> {
      * @param value The value to write.
      * @param version The version number for this write.
      */
-    abstract _diskWrite(key: string, value: T, version: number): Deferred<void>;
+    abstract _diskWrite(key: K, 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.
@@ -38,21 +39,21 @@ export declare abstract class MVCCManager<T, S extends MVCCStrategy<T>> {
      * @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>;
+    abstract _diskRead(key: K, 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>;
+    abstract _diskDelete(key: K, 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;
+    abstract _commit(tx: MVCCTransaction<S, K, T, this>): Deferred<void>;
+    _removeTransaction(tx: MVCCTransaction<S, K, T, this>): void;
     protected _cleanupDeletedCache(): void;
 }

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

@@ -5,16 +5,17 @@ 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 K The type of key used for data storage (e.g., string).
+ * @template T The type of data stored (e.g., string, Buffer, object).
  * @template M The manager type that created this transaction.
  */
-export declare abstract class MVCCTransaction<T, S extends MVCCStrategy<T>, M extends MVCCManager<T, S>> {
+export declare abstract class MVCCTransaction<S extends MVCCStrategy<K, T>, K, T, M extends MVCCManager<S, K, T>> {
     protected readonly manager: M;
     protected committed: boolean;
     readonly snapshotVersion: number;
-    readonly writeBuffer: Map<string, T>;
-    readonly deleteBuffer: Set<string>;
+    readonly writeBuffer: Map<K, T>;
+    readonly deleteBuffer: Set<K>;
     constructor(manager: M, snapshotVersion: number);
     /**
      * Schedules a creation (insert) of a key-value pair.
@@ -23,7 +24,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 +32,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,7 +50,7 @@ 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.

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

@@ -1,11 +1,11 @@
 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> {
+export declare class SyncMVCCManager<S extends SyncMVCCStrategy<K, T>, K, T> extends MVCCManager<S, K, T> {
     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;
+    createTransaction(): SyncMVCCTransaction<S, K, T, this>;
+    _diskWrite(key: K, value: T, version: number): void;
+    _diskRead(key: K, snapshotVersion: number): T | null;
+    _diskDelete(key: K, snapshotVersion: number): void;
+    _commit(tx: SyncMVCCTransaction<S, K, T, this>): void;
 }

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,7 @@
 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, M extends SyncMVCCManager<S, K, T>> extends MVCCTransaction<S, K, T, M> {
+    read(key: K): T | null;
     commit(): this;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mvcc-api",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Multiversion Concurrency Control (MVCC) API for TypeScript",
   "license": "MIT",
   "author": "izure <admin@izure.org>",