dataply 0.0.26-alpha.8 → 0.0.26-alpha.9

package/dist/cjs/index.js

@@ -5002,8 +5002,6 @@ var BPTreePureSync = class {
   comparator;
   option;
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5017,7 +5015,7 @@ var BPTreePureSync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       getNode(id) {
@@ -5084,16 +5082,35 @@ var BPTreePureSync = class {
     }
     return { ops, flush };
   }
+  _readCtx() {
+    const head = this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  _createCtx() {
+    const strategy = this.strategy;
+    const head = strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   init() {
     const { ops, flush } = this._createBufferedOps();
-    this._ctx = {
+    const ctx = {
       rootId: "",
       order: this.strategy.order,
       headData: () => this.strategy.head.data
     };
     initOp(
       ops,
-      this._ctx,
+      ctx,
       this.strategy.order,
       this.strategy.head,
       (head) => {
@@ -5101,19 +5118,18 @@ var BPTreePureSync = class {
       }
     );
     flush();
-    this._ops = this._createOps();
   }
   /**
    * Returns the ID of the root node.
    */
   getRootId() {
-    return this._ctx.rootId;
+    return this._readCtx().rootId;
   }
   /**
    * Returns the order of the B+Tree.
    */
   getOrder() {
-    return this._ctx.order;
+    return this._readCtx().order;
   }
   /**
    * Verified if the value satisfies the condition.
@@ -5130,15 +5146,18 @@ var BPTreePureSync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   get(key) {
-    return getOp(this._ops, this._ctx.rootId, key);
+    const { rootId } = this._readCtx();
+    return getOp(this._createReadOps(), rootId, key);
   }
   exists(key, value) {
-    return existsOp(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = this._readCtx();
+    return existsOp(this._createReadOps(), rootId, key, value, this.comparator);
   }
   *keysStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* keysStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5148,9 +5167,10 @@ var BPTreePureSync = class {
     );
   }
   *whereStream(condition, options) {
+    const { rootId } = this._readCtx();
     yield* whereStreamOp(
-      this._ops,
-      this._ctx.rootId,
+      this._createReadOps(),
+      rootId,
       condition,
       this.comparator,
       this._verifierMap,
@@ -5176,27 +5196,31 @@ var BPTreePureSync = class {
   // ─── Mutation ────────────────────────────────────────────────────
   insert(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    insertOp(ops, this._ctx, key, value, this.comparator);
+    const ctx = this._createCtx();
+    insertOp(ops, ctx, key, value, this.comparator);
     flush();
   }
   delete(key, value) {
     const { ops, flush } = this._createBufferedOps();
-    deleteOp(ops, this._ctx, key, this.comparator, value);
+    const ctx = this._createCtx();
+    deleteOp(ops, ctx, key, this.comparator, value);
     flush();
   }
   batchInsert(entries) {
     const { ops, flush } = this._createBufferedOps();
-    batchInsertOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    batchInsertOp(ops, ctx, entries, this.comparator);
     flush();
   }
   bulkLoad(entries) {
     const { ops, flush } = this._createBufferedOps();
-    bulkLoadOp(ops, this._ctx, entries, this.comparator);
+    const ctx = this._createCtx();
+    bulkLoadOp(ops, ctx, entries, this.comparator);
     flush();
   }
   // ─── Head Data ───────────────────────────────────────────────────
   getHeadData() {
-    const head = this._ops.readHead();
+    const head = this.strategy.readHead();
     if (head === null) {
       throw new Error("Head not found");
     }
@@ -5224,8 +5248,6 @@ var BPTreePureAsync = class {
   option;
   lock = new Ryoiki2();
   _cachedRegexp = /* @__PURE__ */ new Map();
-  _ctx;
-  _ops;
   _verifierMap;
   _searchConfigs;
   constructor(strategy, comparator, option) {
@@ -5239,7 +5261,7 @@ var BPTreePureAsync = class {
   _ensureValues(v) {
     return Array.isArray(v) ? v : [v];
   }
-  _createOps() {
+  _createReadOps() {
     const strategy = this.strategy;
     return {
       async getNode(id) {
@@ -5306,6 +5328,25 @@ var BPTreePureAsync = class {
     }
     return { ops, flush };
   }
+  async _readCtx() {
+    const head = await this.strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return { rootId: head.root, order: head.order };
+  }
+  async _createCtx() {
+    const strategy = this.strategy;
+    const head = await strategy.readHead();
+    if (head === null) {
+      throw new Error("Tree not initialized. Call init() first.");
+    }
+    return {
+      rootId: head.root,
+      order: head.order,
+      headData: () => strategy.head.data
+    };
+  }
   async writeLock(fn) {
     let lockId;
     return this.lock.writeLock(async (_lockId) => {
@@ -5318,14 +5359,14 @@ var BPTreePureAsync = class {
   async init() {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      this._ctx = {
+      const ctx = {
         rootId: "",
         order: this.strategy.order,
         headData: () => this.strategy.head.data
       };
       await initOpAsync(
         ops,
-        this._ctx,
+        ctx,
         this.strategy.order,
         this.strategy.head,
         (head) => {
@@ -5333,14 +5374,13 @@ var BPTreePureAsync = class {
         }
       );
       await flush();
-      this._ops = this._createOps();
     });
   }
-  getRootId() {
-    return this._ctx.rootId;
+  async getRootId() {
+    return (await this._readCtx()).rootId;
   }
-  getOrder() {
-    return this._ctx.order;
+  async getOrder() {
+    return (await this._readCtx()).order;
   }
   verify(nodeValue, condition) {
     for (const key in condition) {
@@ -5352,18 +5392,21 @@ var BPTreePureAsync = class {
   }
   // ─── Query ───────────────────────────────────────────────────────
   async get(key) {
-    return getOpAsync(this._ops, this._ctx.rootId, key);
+    const { rootId } = await this._readCtx();
+    return getOpAsync(this._createReadOps(), rootId, key);
   }
   async exists(key, value) {
-    return existsOpAsync(this._ops, this._ctx.rootId, key, value, this.comparator);
+    const { rootId } = await this._readCtx();
+    return existsOpAsync(this._createReadOps(), rootId, key, value, this.comparator);
   }
   async *keysStream(condition, options) {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* keysStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5379,9 +5422,10 @@ var BPTreePureAsync = class {
     let lockId;
     try {
       lockId = await this.lock.readLock([0, 0.1], async (id) => id);
+      const { rootId } = await this._readCtx();
       yield* whereStreamOpAsync(
-        this._ops,
-        this._ctx.rootId,
+        this._createReadOps(),
+        rootId,
         condition,
         this.comparator,
         this._verifierMap,
@@ -5411,34 +5455,38 @@ var BPTreePureAsync = class {
   async insert(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await insertOpAsync(ops, this._ctx, key, value, this.comparator);
+      const ctx = await this._createCtx();
+      await insertOpAsync(ops, ctx, key, value, this.comparator);
       await flush();
     });
   }
   async delete(key, value) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await deleteOpAsync(ops, this._ctx, key, this.comparator, value);
+      const ctx = await this._createCtx();
+      await deleteOpAsync(ops, ctx, key, this.comparator, value);
       await flush();
     });
   }
   async batchInsert(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await batchInsertOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await batchInsertOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   async bulkLoad(entries) {
     return this.writeLock(async () => {
       const { ops, flush } = this._createBufferedOps();
-      await bulkLoadOpAsync(ops, this._ctx, entries, this.comparator);
+      const ctx = await this._createCtx();
+      await bulkLoadOpAsync(ops, ctx, entries, this.comparator);
       await flush();
     });
   }
   // ─── Head Data ───────────────────────────────────────────────────
   async getHeadData() {
-    const head = await this._ops.readHead();
+    const head = await this.strategy.readHead();
     if (head === null) throw new Error("Head not found");
     return head.data;
   }
@@ -11672,15 +11720,6 @@ var Dataply = class {
   get options() {
     return this.api.options;
   }
-  /**
-   * Creates a transaction.
-   * The created transaction object can be used to add or modify data.
-   * A transaction must be terminated by calling either `commit` or `rollback`.
-   * @returns Transaction object
-   */
-  createTransaction() {
-    return this.api.createTransaction();
-  }
   /**
    * Runs a write callback within a transaction context.
    */

package/dist/types/core/Dataply.d.ts

@@ -12,13 +12,6 @@ export declare class Dataply {
      * @returns Options used to open the dataply.
      */
     get options(): Required<DataplyOptions>;
-    /**
-     * Creates a transaction.
-     * The created transaction object can be used to add or modify data.
-     * A transaction must be terminated by calling either `commit` or `rollback`.
-     * @returns Transaction object
-     */
-    protected createTransaction(): Transaction;
     /**
      * Runs a write callback within a transaction context.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dataply",
-  "version": "0.0.26-alpha.8",
+  "version": "0.0.26-alpha.9",
   "description": "A lightweight storage engine for Node.js with support for MVCC, WAL.",
   "license": "MIT",
   "author": "izure <admin@izure.org>",
@@ -49,6 +49,6 @@
     "hookall": "^2.2.0",
     "mvcc-api": "^1.3.7",
     "ryoiki": "^1.2.0",
-    "serializable-bptree": "^9.0.1"
+    "serializable-bptree": "^9.0.2"
   }
 }