@peerbit/indexer-sqlite3 3.0.0-e6ea5c0 → 3.0.1

package/dist/index.min.js

@@ -20787,20 +20787,39 @@ var isUint8ArrayType = (type) => {
   }
   return false;
 };
-var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback, parentId = void 0, index) => {
+var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback, parentId = void 0, index, options) => {
   const bindableValues = [];
   let nestedCallbacks = [];
   handleNestedCallback = table.primary === false ? handleNestedCallback : (fn) => nestedCallbacks.push(fn);
+  const toInsertValue = (item, subTable) => typeof item === "function" && item instanceof Uint8Array === false ? item : subTable.isSimpleValue ? (
+    // eslint-disable-next-line new-cap
+    new subTable.ctor(item)
+  ) : Object.assign(Object.create(subTable.ctor.prototype), item);
   const handleElement = async (item, field2, parentId2, index2) => {
     const subTable = getTableFromValue(table, tables, field2, item);
-    await insert(insertFn, typeof item === "function" && item instanceof Uint8Array === false ? item : subTable.isSimpleValue ? (
-      // eslint-disable-next-line new-cap
-      new subTable.ctor(item)
-    ) : Object.assign(Object.create(subTable.ctor.prototype), item), tables, subTable, getSchema(subTable.ctor).fields, handleNestedCallback, parentId2, index2);
+    await insert(insertFn, toInsertValue(item, subTable), tables, subTable, getSchema(subTable.ctor).fields, handleNestedCallback, parentId2, index2, options);
   };
   const handleNested = async (field2, optional, parentId2) => {
     if (Array.isArray(obj[field2.key])) {
       const arr = obj[field2.key];
+      const firstItem = arr.find((item) => item != null);
+      if (parentId2 != null && arr.length > 1 && firstItem != null && options?.insertSimpleVecRows) {
+        const subTable = getTableFromValue(table, tables, field2, firstItem);
+        if (subTable.isSimpleValue) {
+          const rows = [];
+          for (let i = 0; i < arr.length; i++) {
+            const item = arr[i];
+            await insert((values) => {
+              rows.push(values);
+              return void 0;
+            }, toInsertValue(item, subTable), tables, subTable, getSchema(subTable.ctor).fields, handleNestedCallback, parentId2, i, options);
+          }
+          if (rows.length > 0) {
+            await options.insertSimpleVecRows(rows, subTable);
+          }
+          return;
+        }
+      }
       for (let i = 0; i < arr.length; i++) {
         const item = arr[i];
         await handleElement(item, field2, parentId2, i);
@@ -20868,7 +20887,9 @@ var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback,
           (fn) => nestedCallbacks.push(fn),
           void 0,
           // parentId is not defined here, we are inserting a nested object inline
-          void 0
+          void 0,
+          // index is not defined here, we are inserting a nested object inline
+          options
         );
       } else {
         nestedFields.push(field2);
@@ -20881,7 +20902,9 @@ var insert = async (insertFn, obj, tables, table, fields, handleNestedCallback,
     const isOptional = nested.type instanceof OptionKind;
     await handleNestedCallback((id) => handleNested(nested, isOptional, id));
   }
-  const thisId = await insertFn(bindableValues, table);
+  const thisId = await insertFn(bindableValues, table, {
+    requireId: nestedCallbacks.length > 0
+  });
   if (table.primary === false && nestedCallbacks.length > 0) {
     throw new Error("Unexpected");
   }
@@ -21343,7 +21366,8 @@ var _buildJoin = (table, options) => {
   }
   if (table.columns.length > 0) {
     const usedColumns = removeDuplicatesOrdered(table.columns);
-    indexedBy = options?.planner ? ` INDEXED BY ${options.planner.resolveIndex(table.table.name, usedColumns)} ` : "";
+    const usesImplicitPrimaryKeyIndex = table.type === "root" && table.table.primary !== false && usedColumns.length === 1 && usedColumns[0] === table.table.primary;
+    indexedBy = options?.planner && !usesImplicitPrimaryKeyIndex ? ` INDEXED BY ${options.planner.resolveIndex(table.table.name, usedColumns)} ` : "";
   }
   if (table.type !== "root") {
     let nonInlinedParent = table.table.parent && getNonInlinedTable(table.table.parent);
@@ -21893,12 +21917,17 @@ var generatePermutations = (list) => {
 var isFKError = (e) => {
   return e?.code === "SQLITE_CONSTRAINT_FOREIGNKEY" || e?.rc === 787 || e?.message && (e.message.includes("SQLITE_CONSTRAINT_FOREIGNKEY") || e.message.includes("FOREIGN KEY constraint failed"));
 };
+var isUniqueConstraintError = (e) => {
+  return e?.code === "SQLITE_CONSTRAINT_PRIMARYKEY" || e?.code === "SQLITE_CONSTRAINT_UNIQUE" || e?.rc === 1555 || e?.rc === 2067 || e?.message && (e.message.includes("SQLITE_CONSTRAINT_PRIMARYKEY") || e.message.includes("SQLITE_CONSTRAINT_UNIQUE") || e.message.includes("UNIQUE constraint failed") || e.message.includes("PRIMARY KEY constraint failed"));
+};
 
 // dist/src/engine.js
 var escapePathToSQLName = (path) => {
   return path.map((x) => x.replace(/[^a-zA-Z0-9]/g, "_"));
 };
 var putStatementKey = (table) => table.name + "_put";
+var insertKnownIdStatementKey = (table) => table.name + "_insert_known_id";
+var putStatementBatchNoReturnKey = (table, rows) => table.name + "_put_batch_noreturn_" + rows;
 var replaceStatementKey = (table) => table.name + "_replicate";
 var resolveChildrenStatement = (table) => table.name + "_resolve_children";
 async function safeReset(stmt) {
@@ -21940,7 +21969,20 @@ async function getIgnoreFK(stmt, values) {
     throw e;
   }
 }
-var SQLLiteIndex = class {
+var createBatchInsertSQL = (table, rows) => {
+  const columns = table.fields.map((field2) => escapeColumnName(field2.name)).join(", ");
+  const rowPlaceholder = `(${table.fields.map(() => "?").join(", ")})`;
+  return `insert into ${table.name} (${columns}) VALUES ${Array.from({
+    length: rows
+  }).map(() => rowPlaceholder).join(", ")};`;
+};
+var canUseWithoutRowId = (table) => {
+  if (table.inline || table.primary === false || !table.primaryField) {
+    return false;
+  }
+  return !/^INTEGER\b/i.test(table.primaryField.type);
+};
+var SQLiteIndex = class {
   properties;
   // SQLite writes are inherently serialized per connection.
   // We still need an explicit async barrier because our API is async and
@@ -21990,6 +22032,9 @@ var SQLLiteIndex = class {
       exec: this.properties.db.exec.bind(this.properties.db)
     });
   }
+  persisted() {
+    return this.properties.persisted ?? true;
+  }
   get tables() {
     if (this.closed) {
       throw new NotStartedError();
@@ -22053,11 +22098,14 @@ var SQLLiteIndex = class {
       if (table.inline) {
         continue;
       }
-      const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")}) strict`;
+      const tableOptions = canUseWithoutRowId(table) ? " strict, without rowid" : " strict";
+      const sqlCreateTable = `create table if not exists ${table.name} (${[...table.fields, ...table.constraints].map((s) => s.definition).join(", ")})${tableOptions}`;
       this.properties.db.exec(sqlCreateTable);
       let sqlPut = `insert into ${table.name}  (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")}) RETURNING ${table.primary};`;
+      let sqlInsertKnownId = `insert into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
       let sqlReplace = `insert or replace into ${table.name} (${table.fields.map((field2) => escapeColumnName(field2.name)).join(", ")}) VALUES (${table.fields.map((_x) => "?").join(", ")});`;
       await this.properties.db.prepare(sqlPut, putStatementKey(table));
+      await this.properties.db.prepare(sqlInsertKnownId, insertKnownIdStatementKey(table));
       await this.properties.db.prepare(sqlReplace, replaceStatementKey(table));
       if (table.parent) {
         await this.properties.db.prepare(selectChildren(table), resolveChildrenStatement(table));
@@ -22145,7 +22193,7 @@ var SQLLiteIndex = class {
     }
     return void 0;
   }
-  async put(value, _id) {
+  async put(value, _id, options) {
     return this.withWriteBarrier(async () => {
       const classOfValue = value.constructor;
       return insert(async (values, table) => {
@@ -22153,8 +22201,23 @@ var SQLLiteIndex = class {
         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);
+            const shouldReplace = options?.replace ?? true;
+            if (!shouldReplace) {
+              statement = this.properties.db.statements.get(insertKnownIdStatementKey(table));
+              try {
+                this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
+              } catch (error2) {
+                if (!isUniqueConstraintError(error2)) {
+                  throw error2;
+                }
+                await statement.reset?.();
+                statement = this.properties.db.statements.get(replaceStatementKey(table));
+                this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
+              }
+            } else {
+              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));
@@ -22169,6 +22232,17 @@ var SQLLiteIndex = class {
         }
       }, value, this.tables, resolveTable(this.scopeString ? [this.scopeString] : [], this.tables, classOfValue, true), getSchema(classOfValue).fields, (_fn) => {
         throw new Error("Unexpected");
+      }, void 0, void 0, {
+        insertSimpleVecRows: async (rows, table) => {
+          if (rows.length === 0) {
+            return;
+          }
+          const key = putStatementBatchNoReturnKey(table, rows.length);
+          const sql = createBatchInsertSQL(table, rows.length);
+          const statement = this.properties.db.statements.get(key) || await this.properties.db.prepare(sql, key);
+          const values = rows.flat();
+          this.fkMode === "race-tolerant" ? await runIgnoreFK(statement, values) : await statement.run(values);
+        }
       });
     });
   }
@@ -22389,10 +22463,11 @@ var SQLiteIndices = class _SQLiteIndices {
     if (existing) {
       return existing.index;
     }
-    const index = new SQLLiteIndex({
+    const index = new SQLiteIndex({
       db: this.properties.db,
       schema: properties.schema,
-      scope: this._scope
+      scope: this._scope,
+      persisted: await this.persisted()
     });
     await index.init(properties);
     this.indices.push({ schema: properties.schema, index });
@@ -22421,6 +22496,9 @@ var SQLiteIndices = class _SQLiteIndices {
     }
     return scope;
   }
+  persisted() {
+    return this.properties.directory != null;
+  }
   async start() {
     this.closed = false;
     if (!this.properties.parent) {
@@ -22464,12 +22542,44 @@ var SQLiteIndices = class _SQLiteIndices {
 };
 
 // dist/src/sqlite3-messages.worker.js
-var encodeValue = (value) => {
+var encodeValue = (value, protocol = "legacy") => {
   if (value instanceof Uint8Array) {
-    return { type: "uint8array", base64: toBase64(value) };
+    return protocol === "clone" ? { type: "uint8array", encoding: "clone", value } : { type: "uint8array", encoding: "base64", base64: toBase64(value) };
   }
   return { type: "simple", value };
 };
+var encodeValues = (values, protocol = "legacy") => {
+  if (!values || values.length === 0) {
+    return {
+      values,
+      metrics: {
+        encodeMs: 0,
+        valueCount: 0,
+        blobValueCount: 0,
+        blobBytes: 0
+      }
+    };
+  }
+  let blobBytes = 0;
+  let blobValueCount = 0;
+  const startedAt = performance.now();
+  const encodedValues = values.map((value) => {
+    if (value instanceof Uint8Array) {
+      blobValueCount++;
+      blobBytes += value.byteLength;
+    }
+    return encodeValue(value, protocol);
+  });
+  return {
+    values: encodedValues,
+    metrics: {
+      encodeMs: performance.now() - startedAt,
+      valueCount: values.length,
+      blobValueCount,
+      blobBytes
+    }
+  };
+};
 
 // dist/src/sqlite3.wasm.js
 init_sqlite_wasm();
@@ -22585,7 +22695,18 @@ 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;
@@ -22680,8 +22801,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,
@@ -22716,26 +22836,44 @@ var create = async (directory) => {
 };
 
 // dist/src/sqlite3.browser.js
+var DEFAULT_PROTOCOL = "clone";
+var EMPTY_ENCODE_METRICS = {
+  encodeMs: 0,
+  valueCount: 0,
+  blobValueCount: 0,
+  blobBytes: 0
+};
+var getProtocol = (options) => options?.protocol ?? DEFAULT_PROTOCOL;
 var ProxyStatement = class {
   send;
   databaseId;
   statementId;
+  sql;
+  options;
   id;
-  resolvers = {};
-  constructor(send, databaseId, statementId) {
+  needsReset = false;
+  constructor(send, databaseId, statementId, sql, options) {
     this.send = send;
     this.databaseId = databaseId;
     this.statementId = statementId;
+    this.sql = sql;
+    this.options = options;
     this.id = statementId;
   }
   async bind(values) {
+    const encoded = encodeValues(values, getProtocol(this.options));
     await this.send({
       type: "bind",
-      values: values.map(encodeValue),
+      values: encoded.values ?? [],
       id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "bind",
+      sql: this.sql,
+      ...encoded.metrics
     });
+    this.needsReset = true;
     return this;
   }
   async finalize() {
@@ -22744,60 +22882,141 @@ var ProxyStatement = class {
       id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "finalize",
+      sql: this.sql,
+      ...EMPTY_ENCODE_METRICS
     });
+    this.needsReset = false;
   }
-  get(values) {
-    return this.send({
+  async get(values) {
+    const encoded = encodeValues(values, getProtocol(this.options));
+    const result = await this.send({
       type: "get",
-      values: values ? values.map(encodeValue) : void 0,
+      values: encoded.values,
       id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "get",
+      sql: this.sql,
+      ...encoded.metrics
     });
+    this.needsReset = false;
+    return result;
   }
   async run(values) {
+    const encoded = encodeValues(values, getProtocol(this.options));
     await this.send({
       type: "run-statement",
-      values: values.map(encodeValue),
+      values: encoded.values ?? [],
       id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "run-statement",
+      sql: this.sql,
+      ...encoded.metrics
     });
+    this.needsReset = false;
   }
   async reset() {
+    if (!this.needsReset) {
+      return this;
+    }
     await this.send({
       type: "reset",
       id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "reset",
+      sql: this.sql,
+      ...EMPTY_ENCODE_METRICS
     });
+    this.needsReset = false;
     return this;
   }
   async all(values) {
-    let id = v4_default();
-    const results = await this.send({
+    const encoded = encodeValues(values, getProtocol(this.options));
+    const result = await this.send({
       type: "all",
-      values: values.map(encodeValue),
-      id,
+      values: encoded.values ?? [],
+      id: v4_default(),
       databaseId: this.databaseId,
       statementId: this.statementId
+    }, {
+      requestType: "all",
+      sql: this.sql,
+      ...encoded.metrics
     });
-    return results;
+    this.needsReset = false;
+    return result;
   }
 };
 var ProxyDatabase = class {
-  send;
+  postMessage;
+  options;
   statements = /* @__PURE__ */ new Map();
-  resolvers = {};
   databaseId;
-  constructor(send) {
-    this.send = send;
+  directory;
+  constructor(postMessage, options) {
+    this.postMessage = postMessage;
+    this.options = options;
+  }
+  async send(message, metrics) {
+    const startedAt = performance.now();
+    const protocol = getProtocol(this.options);
+    const shouldProfile = Boolean(this.options?.profile || this.options?.onProfile);
+    const requestType = metrics?.requestType ?? message.type;
+    try {
+      const response = await this.postMessage({
+        ...message,
+        protocol,
+        profile: shouldProfile
+      });
+      this.options?.onProfile?.({
+        requestType,
+        protocol,
+        databaseId: this.databaseId,
+        databaseDirectory: this.directory,
+        sql: metrics?.sql ?? ("sql" in message && typeof message.sql === "string" ? message.sql : void 0),
+        clientEncodeMs: metrics?.encodeMs ?? 0,
+        clientRoundTripMs: performance.now() - startedAt,
+        valueCount: metrics?.valueCount ?? 0,
+        blobValueCount: metrics?.blobValueCount ?? 0,
+        blobBytes: metrics?.blobBytes ?? 0,
+        worker: response.timing
+      });
+      return response.result;
+    } catch (error2) {
+      const responseError = error2;
+      this.options?.onProfile?.({
+        requestType,
+        protocol,
+        databaseId: this.databaseId,
+        databaseDirectory: this.directory,
+        sql: metrics?.sql ?? ("sql" in message && typeof message.sql === "string" ? message.sql : void 0),
+        clientEncodeMs: metrics?.encodeMs ?? 0,
+        clientRoundTripMs: performance.now() - startedAt,
+        valueCount: metrics?.valueCount ?? 0,
+        blobValueCount: metrics?.blobValueCount ?? 0,
+        blobBytes: metrics?.blobBytes ?? 0,
+        worker: responseError?.timing
+      });
+      if (responseError?.type === "error") {
+        throw new Error(responseError.message);
+      }
+      throw error2;
+    }
   }
   async init(directory) {
     this.databaseId = v4_default();
+    this.directory = directory;
     return this.send({
       type: "create",
       directory,
+      pragmas: this.options?.pragmas,
       databaseId: this.databaseId,
       id: v4_default()
     });
@@ -22824,7 +23043,7 @@ var ProxyDatabase = class {
       id: v4_default(),
       databaseId: this.databaseId
     });
-    const statement = new ProxyStatement(this.send, this.databaseId, statementId);
+    const statement = new ProxyStatement(this.send.bind(this), this.databaseId, statementId, sql, this.options);
     this.statements.set(statementId, statement);
     if (id != null) {
       this.statements.set(id, statement);
@@ -22861,16 +23080,16 @@ var init = async () => {
   if (initialized) {
     return initialized;
   }
-  let worker = new Worker(new URL("/peerbit/sqlite3/sqlite3.worker.min.js", import.meta.url), { type: "module" });
-  let resolvers = {};
-  let send = (message) => {
+  const worker = new Worker(new URL("/peerbit/sqlite3/sqlite3.worker.min.js", import.meta.url), { type: "module" });
+  const resolvers = {};
+  const postMessage = (message) => {
     const promise = new Promise((resolve, reject) => {
       resolvers[message.id] = { resolve, reject };
     });
     worker.postMessage(message);
     return promise.finally(() => delete resolvers[message.id]);
   };
-  let isReady = pDefer();
+  const isReady = pDefer();
   worker.onmessage = async (ev) => {
     const message = ev.data;
     if (message.type === "ready") {
@@ -22878,14 +23097,17 @@ var init = async () => {
       return;
     }
     const resolver = resolvers[message.id];
+    if (!resolver) {
+      return;
+    }
     if (message.type === "error") {
-      resolver.reject(new Error(message.message));
-    } else if (message.type === "response") {
-      resolver.resolve(message.result);
+      resolver.reject(message);
+    } else {
+      resolver.resolve(message);
     }
   };
-  const create4 = async (directory) => {
-    const db = new ProxyDatabase(send);
+  const create4 = async (directory, options) => {
+    const db = new ProxyDatabase(postMessage, options);
     await isReady.promise;
     await db.init(directory);
     await db.open();
@@ -22899,12 +23121,11 @@ var init = async () => {
     }
   };
 };
-var create2 = (directory) => {
+var create2 = (directory, options) => {
   if (directory) {
-    return init().then((creator) => creator.create(directory));
-  } else {
-    return create();
+    return init().then((creator) => creator.create(directory, options));
   }
+  return create(directory, options);
 };
 
 // dist/src/index.js
@@ -22913,14 +23134,17 @@ var encodeName = (name) => {
   writer.string(name);
   return toBase58(sha256Sync(writer.finalize()));
 };
-var create3 = async (directory) => {
-  const db = await create2(directory);
+var create3 = async (directory, options) => {
+  const db = await create2(directory, options);
   return new SQLiteIndices({ db, directory });
 };
+var createDatabase = (directory, options) => create2(directory, options);
 export {
-  SQLLiteIndex,
+  SQLiteIndex as SQLLiteIndex,
+  SQLiteIndex,
   SQLiteIndices,
   create3 as create,
+  createDatabase,
   encodeName
 };
 //# sourceMappingURL=index.min.js.map