@peerbit/indexer-sqlite3 2.1.1 → 2.1.2-000e3f1

package/dist/index.min.js

@@ -19003,12 +19003,15 @@ function hashBlocks(w, v2, p, pos, len) {
 // ../../crypto/dist/src/utils.js
 var import_libsodium_wrappers = __toESM(require_libsodium_wrappers(), 1);
 var fromHexString = (hexString) => import_libsodium_wrappers.default.from_hex(hexString);
-var toHexString = (bytes) => import_libsodium_wrappers.default.to_hex(bytes);
+var asU8 = (bytes) => {
+  return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+};
+var toHexString = (bytes) => import_libsodium_wrappers.default.to_hex(asU8(bytes));
 var toBase64 = (arr) => {
-  return import_libsodium_wrappers.default.to_base64(arr, import_libsodium_wrappers.default.base64_variants.ORIGINAL);
+  return import_libsodium_wrappers.default.to_base64(asU8(arr), import_libsodium_wrappers.default.base64_variants.ORIGINAL);
 };
 var toBase58 = (arr) => {
-  return base58btc.baseEncode(arr);
+  return base58btc.baseEncode(asU8(arr));
 };
 
 // ../../crypto/dist/src/hash.browser.js
@@ -19503,10 +19506,11 @@ var toId = (obj) => {
     }
     throw new Error("BigInt is not less than 2^64 - 1. Max value is " + (2 ** 64 - 1) + ". Provided value: " + obj);
   }
-  if (obj instanceof Uint8Array) {
-    return new Uint8ArrayKey(obj);
+  if (obj instanceof Uint8Array || ArrayBuffer.isView(obj)) {
+    const bytes = obj instanceof Uint8Array ? obj : new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength);
+    return new Uint8ArrayKey(bytes);
   }
-  throw new Error("Unexpected index key: " + typeof obj + ", expected: string, number, bigint or Uint8Array");
+  throw new Error("Unexpected index key: " + typeof obj + ", expected: string, number, bigint, Uint8Array or ArrayBufferView");
 };
 
 // ../../../../node_modules/.pnpm/uuid@10.0.0/node_modules/uuid/dist/esm-browser/stringify.js
@@ -20380,7 +20384,11 @@ var resolvePrimaryFieldInfoFromSchema = (ctor, path, primary) => {
     if (fieldType instanceof OptionKind) {
       fieldType = fieldType.elementType;
     }
-    fieldType = unwrapNestedType(fieldType);
+    if (fieldType instanceof FixedArrayKind && fieldType.elementType === "u8") {
+      fieldType = Uint8Array;
+    } else {
+      fieldType = unwrapNestedType(fieldType);
+    }
     if (fieldType instanceof VecKind) {
       continue;
     }
@@ -21934,6 +21942,30 @@ async function getIgnoreFK(stmt, values) {
 }
 var SQLLiteIndex = class {
   properties;
+  // SQLite writes are inherently serialized per connection.
+  // We still need an explicit async barrier because our API is async and
+  // awaits between statements (root insert -> many child inserts). Without
+  // a barrier, concurrent `put()` and `del()` can interleave mid-insert and
+  // create large volumes of FK constraint noise (and occasional timeouts in
+  // browser/webworker runners).
+  // TODO(perf): This is intentionally coarse-grained for correctness.
+  // Possible optimizations:
+  // 1) wrap nested writes in explicit transactions to reduce lock time;
+  // 2) use table/key-scoped write queues when overlap detection is available.
+  // Any relaxation must keep concurrent put/del stability across all runners.
+  _writeBarrier = Promise.resolve();
+  async withWriteBarrier(fn) {
+    const prev = this._writeBarrier;
+    let release;
+    const next = new Promise((r) => release = r);
+    this._writeBarrier = prev.then(() => next, () => next);
+    await prev.catch(() => void 0);
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
   primaryKeyArr;
   primaryKeyString;
   planner;
@@ -22114,28 +22146,30 @@ var SQLLiteIndex = class {
     return void 0;
   }
   async put(value, _id) {
-    const classOfValue = value.constructor;
-    return insert(async (values, table) => {
-      let preId = values[table.primaryIndex];
-      let statement = void 0;
-      try {
-        if (preId != null) {
-          statement = this.properties.db.statements.get(replaceStatementKey(table));
-          this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
-          return preId;
-        } else {
-          statement = this.properties.db.statements.get(putStatementKey(table));
-          const out = this.fkMode === "race-tolerant" ? await getIgnoreFK(statement, values) : await statement.get(values);
-          if (out == null) {
-            return void 0;
+    return this.withWriteBarrier(async () => {
+      const classOfValue = value.constructor;
+      return insert(async (values, table) => {
+        let preId = values[table.primaryIndex];
+        let statement = void 0;
+        try {
+          if (preId != null) {
+            statement = this.properties.db.statements.get(replaceStatementKey(table));
+            this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
+            return preId;
+          } else {
+            statement = this.properties.db.statements.get(putStatementKey(table));
+            const out = this.fkMode === "race-tolerant" ? await getIgnoreFK(statement, values) : await statement.get(values);
+            if (out == null) {
+              return void 0;
+            }
+            return out[table.primary];
           }
-          return out[table.primary];
+        } finally {
+          await statement?.reset?.();
         }
-      } finally {
-        await statement?.reset?.();
-      }
-    }, value, this.tables, resolveTable(this.scopeString ? [this.scopeString] : [], this.tables, classOfValue, true), getSchema(classOfValue).fields, (_fn) => {
-      throw new Error("Unexpected");
+      }, value, this.tables, resolveTable(this.scopeString ? [this.scopeString] : [], this.tables, classOfValue, true), getSchema(classOfValue).fields, (_fn) => {
+        throw new Error("Unexpected");
+      });
     });
   }
   iterate(request, options) {
@@ -22245,30 +22279,32 @@ var SQLLiteIndex = class {
     return this.count();
   }
   async del(query) {
-    let ret = [];
-    let once = false;
-    let lastError = void 0;
-    for (const table of this._rootTables) {
-      try {
-        const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
-        const stmt = await this.properties.db.prepare(sql, sql);
-        const results = await stmt.all(bindable);
-        for (const result of results) {
-          ret.push(toId(convertFromSQLType(result[table.primary], table.primaryField.from.type)));
-        }
-        once = true;
-      } catch (error2) {
-        if (error2 instanceof MissingFieldError) {
-          lastError = error2;
-          continue;
+    return this.withWriteBarrier(async () => {
+      let ret = [];
+      let once = false;
+      let lastError = void 0;
+      for (const table of this._rootTables) {
+        try {
+          const { sql, bindable } = convertDeleteRequestToQuery(query, this.tables, table);
+          const stmt = await this.properties.db.prepare(sql, sql);
+          const results = await stmt.all(bindable);
+          for (const result of results) {
+            ret.push(toId(convertFromSQLType(result[table.primary], table.primaryField.from.type)));
+          }
+          once = true;
+        } catch (error2) {
+          if (error2 instanceof MissingFieldError) {
+            lastError = error2;
+            continue;
+          }
+          throw error2;
         }
-        throw error2;
       }
-    }
-    if (!once) {
-      throw lastError;
-    }
-    return ret;
+      if (!once) {
+        throw lastError;
+      }
+      return ret;
+    });
   }
   async sum(query) {
     let ret = void 0;