@frostpillar/frostpillar-btree 0.2.4 → 0.2.6

package/dist/index.js

@@ -6,7 +6,7 @@ import {
   DEFAULT_MAX_LEAF_ENTRIES,
   InMemoryBTree,
   computeAutoScaleTier
-} from "./chunk-ZA3EQNDI.js";
+} from "./chunk-OWHENPGJ.js";
 
 // src/concurrency/helpers.ts
 var DEFAULT_MAX_RETRIES = 16;
@@ -30,6 +30,81 @@ var assertNeverMutation = (mutation) => {
     `Unsupported mutation type from shared store: ${String(unknownMutation.type)}`
   );
 };
+var validatePutManyEntries = (entries) => {
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null || !("key" in entry) || !("value" in entry)) {
+      throw new BTreeConcurrencyError("Malformed putMany mutation: each entry must have key and value.");
+    }
+  }
+};
+var validateInitMutation = (m, expectedConfigFingerprint) => {
+  if (typeof m.configFingerprint !== "string") {
+    throw new BTreeConcurrencyError("Malformed init mutation: missing configFingerprint.");
+  }
+  if (expectedConfigFingerprint !== void 0 && m.configFingerprint !== expectedConfigFingerprint) {
+    throw new BTreeConcurrencyError(
+      "Config mismatch: store peers must share identical tree config."
+    );
+  }
+};
+var validateSingleMutation = (m, expectedConfigFingerprint) => {
+  switch (m.type) {
+    case "init":
+      validateInitMutation(m, expectedConfigFingerprint);
+      break;
+    case "put":
+      if (!("key" in m) || !("value" in m)) {
+        throw new BTreeConcurrencyError("Malformed put mutation: missing key or value.");
+      }
+      break;
+    case "remove":
+      if (!("key" in m)) {
+        throw new BTreeConcurrencyError("Malformed remove mutation: missing key.");
+      }
+      break;
+    case "removeById":
+      if (!("entryId" in m)) {
+        throw new BTreeConcurrencyError("Malformed removeById mutation: missing entryId.");
+      }
+      break;
+    case "updateById":
+      if (!("entryId" in m) || !("value" in m)) {
+        throw new BTreeConcurrencyError("Malformed updateById mutation: missing entryId or value.");
+      }
+      break;
+    case "popFirst":
+    case "popLast":
+      break;
+    case "putMany":
+      if (!("entries" in m) || !Array.isArray(m.entries)) {
+        throw new BTreeConcurrencyError("Malformed putMany mutation: missing entries array.");
+      }
+      validatePutManyEntries(m.entries);
+      break;
+    case "deleteRange":
+      if (!("startKey" in m) || !("endKey" in m)) {
+        throw new BTreeConcurrencyError("Malformed deleteRange mutation: missing startKey or endKey.");
+      }
+      break;
+    case "clear":
+      break;
+    default:
+      throw new BTreeConcurrencyError(
+        `Unsupported mutation type from shared store: ${String(m.type)}`
+      );
+  }
+};
+var validateMutationBatch = (mutations, expectedConfigFingerprint) => {
+  for (const mutation of mutations) {
+    if (typeof mutation !== "object" || mutation === null) {
+      throw new BTreeConcurrencyError("Malformed mutation: expected an object.");
+    }
+    validateSingleMutation(
+      mutation,
+      expectedConfigFingerprint
+    );
+  }
+};
 var normalizeMaxRetries = (value) => {
   if (value === void 0) {
     return DEFAULT_MAX_RETRIES;
@@ -88,10 +163,110 @@ function assertAppendVersionContract(expectedVersion, appendResult) {
   }
 }
 
+// src/concurrency/writeOps.ts
+var applyMutationLocal = (tree, mutation, onInit) => {
+  switch (mutation.type) {
+    case "init":
+      onInit();
+      return null;
+    case "put":
+      return tree.put(mutation.key, mutation.value);
+    case "putMany":
+      return tree.putMany(mutation.entries);
+    case "remove":
+      return tree.remove(mutation.key);
+    case "removeById":
+      return tree.removeById(mutation.entryId);
+    case "updateById":
+      return tree.updateById(mutation.entryId, mutation.value);
+    case "popFirst":
+      return tree.popFirst();
+    case "popLast":
+      return tree.popLast();
+    case "deleteRange":
+      return tree.deleteRange(mutation.startKey, mutation.endKey, mutation.options);
+    case "clear":
+      tree.clear();
+      return null;
+    default:
+      return assertNeverMutation(mutation);
+  }
+};
+var createPutEvaluator = (duplicateKeys, key, value) => {
+  return (tree) => {
+    if (duplicateKeys === "reject" && tree.hasKey(key)) {
+      throw new BTreeValidationError("Duplicate key rejected.");
+    }
+    return { type: "put", key, value };
+  };
+};
+var createRemoveEvaluator = (key) => {
+  return (tree) => {
+    return tree.hasKey(key) ? { type: "remove", key } : null;
+  };
+};
+var createRemoveByIdEvaluator = (entryId) => {
+  return (tree) => {
+    return tree.peekById(entryId) !== null ? { type: "removeById", entryId } : null;
+  };
+};
+var createUpdateByIdEvaluator = (entryId, value) => {
+  return (tree) => {
+    return tree.peekById(entryId) !== null ? { type: "updateById", entryId, value } : null;
+  };
+};
+var createPopFirstEvaluator = () => {
+  return (tree) => {
+    return tree.peekFirst() !== null ? { type: "popFirst" } : null;
+  };
+};
+var createPopLastEvaluator = () => {
+  return (tree) => {
+    return tree.peekLast() !== null ? { type: "popLast" } : null;
+  };
+};
+var createPutManyEvaluator = (entries, duplicateKeys, compareKeys) => {
+  return (tree) => {
+    const strictlyAscending = duplicateKeys !== "allow";
+    for (let i = 1; i < entries.length; i += 1) {
+      const cmp = compareKeys(entries[i - 1].key, entries[i].key);
+      if (cmp > 0) {
+        throw new BTreeValidationError("putMany: entries not in ascending order.");
+      }
+      if (strictlyAscending && cmp === 0) {
+        throw new BTreeValidationError(
+          duplicateKeys === "reject" ? "putMany: duplicate key rejected." : "putMany: equal keys not allowed in strict mode."
+        );
+      }
+    }
+    if (duplicateKeys === "reject") {
+      for (const entry of entries) {
+        if (tree.hasKey(entry.key)) {
+          throw new BTreeValidationError("Duplicate key rejected.");
+        }
+      }
+    }
+    return { type: "putMany", entries };
+  };
+};
+var createDeleteRangeEvaluator = (startKey, endKey, options) => {
+  return (tree) => {
+    const count = tree.count(startKey, endKey, options);
+    if (count === 0) {
+      return null;
+    }
+    return { type: "deleteRange", startKey, endKey, options };
+  };
+};
+var createClearEvaluator = () => {
+  return () => ({ type: "clear" });
+};
+
 // src/concurrency/ConcurrentInMemoryBTree.ts
 var ConcurrentInMemoryBTree = class {
   constructor(config) {
     this.store = config.store;
+    this.compareKeys = config.compareKeys;
     this.maxRetries = normalizeMaxRetries(config.maxRetries);
     this.maxSyncMutationsPerBatch = normalizeMaxSyncMutationsPerBatch(
       config.maxSyncMutationsPerBatch
@@ -110,6 +285,7 @@ var ConcurrentInMemoryBTree = class {
     this.currentVersion = 0n;
     this.operationQueue = Promise.resolve();
     this.initSeen = false;
+    this.corrupted = false;
   }
   async sync() {
     await this.runExclusive(async () => {
@@ -132,39 +308,31 @@ var ConcurrentInMemoryBTree = class {
     if (log.version <= this.currentVersion) {
       return;
     }
-    for (const mutation of log.mutations) {
-      this.applyMutationLocal(mutation);
-    }
-    this.currentVersion = log.version;
-  }
-  applyMutationLocal(mutation) {
-    switch (mutation.type) {
-      case "init":
-        if (mutation.configFingerprint !== this.configFingerprint) {
-          throw new BTreeConcurrencyError(
-            "Config mismatch: store peers must share identical tree config."
-          );
-        }
-        this.initSeen = true;
-        return null;
-      case "put":
-        return this.tree.put(mutation.key, mutation.value);
-      case "remove":
-        return this.tree.remove(mutation.key);
-      case "removeById":
-        return this.tree.removeById(mutation.entryId);
-      case "updateById":
-        return this.tree.updateById(mutation.entryId, mutation.value);
-      case "popFirst":
-        return this.tree.popFirst();
-      case "popLast":
-        return this.tree.popLast();
-      default:
-        return assertNeverMutation(mutation);
+    validateMutationBatch(log.mutations, this.configFingerprint);
+    try {
+      for (const mutation of log.mutations) {
+        applyMutationLocal(this.tree, mutation, () => {
+          this.initSeen = true;
+        });
+      }
+      this.currentVersion = log.version;
+    } catch (error) {
+      this.corrupted = true;
+      const cause = error instanceof Error ? error.message : String(error);
+      throw new BTreeConcurrencyError(
+        `Replay failure: instance is permanently corrupted. Discard and create a new instance. Cause: ${cause}`
+      );
     }
   }
   runExclusive(operation) {
-    const run = async () => operation();
+    const run = async () => {
+      if (this.corrupted) {
+        throw new BTreeConcurrencyError(
+          "Instance is permanently corrupted. Discard and create a new instance."
+        );
+      }
+      return operation();
+    };
     const result = this.operationQueue.then(run, run);
     this.operationQueue = result.then(
       () => void 0,
@@ -192,13 +360,29 @@ var ConcurrentInMemoryBTree = class {
       const appendResult = await this.store.append(expectedVersion, mutations);
       assertAppendVersionContract(expectedVersion, appendResult);
       if (appendResult.applied) {
-        for (const m of mutations) {
-          if (m === mutation) break;
-          this.applyMutationLocal(m);
+        try {
+          for (const m of mutations) {
+            if (m === mutation) break;
+            applyMutationLocal(this.tree, m, () => {
+              this.initSeen = true;
+            });
+          }
+          const localResult = applyMutationLocal(
+            this.tree,
+            mutation,
+            () => {
+              this.initSeen = true;
+            }
+          );
+          this.currentVersion = appendResult.version;
+          return localResult;
+        } catch (error) {
+          this.corrupted = true;
+          const cause = error instanceof Error ? error.message : String(error);
+          throw new BTreeConcurrencyError(
+            `Local apply failure after successful append: instance is permanently corrupted. Discard and create a new instance. Cause: ${cause}`
+          );
         }
-        const localResult = this.applyMutationLocal(mutation);
-        this.currentVersion = appendResult.version;
-        return localResult;
       }
     }
     throw new BTreeConcurrencyError(
@@ -208,47 +392,56 @@ var ConcurrentInMemoryBTree = class {
   async put(key, value) {
     return this.runExclusive(async () => {
       return this.appendMutationAndApplyUnlocked(
-        (tree) => {
-          if (this.duplicateKeys === "reject" && tree.hasKey(key)) {
-            throw new BTreeValidationError("Duplicate key rejected.");
-          }
-          return { type: "put", key, value };
-        }
+        createPutEvaluator(this.duplicateKeys, key, value)
       );
     });
   }
   async remove(key) {
     return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(
-        (tree) => {
-          return tree.hasKey(key) ? { type: "remove", key } : null;
-        }
-      );
+      return this.appendMutationAndApplyUnlocked(createRemoveEvaluator(key));
     });
   }
   async removeById(entryId) {
     return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked(
-        (tree) => {
-          return tree.peekById(entryId) !== null ? { type: "removeById", entryId } : null;
-        }
-      );
+      return this.appendMutationAndApplyUnlocked(createRemoveByIdEvaluator(entryId));
     });
   }
   async updateById(entryId, value) {
+    return this.runExclusive(async () => {
+      return this.appendMutationAndApplyUnlocked(createUpdateByIdEvaluator(entryId, value));
+    });
+  }
+  async popFirst() {
+    return this.runExclusive(async () => {
+      return this.appendMutationAndApplyUnlocked(createPopFirstEvaluator());
+    });
+  }
+  async popLast() {
+    return this.runExclusive(async () => {
+      return this.appendMutationAndApplyUnlocked(createPopLastEvaluator());
+    });
+  }
+  async putMany(entries) {
+    if (entries.length === 0) {
+      return [];
+    }
     return this.runExclusive(async () => {
       return this.appendMutationAndApplyUnlocked(
-        (tree) => {
-          return tree.peekById(entryId) !== null ? { type: "updateById", entryId, value } : null;
-        }
+        createPutManyEvaluator(entries, this.duplicateKeys, this.compareKeys)
       );
     });
   }
-  async popFirst() {
+  async deleteRange(startKey, endKey, options) {
     return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked((tree) => {
-        return tree.peekFirst() !== null ? { type: "popFirst" } : null;
-      });
+      const result = await this.appendMutationAndApplyUnlocked(
+        createDeleteRangeEvaluator(startKey, endKey, options)
+      );
+      return result ?? 0;
+    });
+  }
+  async clear() {
+    await this.runExclusive(async () => {
+      await this.appendMutationAndApplyUnlocked(createClearEvaluator());
     });
   }
   async get(key) {
@@ -284,13 +477,6 @@ var ConcurrentInMemoryBTree = class {
   async peekLast() {
     return this.readOp((tree) => tree.peekLast());
   }
-  async popLast() {
-    return this.runExclusive(async () => {
-      return this.appendMutationAndApplyUnlocked((tree) => {
-        return tree.peekLast() !== null ? { type: "popLast" } : null;
-      });
-    });
-  }
   async peekById(entryId) {
     return this.readOp((tree) => tree.peekById(entryId));
   }
@@ -306,6 +492,38 @@ var ConcurrentInMemoryBTree = class {
   async getPairOrNextLower(key) {
     return this.readOp((tree) => tree.getPairOrNextLower(key));
   }
+  async entries() {
+    return this.readOp((tree) => Array.from(tree.entries()));
+  }
+  async entriesReversed() {
+    return this.readOp((tree) => Array.from(tree.entriesReversed()));
+  }
+  async keys() {
+    return this.readOp((tree) => Array.from(tree.keys()));
+  }
+  async values() {
+    return this.readOp((tree) => Array.from(tree.values()));
+  }
+  async forEach(callback) {
+    await this.readOp((tree) => {
+      tree.forEach(callback);
+    });
+  }
+  async *[Symbol.asyncIterator]() {
+    const all = await this.entries();
+    for (const entry of all) {
+      yield entry;
+    }
+  }
+  async clone() {
+    return this.readOp((tree) => tree.clone());
+  }
+  async toJSON() {
+    return this.readOp((tree) => tree.toJSON());
+  }
+  static fromJSON(json, compareKeys) {
+    return InMemoryBTree.fromJSON(json, compareKeys);
+  }
 };
 export {
   BTreeConcurrencyError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frostpillar/frostpillar-btree",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "A tiny, zero-dependency in-memory B+ tree for TypeScript, Node.js, and browser JavaScript.",
   "type": "module",
   "author": "Hajime Sano",