rivetkit 0.0.0-stack-chore-sync-engine-changes-from-enterprise-mszropyy.677d526 → 0.0.0-sync-sqlite.0ed739a

package/dist/tsup/agent-os/index.cjs

@@ -420,7 +420,7 @@ function isRivetErrorCode(error, group, code) {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "0.0.0-stack-chore-sync-engine-changes-from-enterprise-mszropyy.677d526",
+  version: "0.0.0-sync-sqlite.0ed739a",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -921,6 +921,38 @@ function validateTransactionName(name) {
     throw new Error("db.transaction() name must not be empty");
   }
 }
+function isPromiseLike(value) {
+  return typeof value === "object" && value !== null || typeof value === "function" ? typeof value.then === "function" : false;
+}
+function runSqliteTransactionSync(database, callback, options) {
+  validateTransactionTimeout(options == null ? void 0 : options.timeout);
+  validateTransactionName(options == null ? void 0 : options.name);
+  if (!database.beginTransactionSync) {
+    throw new Error(
+      "Synchronous SQLite transactions are only available in the Node.js native runtime."
+    );
+  }
+  const transaction = database.beginTransactionSync(
+    options == null ? void 0 : options.timeout,
+    options == null ? void 0 : options.name
+  );
+  try {
+    const result = callback(transaction);
+    if (isPromiseLike(result)) {
+      throw new Error(
+        "db.transactionSync() callback must complete synchronously and must not return a promise."
+      );
+    }
+    transaction.commitSync();
+    return result;
+  } catch (error) {
+    try {
+      transaction.rollbackSync();
+    } catch (e3) {
+    }
+    throw error;
+  }
+}
 function isSqliteBindingValue(value) {
   if (value === null || typeof value === "number" || typeof value === "string" || typeof value === "bigint" || value instanceof Uint8Array) {
     return true;
@@ -983,6 +1015,7 @@ function db({
       const db2 = await nativeDatabaseProvider.open(ctx.actorId);
       let closed = false;
       let manualTransactionWarned = false;
+      let synchronousTransactionActive = false;
       const ensureOpen = () => {
         if (closed) {
           throw new Error(
@@ -990,16 +1023,24 @@ function db({
           );
         }
       };
+      const ensureSynchronousTransactionClient = (transactionScoped) => {
+        if (!transactionScoped && synchronousTransactionActive) {
+          throw new Error(
+            "Use the transaction callback's tx value for queries inside db.transactionSync()."
+          );
+        }
+      };
       const createClient = (target, transactionScoped = false, stateTransactionContext) => {
         const client2 = {
           execute: async (query, ...args) => {
             var _a, _b, _c, _d;
             ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
             if (!transactionScoped && warnOnManualTransactions && !manualTransactionWarned && !hasMultipleStatements(query) && isManualTransactionControl(query)) {
               manualTransactionWarned = true;
               getLogger("database").warn(
                 { actorId: ctx.actorId },
-                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
+                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
               );
             }
             const kvReadsBefore = _nullishCoalesce(((_a = ctx.metrics) == null ? void 0 : _a.totalKvReads), () => ( 0));
@@ -1045,8 +1086,66 @@ function db({
               }
             }
           },
+          executeSync: (query, ...args) => {
+            var _a, _b, _c, _d;
+            ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
+            if (!target.executeSync) {
+              throw new Error(
+                "Synchronous SQLite queries are only available in the Node.js native runtime."
+              );
+            }
+            if (!transactionScoped && warnOnManualTransactions && !manualTransactionWarned && !hasMultipleStatements(query) && isManualTransactionControl(query)) {
+              manualTransactionWarned = true;
+              getLogger("database").warn(
+                { actorId: ctx.actorId },
+                "Manual cross-call SQLite transactions can interleave with other actor work. Use db.transaction() or db.transactionSync() for coordinated transactions. Set warnOnManualTransactions: false in your db(...) configuration to disable this warning."
+              );
+            }
+            const kvReadsBefore = _nullishCoalesce(((_a = ctx.metrics) == null ? void 0 : _a.totalKvReads), () => ( 0));
+            const kvWritesBefore = _nullishCoalesce(((_b = ctx.metrics) == null ? void 0 : _b.totalKvWrites), () => ( 0));
+            const start = performance.now();
+            try {
+              if (args.length > 0) {
+                const bindings = args.length === 1 && isSqliteBindingObject(args[0]) ? toSqliteBindings(args[0]) : toSqliteBindings(args);
+                const { rows, columns } = target.executeSync(
+                  query,
+                  bindings
+                );
+                return rows.map(
+                  (row) => rowToObject(row, columns)
+                );
+              }
+              if (!hasMultipleStatements(query)) {
+                const { rows, columns } = target.executeSync(
+                  query,
+                  void 0
+                );
+                return rows.map(
+                  (row) => rowToObject(row, columns)
+                );
+              }
+              return execMultiStatementSync(target, query);
+            } finally {
+              const durationMs = performance.now() - start;
+              (_c = ctx.metrics) == null ? void 0 : _c.trackSql(query, durationMs);
+              if (ctx.metrics) {
+                const kvReads = ctx.metrics.totalKvReads - kvReadsBefore;
+                const kvWrites = ctx.metrics.totalKvWrites - kvWritesBefore;
+                (_d = ctx.log) == null ? void 0 : _d.debug({
+                  msg: "sql query",
+                  query: query.slice(0, 120),
+                  durationMs,
+                  kvReads,
+                  kvWrites
+                });
+              }
+            }
+          },
           transaction: async (callback, options) => {
             var _a, _b;
+            ensureOpen();
+            ensureSynchronousTransactionClient(transactionScoped);
             validateTransactionTimeout(options == null ? void 0 : options.timeout);
             validateTransactionName(options == null ? void 0 : options.name);
             if (transactionScoped && ((_a = options == null ? void 0 : options.experimental) == null ? void 0 : _a.includeState)) {
@@ -1082,7 +1181,7 @@ function db({
               } catch (error) {
                 try {
                   await transaction.rollback();
-                } catch (e3) {
+                } catch (e4) {
                 }
                 throw error;
               }
@@ -1092,6 +1191,33 @@ function db({
               }
             }
           },
+          transactionSync: (callback, options) => {
+            ensureOpen();
+            if (transactionScoped || synchronousTransactionActive) {
+              throw new Error(
+                "Nested synchronous SQLite transactions are not supported."
+              );
+            }
+            return runSqliteTransactionSync(
+              db2,
+              (transaction) => {
+                const transactionClient = createClient(
+                  transaction,
+                  true
+                );
+                const tx = {
+                  executeSync: transactionClient.executeSync
+                };
+                synchronousTransactionActive = true;
+                try {
+                  return callback(tx);
+                } finally {
+                  synchronousTransactionActive = false;
+                }
+              },
+              options
+            );
+          },
           close: async () => {
             if (!closed) {
               closed = true;
@@ -1143,6 +1269,22 @@ async function execMultiStatement(db2, query) {
   });
   return results;
 }
+function execMultiStatementSync(db2, query) {
+  if (!db2.execSync) {
+    throw new Error(
+      "Synchronous SQLite queries are only available in the Node.js native runtime."
+    );
+  }
+  const results = [];
+  let columnNames = null;
+  db2.execSync(query, (row, columns) => {
+    if (!columnNames) {
+      columnNames = columns;
+    }
+    results.push(rowToObject(row, columnNames));
+  });
+  return results;
+}
 async function withMigrationSavepoint(client, callback) {
   return await client.transaction(
     async (transaction) => {