@peerbit/indexer-sqlite3 3.0.0-e6ea5c0 → 3.0.1

package/dist/assets/sqlite3/sqlite3.worker.min.js

@@ -17458,7 +17458,12 @@ var fromBase64 = (base64) => {
 };
 
 // src/sqlite3-messages.worker.ts
-var resolveValue = (value) => value.type === "simple" ? value.value : fromBase64(value.base64);
+var resolveValue = (value) => {
+  if (value.type === "simple") {
+    return value.value;
+  }
+  return value.encoding === "clone" ? value.value : fromBase64(value.base64);
+};
 
 // src/sqlite3.wasm.ts
 init_sqlite_wasm();
@@ -17625,7 +17630,20 @@ var getSqlite3 = async () => {
   }
   return sqlite3Promise;
 };
-var create = async (directory) => {
+var applyPragmas = (db, pragmas) => {
+  db.exec("PRAGMA journal_mode = WAL");
+  db.exec("PRAGMA foreign_keys = on");
+  db.exec(
+    `PRAGMA synchronous = ${(pragmas?.synchronous ?? "NORMAL").toUpperCase()}`
+  );
+  if (pragmas?.lockingMode) {
+    db.exec(`PRAGMA locking_mode = ${pragmas.lockingMode.toUpperCase()}`);
+  }
+  if (pragmas?.tempStore && pragmas.tempStore !== "DEFAULT") {
+    db.exec(`PRAGMA temp_store = ${pragmas.tempStore.toUpperCase()}`);
+  }
+};
+var create = async (directory, options) => {
   let statements = /* @__PURE__ */ new Map();
   const sqlite32 = await getSqlite3();
   let sqliteDb = void 0;
@@ -17720,8 +17738,7 @@ var create = async (directory) => {
     if (!sqliteDb) {
       throw new Error("Failed to open sqlite database");
     }
-    sqliteDb.exec("PRAGMA journal_mode = WAL");
-    sqliteDb.exec("PRAGMA foreign_keys = on");
+    applyPragmas(sqliteDb, options?.pragmas);
   };
   return {
     close,
@@ -17756,24 +17773,64 @@ var create = async (directory) => {
 };
 
 // src/sqlite3.worker.ts
+var resolveValues = (values, profile = false) => {
+  if (!values || values.length === 0) {
+    return {
+      values: void 0,
+      timing: profile ? {
+        decodeMs: 0,
+        valueCount: 0,
+        blobValueCount: 0,
+        blobBytes: 0
+      } : void 0
+    };
+  }
+  let blobBytes = 0;
+  let blobValueCount = 0;
+  const startedAt = profile ? performance.now() : 0;
+  const resolvedValues = values.map((value) => {
+    const resolved = resolveValue(value);
+    if (profile && resolved instanceof Uint8Array) {
+      blobValueCount++;
+      blobBytes += resolved.byteLength;
+    }
+    return resolved;
+  });
+  return {
+    values: resolvedValues,
+    timing: profile ? {
+      decodeMs: performance.now() - startedAt,
+      valueCount: values.length,
+      blobValueCount,
+      blobBytes
+    } : void 0
+  };
+};
 var SqliteWorkerHandler = class {
   databases = /* @__PURE__ */ new Map();
-  async create(databaseId, directory) {
-    const db = await create(directory);
+  async create(databaseId, directory, options) {
+    const db = await create(directory, options);
     this.databases.set(databaseId, db);
     return db;
   }
   async onMessage(message) {
-    if (message.type === "create") {
-      await this.create(message.databaseId, message.directory);
-    } else {
+    const profile = Boolean(message.profile);
+    const startedAt = profile ? performance.now() : 0;
+    let decodeMs = 0;
+    let valueCount = 0;
+    let blobValueCount = 0;
+    let blobBytes = 0;
+    const execute = async () => {
+      if (message.type === "create") {
+        await this.create(message.databaseId, message.directory, {
+          pragmas: message.pragmas
+        });
+        return void 0;
+      }
       const db = this.databases.get(message.databaseId);
       if (!db) {
-        if (message.type === "close") {
-          return;
-        }
-        if (message.type === "drop") {
-          return;
+        if (message.type === "close" || message.type === "drop") {
+          return void 0;
         }
         if (message.type === "status") {
           return "closed";
@@ -17784,67 +17841,126 @@ var SqliteWorkerHandler = class {
       }
       if (message.type === "exec") {
         return db.exec(message.sql);
-      } else if (message.type === "status") {
+      }
+      if (message.type === "status") {
         return db.status();
-      } else if (message.type === "prepare") {
+      }
+      if (message.type === "prepare") {
         const statementId = message.id;
         await db.prepare(message.sql, message.id);
         return statementId;
-      } else if (message.type === "close") {
+      }
+      if (message.type === "close") {
         await db.close();
         this.databases.delete(message.databaseId);
-      } else if (message.type === "drop") {
+        return void 0;
+      }
+      if (message.type === "drop") {
         await db.drop();
         this.databases.delete(message.databaseId);
-      } else if (message.type === "open") {
+        return void 0;
+      }
+      if (message.type === "open") {
         await db.open();
         this.databases.set(message.databaseId, db);
-      } else if (message.type === "run") {
-        return db.run(message.sql, message.values.map(resolveValue));
-      } else {
-        const statement = db.statements.get(message.statementId);
-        if (!statement) {
-          throw new Error(
-            "Statement not found with id: " + message.statementId
-          );
-        }
-        if (message.type === "bind") {
-          return statement.bind(message.values.map(resolveValue));
-        } else if (message.type === "finalize") {
-          return statement.finalize();
-        } else if (message.type === "reset") {
-          return statement.reset();
-        } else if (message.type === "get") {
-          return statement.get(
-            message.values ? message.values.map(resolveValue) : void 0
-          );
-        } else if (message.type === "step") {
-          return statement.step();
-        } else if (message.type === "run-statement") {
-          return statement.run(message.values.map(resolveValue));
-        } else if (message.type === "all") {
-          return statement.all(message.values.map(resolveValue));
-        } else {
-          throw new Error("Unknown statement message type: " + message["type"]);
-        }
-      }
-    }
+        return void 0;
+      }
+      if (message.type === "run") {
+        const resolved = resolveValues(message.values, profile);
+        decodeMs = resolved.timing?.decodeMs ?? 0;
+        valueCount = resolved.timing?.valueCount ?? 0;
+        blobValueCount = resolved.timing?.blobValueCount ?? 0;
+        blobBytes = resolved.timing?.blobBytes ?? 0;
+        return db.run(message.sql, resolved.values ?? []);
+      }
+      const statement = db.statements.get(message.statementId);
+      if (!statement) {
+        throw new Error("Statement not found with id: " + message.statementId);
+      }
+      if (message.type === "bind") {
+        const resolved = resolveValues(message.values, profile);
+        decodeMs = resolved.timing?.decodeMs ?? 0;
+        valueCount = resolved.timing?.valueCount ?? 0;
+        blobValueCount = resolved.timing?.blobValueCount ?? 0;
+        blobBytes = resolved.timing?.blobBytes ?? 0;
+        return statement.bind(resolved.values ?? []);
+      }
+      if (message.type === "finalize") {
+        return statement.finalize();
+      }
+      if (message.type === "reset") {
+        return statement.reset();
+      }
+      if (message.type === "get") {
+        const resolved = resolveValues(message.values, profile);
+        decodeMs = resolved.timing?.decodeMs ?? 0;
+        valueCount = resolved.timing?.valueCount ?? 0;
+        blobValueCount = resolved.timing?.blobValueCount ?? 0;
+        blobBytes = resolved.timing?.blobBytes ?? 0;
+        return statement.get(resolved.values);
+      }
+      if (message.type === "step") {
+        return statement.step();
+      }
+      if (message.type === "run-statement") {
+        const resolved = resolveValues(message.values, profile);
+        decodeMs = resolved.timing?.decodeMs ?? 0;
+        valueCount = resolved.timing?.valueCount ?? 0;
+        blobValueCount = resolved.timing?.blobValueCount ?? 0;
+        blobBytes = resolved.timing?.blobBytes ?? 0;
+        return statement.run(resolved.values ?? []);
+      }
+      if (message.type === "all") {
+        const resolved = resolveValues(message.values, profile);
+        decodeMs = resolved.timing?.decodeMs ?? 0;
+        valueCount = resolved.timing?.valueCount ?? 0;
+        blobValueCount = resolved.timing?.blobValueCount ?? 0;
+        blobBytes = resolved.timing?.blobBytes ?? 0;
+        return statement.all(resolved.values ?? []);
+      }
+      throw new Error("Unknown statement message type: " + message["type"]);
+    };
+    const execStart = profile ? performance.now() : 0;
+    const result = await execute();
+    const execMs = profile ? performance.now() - execStart - decodeMs : 0;
+    return {
+      result,
+      timing: profile ? {
+        decodeMs,
+        execMs,
+        totalMs: performance.now() - startedAt,
+        valueCount,
+        blobValueCount,
+        blobBytes
+      } : void 0
+    };
   }
 };
 var worker = new SqliteWorkerHandler();
 self.onmessage = async (messageEvent) => {
+  const profile = Boolean(messageEvent.data.profile);
+  const startedAt = profile ? performance.now() : 0;
   try {
-    const results = await worker.onMessage(messageEvent.data);
+    const response = await worker.onMessage(messageEvent.data);
     self.postMessage({
       type: "response",
       id: messageEvent.data.id,
-      result: results
+      result: response.result,
+      timing: response.timing
     });
   } catch (error2) {
     self.postMessage({
       type: "error",
       id: messageEvent.data.id,
-      message: error2?.message
+      message: error2?.message,
+      timing: profile ? {
+        decodeMs: 0,
+        execMs: 0,
+        totalMs: performance.now() - startedAt,
+        valueCount: 0,
+        blobValueCount: 0,
+        blobBytes: 0
+      } : void 0
     });
   }
 };