rivetkit 2.1.5 → 2.1.6-rc.1

package/dist/tsup/serve-test-suite/mod.js

@@ -1,6 +1,11 @@
 import {
   hibernationActor,
   logger,
+  manyQueueActionParentActor,
+  manyQueueChildActor,
+  manyQueueRunParentActor,
+  queueActor,
+  queueLimitedActor,
   runWithEarlyExit,
   runWithError,
   runWithQueueConsumer,
@@ -9,48 +14,68 @@ import {
   sleep,
   sleepWithLongRpc,
   sleepWithNoSleepOption,
+  sleepWithPreventSleep,
   sleepWithRawHttp,
   sleepWithRawWebSocket,
+  sleepWithWaitUntilMessage,
   workflowAccessActor,
+  workflowCompleteActor,
   workflowCounterActor,
+  workflowDestroyActor,
+  workflowErrorHookActor,
+  workflowErrorHookEffectsActor,
+  workflowErrorHookSleepActor,
+  workflowFailedStepActor,
+  workflowNestedJoinActor,
+  workflowNestedLoopActor,
+  workflowNestedRaceActor,
   workflowQueueActor,
   workflowSleepActor,
+  workflowSpawnChildActor,
+  workflowSpawnParentActor,
   workflowStopTeardownActor
-} from "../chunk-R5OQUSLN.js";
-import "../chunk-WY2SHWXQ.js";
-import "../chunk-S662Y6ZU.js";
+} from "../chunk-DK46YYCJ.js";
+import "../chunk-SVHJSM2E.js";
 import {
   db as db2,
   integer,
   mod_exports,
   sqliteTable,
   text
-} from "../chunk-VKVNIQRQ.js";
+} from "../chunk-K7MVU5SI.js";
+import {
+  setup
+} from "../chunk-JJSPHLJN.js";
 import {
   actor,
   event,
-  queue,
-  setup
-} from "../chunk-ZPWOYQHN.js";
+  queue
+} from "../chunk-UQZRMTM3.js";
 import {
   createFileSystemOrMemoryDriver
-} from "../chunk-SRIM3GHD.js";
-import "../chunk-JPXO2H55.js";
-import "../chunk-2OK7S6QF.js";
+} from "../chunk-EGWXXBZV.js";
+import "../chunk-YGYGANCA.js";
+import "../chunk-EONWXYMN.js";
+import "../chunk-WW27B6DM.js";
+import "../chunk-I5I6OALK.js";
 import {
   db
-} from "../chunk-KJSYAUOM.js";
-import "../chunk-N4KRDJ56.js";
+} from "../chunk-MLK3GY6P.js";
+import {
+  AsyncMutex,
+  toSqliteBindings
+} from "../chunk-GFGRBYO2.js";
 import {
   buildManagerRouter
-} from "../chunk-MIX2KB6U.js";
+} from "../chunk-C4EB42ET.js";
+import "../chunk-PQWI44WD.js";
 import "../chunk-LXUQ667X.js";
-import "../chunk-TADUYCHF.js";
-import "../chunk-EIATSBYZ.js";
+import "../chunk-C22JYHVT.js";
+import "../chunk-VWYO36X4.js";
 import {
   ActorError,
   UserError
-} from "../chunk-7HTNH26M.js";
+} from "../chunk-AKUJ5OTO.js";
 import "../chunk-424PT5DM.js";
 
 // src/serve-test-suite/mod.ts
@@ -361,10 +386,7 @@ var dbActorRaw = actor({
   actions: {
     configureDisconnectInsert: (c, enabled, delayMs) => {
       c.state.disconnectInsertEnabled = enabled;
-      c.state.disconnectInsertDelayMs = Math.max(
-        0,
-        Math.floor(delayMs)
-      );
+      c.state.disconnectInsertDelayMs = Math.max(0, Math.floor(delayMs));
     },
     getDisconnectInsertCount: async (c) => {
       var _a;
@@ -386,9 +408,7 @@ var dbActorRaw = actor({
       return { id: results[0].id };
     },
     getValues: async (c) => {
-      const results = await c.db.execute(
-        `SELECT * FROM test_data ORDER BY id`
-      );
+      const results = await c.db.execute(`SELECT * FROM test_data ORDER BY id`);
       return results;
     },
     getValue: async (c, id) => {
@@ -520,7 +540,9 @@ var dbActorRaw = actor({
       for (let i = 0; i < normalizedChurnCount; i++) {
         const id = i % normalizedSeedCount + 1;
         if (i % 9 === 0) {
-          await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+          await c.db.execute(
+            `DELETE FROM test_data WHERE id = ${id}`
+          );
         } else {
           const payload = makePayload(768 + i % 7 * 96);
           await c.db.execute(
@@ -654,10 +676,7 @@ var dbActorDrizzle = actor({
   actions: {
     configureDisconnectInsert: (c, enabled, delayMs) => {
       c.state.disconnectInsertEnabled = enabled;
-      c.state.disconnectInsertDelayMs = Math.max(
-        0,
-        Math.floor(delayMs)
-      );
+      c.state.disconnectInsertDelayMs = Math.max(0, Math.floor(delayMs));
     },
     getDisconnectInsertCount: async (c) => {
       var _a;
@@ -679,9 +698,7 @@ var dbActorDrizzle = actor({
       return { id: results[0].id };
     },
     getValues: async (c) => {
-      const results = await c.db.execute(
-        `SELECT * FROM test_data ORDER BY id`
-      );
+      const results = await c.db.execute(`SELECT * FROM test_data ORDER BY id`);
       return results;
     },
     getValue: async (c, id) => {
@@ -814,7 +831,9 @@ var dbActorDrizzle = actor({
       for (let i = 0; i < normalizedChurnCount; i++) {
         const id = i % normalizedSeedCount + 1;
         if (i % 9 === 0) {
-          await c.db.execute(`DELETE FROM test_data WHERE id = ${id}`);
+          await c.db.execute(
+            `DELETE FROM test_data WHERE id = ${id}`
+          );
         } else {
           const payload = makePayload2(768 + i % 7 * 96);
           await c.db.execute(
@@ -1142,6 +1161,9 @@ var connStateActor = actor({
 // fixtures/driver-test-suite/counter.ts
 var counter = actor({
   state: { count: 0 },
+  events: {
+    newCount: event()
+  },
   actions: {
     increment: (c, x) => {
       c.state.count += x;
@@ -1168,6 +1190,9 @@ var counterConn = actor({
     connectionCount: 0
   },
   connState: { count: 0 },
+  events: {
+    newCount: event()
+  },
   onConnect: (c, conn) => {
     c.state.connectionCount += 1;
   },
@@ -1414,6 +1439,20 @@ var kvActor = actor({
         value
       }));
     },
+    listTextRange: async (c, start, end, options) => {
+      const results = await c.kv.listRange(start, end, {
+        keyType: "text",
+        ...options
+      });
+      return results.map(([key, value]) => ({
+        key,
+        value
+      }));
+    },
+    deleteTextRange: async (c, start, end) => {
+      await c.kv.deleteRange(start, end);
+      return true;
+    },
     roundtripArrayBuffer: async (c, key, values) => {
       const buffer = new Uint8Array(values).buffer;
       await c.kv.put(key, buffer, { type: "arrayBuffer" });
@@ -1446,7 +1485,9 @@ var largePayloadActor = actor({
     getLargeResponse: (c, itemCount) => {
       const items = [];
       for (let i = 0; i < itemCount; i++) {
-        items.push(`Item ${i} with some additional text to increase size`);
+        items.push(
+          `Item ${i} with some additional text to increase size`
+        );
       }
       return { items };
     },
@@ -1481,7 +1522,9 @@ var largePayloadConnActor = actor({
     getLargeResponse: (c, itemCount) => {
       const items = [];
       for (let i = 0; i < itemCount; i++) {
-        items.push(`Item ${i} with some additional text to increase size`);
+        items.push(
+          `Item ${i} with some additional text to increase size`
+        );
       }
       return { items };
     },
@@ -1595,209 +1638,6 @@ var metadataActor = actor({
   }
 });
 
-// fixtures/driver-test-suite/queue.ts
-var queueSchemas = {
-  greeting: queue(),
-  self: queue(),
-  a: queue(),
-  b: queue(),
-  c: queue(),
-  one: queue(),
-  two: queue(),
-  missing: queue(),
-  abort: queue(),
-  tasks: queue(),
-  timeout: queue(),
-  nowait: queue(),
-  twice: queue()
-};
-var queueActor = actor({
-  state: {},
-  queues: queueSchemas,
-  actions: {
-    receiveOne: async (c, name, opts) => {
-      const message = await c.queue.next({
-        names: [name],
-        timeout: opts == null ? void 0 : opts.timeout
-      });
-      if (!message) {
-        return null;
-      }
-      return { name: message.name, body: message.body };
-    },
-    receiveMany: async (c, names, opts) => {
-      const messages = await c.queue.nextBatch({
-        names,
-        count: opts == null ? void 0 : opts.count,
-        timeout: opts == null ? void 0 : opts.timeout
-      });
-      return messages.map((message) => ({
-        name: message.name,
-        body: message.body
-      }));
-    },
-    receiveRequest: async (c, request) => {
-      const messages = await c.queue.nextBatch(request);
-      return messages.map((message) => ({
-        name: message.name,
-        body: message.body
-      }));
-    },
-    tryReceiveMany: async (c, request) => {
-      const messages = await c.queue.tryNextBatch(request);
-      return messages.map((message) => ({
-        name: message.name,
-        body: message.body
-      }));
-    },
-    receiveWithIterator: async (c, name) => {
-      for await (const message of c.queue.iter({ names: [name] })) {
-        return { name: message.name, body: message.body };
-      }
-      return null;
-    },
-    receiveWithAsyncIterator: async (c) => {
-      for await (const message of c.queue.iter()) {
-        return { name: message.name, body: message.body };
-      }
-      return null;
-    },
-    sendToSelf: async (c, name, body) => {
-      const client = c.client();
-      const handle = client.queueActor.getForId(c.actorId);
-      await handle.send(name, body);
-      return true;
-    },
-    waitForAbort: async (c) => {
-      setTimeout(() => {
-        c.destroy();
-      }, 10);
-      await c.queue.next({ names: ["abort"], timeout: 1e4 });
-      return true;
-    },
-    waitForSignalAbort: async (c) => {
-      const controller = new AbortController();
-      controller.abort();
-      try {
-        await c.queue.next({
-          names: ["abort"],
-          timeout: 1e4,
-          signal: controller.signal
-        });
-        return { ok: false };
-      } catch (error) {
-        const actorError = error;
-        return { group: actorError.group, code: actorError.code };
-      }
-    },
-    waitForActorAbortWithSignal: async (c) => {
-      const controller = new AbortController();
-      setTimeout(() => {
-        c.destroy();
-      }, 10);
-      try {
-        await c.queue.next({
-          names: ["abort"],
-          timeout: 1e4,
-          signal: controller.signal
-        });
-        return { ok: false };
-      } catch (error) {
-        const actorError = error;
-        return { group: actorError.group, code: actorError.code };
-      }
-    },
-    iterWithSignalAbort: async (c) => {
-      const controller = new AbortController();
-      controller.abort();
-      for await (const _message of c.queue.iter({
-        names: ["abort"],
-        signal: controller.signal
-      })) {
-        return { ok: false };
-      }
-      return { ok: true };
-    },
-    receiveAndComplete: async (c, name) => {
-      const message = await c.queue.next({
-        names: [name],
-        completable: true
-      });
-      if (!message) {
-        return null;
-      }
-      await message.complete({ echo: message.body });
-      return { name: message.name, body: message.body };
-    },
-    receiveWithoutComplete: async (c, name) => {
-      const message = await c.queue.next({
-        names: [name],
-        completable: true
-      });
-      if (!message) {
-        return null;
-      }
-      return { name: message.name, body: message.body };
-    },
-    receiveManualThenNextWithoutComplete: async (c, name) => {
-      const message = await c.queue.next({
-        names: [name],
-        completable: true
-      });
-      if (!message) {
-        return { ok: false, reason: "no_message" };
-      }
-      try {
-        await c.queue.next({ names: [name], timeout: 0 });
-        c.destroy();
-        return { ok: false, reason: "next_succeeded" };
-      } catch (error) {
-        c.destroy();
-        const actorError = error;
-        return { group: actorError.group, code: actorError.code };
-      }
-    },
-    receiveAndCompleteTwice: async (c, name) => {
-      const message = await c.queue.next({
-        names: [name],
-        completable: true
-      });
-      if (!message) {
-        return null;
-      }
-      await message.complete({ ok: true });
-      try {
-        await message.complete({ ok: true });
-        return { ok: false };
-      } catch (error) {
-        const actorError = error;
-        return { group: actorError.group, code: actorError.code };
-      }
-    },
-    receiveWithoutCompleteMethod: async (c, name) => {
-      const message = await c.queue.next({
-        names: [name],
-        completable: true
-      });
-      return {
-        hasComplete: message !== void 0 && typeof message.complete === "function"
-      };
-    }
-  }
-});
-var queueLimitedActor = actor({
-  state: {},
-  queues: {
-    message: queue(),
-    oversize: queue()
-  },
-  actions: {},
-  options: {
-    maxQueueSize: 1,
-    maxQueueMessageSize: 64
-  }
-});
-
 // fixtures/driver-test-suite/raw-http.ts
 import { Hono } from "hono";
 var rawHttpActor = actor({
@@ -2455,6 +2295,270 @@ var connErrorSerializationActor = actor({
   }
 });
 
+// fixtures/driver-test-suite/db-kv-stats.ts
+var FILE_TAGS = { 0: "main", 1: "journal", 2: "wal", 3: "shm" };
+function decodeKey(key) {
+  if (key.length < 4 || key[0] !== 8 || key[1] !== 1) {
+    return `unknown(${Array.from(key).join(",")})`;
+  }
+  const prefix = key[2];
+  const fileTag = FILE_TAGS[key[3]] ?? `file${key[3]}`;
+  if (prefix === 0) {
+    return `meta:${fileTag}`;
+  }
+  if (prefix === 1 && key.length === 8) {
+    const chunkIndex = key[4] << 24 | key[5] << 16 | key[6] << 8 | key[7];
+    return `chunk:${fileTag}[${chunkIndex}]`;
+  }
+  return `unknown(${Array.from(key).join(",")})`;
+}
+function instrumentedKvStore(kv, stats, log) {
+  return {
+    get: async (key) => {
+      stats.getBatchCalls++;
+      stats.getBatchKeys++;
+      log.push({ op: "get", keys: [decodeKey(key)] });
+      const results = await kv.batchGet([key]);
+      return results[0] ?? null;
+    },
+    getBatch: async (keys) => {
+      stats.getBatchCalls++;
+      stats.getBatchKeys += keys.length;
+      log.push({ op: "getBatch", keys: keys.map(decodeKey) });
+      return await kv.batchGet(keys);
+    },
+    put: async (key, value) => {
+      stats.putBatchCalls++;
+      stats.putBatchEntries++;
+      log.push({ op: "put", keys: [decodeKey(key)] });
+      await kv.batchPut([[key, value]]);
+    },
+    putBatch: async (entries) => {
+      stats.putBatchCalls++;
+      stats.putBatchEntries += entries.length;
+      log.push({ op: "putBatch", keys: entries.map(([k]) => decodeKey(k)) });
+      await kv.batchPut(entries);
+    },
+    deleteBatch: async (keys) => {
+      stats.deleteBatchCalls++;
+      log.push({ op: "deleteBatch", keys: keys.map(decodeKey) });
+      await kv.batchDelete(keys);
+    }
+  };
+}
+var perActorData = /* @__PURE__ */ new Map();
+function getOrCreateData(actorId) {
+  let d = perActorData.get(actorId);
+  if (!d) {
+    d = {
+      stats: { getBatchCalls: 0, getBatchKeys: 0, putBatchCalls: 0, putBatchEntries: 0, deleteBatchCalls: 0 },
+      log: []
+    };
+    perActorData.set(actorId, d);
+  }
+  return d;
+}
+var provider = {
+  createClient: async (ctx) => {
+    if (!ctx.sqliteVfs) {
+      throw new Error("SqliteVfs instance not provided in context.");
+    }
+    const data = getOrCreateData(ctx.actorId);
+    const kvStore = instrumentedKvStore(ctx.kv, data.stats, data.log);
+    const db3 = await ctx.sqliteVfs.open(ctx.actorId, kvStore);
+    let closed = false;
+    const mutex = new AsyncMutex();
+    const ensureOpen = () => {
+      if (closed) throw new Error("database is closed");
+    };
+    return {
+      execute: async (query, ...args) => {
+        return await mutex.run(async () => {
+          ensureOpen();
+          if (args.length > 0) {
+            const bindings = toSqliteBindings(args);
+            const token = query.trimStart().slice(0, 16).toUpperCase();
+            const returnsRows = token.startsWith("SELECT") || token.startsWith("PRAGMA") || token.startsWith("WITH");
+            if (returnsRows) {
+              const { rows, columns } = await db3.query(query, bindings);
+              return rows.map((row) => {
+                const rowObj = {};
+                for (let i = 0; i < columns.length; i++) {
+                  rowObj[columns[i]] = row[i];
+                }
+                return rowObj;
+              });
+            }
+            await db3.run(query, bindings);
+            return [];
+          }
+          const results = [];
+          let columnNames = null;
+          await db3.exec(query, (row, columns) => {
+            if (!columnNames) columnNames = columns;
+            const rowObj = {};
+            for (let i = 0; i < row.length; i++) {
+              rowObj[columnNames[i]] = row[i];
+            }
+            results.push(rowObj);
+          });
+          return results;
+        });
+      },
+      close: async () => {
+        const shouldClose = await mutex.run(async () => {
+          if (closed) return false;
+          closed = true;
+          return true;
+        });
+        if (shouldClose) {
+          await db3.close();
+        }
+      }
+    };
+  },
+  onMigrate: async (client) => {
+    await client.execute(`
+			CREATE TABLE IF NOT EXISTS counter (
+				id INTEGER PRIMARY KEY,
+				count INTEGER NOT NULL DEFAULT 0
+			)
+		`);
+    await client.execute(`INSERT OR IGNORE INTO counter (id, count) VALUES (1, 0)`);
+  },
+  onDestroy: async (client) => {
+    await client.close();
+  }
+};
+var dbKvStatsActor = actor({
+  state: {},
+  db: provider,
+  actions: {
+    warmUp: async (c) => {
+      await c.db.execute(`UPDATE counter SET count = count + 1 WHERE id = 1`);
+      await c.db.execute(`UPDATE counter SET count = count + 1 WHERE id = 1`);
+      const data = getOrCreateData(c.actorId);
+      data.stats.getBatchCalls = 0;
+      data.stats.getBatchKeys = 0;
+      data.stats.putBatchCalls = 0;
+      data.stats.putBatchEntries = 0;
+      data.stats.deleteBatchCalls = 0;
+      data.log.length = 0;
+    },
+    resetStats: (c) => {
+      const data = getOrCreateData(c.actorId);
+      data.stats.getBatchCalls = 0;
+      data.stats.getBatchKeys = 0;
+      data.stats.putBatchCalls = 0;
+      data.stats.putBatchEntries = 0;
+      data.stats.deleteBatchCalls = 0;
+      data.log.length = 0;
+    },
+    getStats: (c) => {
+      return { ...getOrCreateData(c.actorId).stats };
+    },
+    getLog: (c) => {
+      return getOrCreateData(c.actorId).log;
+    },
+    increment: async (c) => {
+      await c.db.execute(`UPDATE counter SET count = count + 1 WHERE id = 1`);
+    },
+    getCount: async (c) => {
+      var _a;
+      const rows = await c.db.execute(
+        `SELECT count FROM counter WHERE id = 1`
+      );
+      return ((_a = rows[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    incrementAndRead: async (c) => {
+      var _a;
+      await c.db.execute(`UPDATE counter SET count = count + 1 WHERE id = 1`);
+      const rows = await c.db.execute(
+        `SELECT count FROM counter WHERE id = 1`
+      );
+      return ((_a = rows[0]) == null ? void 0 : _a.count) ?? 0;
+    },
+    insertWithIndex: async (c) => {
+      await c.db.execute(`
+				CREATE TABLE IF NOT EXISTS indexed_data (
+					id INTEGER PRIMARY KEY,
+					value TEXT NOT NULL
+				)
+			`);
+      await c.db.execute(`
+				CREATE INDEX IF NOT EXISTS idx_indexed_data_value ON indexed_data(value)
+			`);
+      await c.db.execute(
+        `INSERT INTO indexed_data (value) VALUES (?)`,
+        `row-${Date.now()}`
+      );
+    },
+    rollbackTest: async (c) => {
+      await c.db.execute(`
+				CREATE TABLE IF NOT EXISTS rollback_test (
+					id INTEGER PRIMARY KEY,
+					value TEXT NOT NULL
+				)
+			`);
+      await c.db.execute(`
+				BEGIN;
+				INSERT INTO rollback_test (value) VALUES ('should-not-persist');
+				ROLLBACK;
+			`);
+    },
+    multiStmtTx: async (c) => {
+      await c.db.execute(`
+				CREATE TABLE IF NOT EXISTS multi_stmt (
+					id INTEGER PRIMARY KEY,
+					value TEXT NOT NULL
+				)
+			`);
+      await c.db.execute(`
+				BEGIN;
+				INSERT INTO multi_stmt (value) VALUES ('row-a');
+				INSERT INTO multi_stmt (value) VALUES ('row-b');
+				COMMIT;
+			`);
+    },
+    bulkInsertLarge: async (c) => {
+      await c.db.execute(`
+				CREATE TABLE IF NOT EXISTS bulk_data (
+					id INTEGER PRIMARY KEY,
+					payload TEXT NOT NULL
+				)
+			`);
+      const pad = "x".repeat(4e3);
+      const stmts = ["BEGIN;"];
+      for (let i = 0; i < 200; i++) {
+        const escaped = `bulk-${i}-${pad}`.replace(/'/g, "''");
+        stmts.push(`INSERT INTO bulk_data (payload) VALUES ('${escaped}');`);
+      }
+      stmts.push("COMMIT;");
+      await c.db.execute(stmts.join("\n"));
+    },
+    getRowCount: async (c) => {
+      var _a;
+      const rows = await c.db.execute(
+        `SELECT COUNT(*) as cnt FROM bulk_data`
+      );
+      return ((_a = rows[0]) == null ? void 0 : _a.cnt) ?? 0;
+    },
+    runIntegrityCheck: async (c) => {
+      var _a;
+      const rows = await c.db.execute(
+        `PRAGMA integrity_check`
+      );
+      return ((_a = rows[0]) == null ? void 0 : _a.integrity_check) ?? "unknown";
+    },
+    triggerSleep: (c) => {
+      c.sleep();
+    }
+  },
+  options: {
+    sleepTimeout: 100
+  }
+});
+
 // fixtures/driver-test-suite/registry.ts
 var registry = setup({
   use: {
@@ -2466,12 +2570,16 @@ var registry = setup({
     counterWithLifecycle,
     // From scheduled.ts
     scheduled,
+    // From sandbox.ts
+    // dockerSandboxActor,
     // From sleep.ts
     sleep,
     sleepWithLongRpc,
     sleepWithRawHttp,
     sleepWithRawWebSocket,
     sleepWithNoSleepOption,
+    sleepWithPreventSleep,
+    sleepWithWaitUntilMessage,
     // From error-handling.ts
     errorHandlingActor,
     customTimeoutActor,
@@ -2482,6 +2590,9 @@ var registry = setup({
     // From queue.ts
     queueActor,
     queueLimitedActor,
+    manyQueueChildActor,
+    manyQueueActionParentActor,
+    manyQueueRunParentActor,
     // From action-inputs.ts
     inputActor,
     // From action-timeout.ts
@@ -2541,8 +2652,19 @@ var registry = setup({
     workflowCounterActor,
     workflowQueueActor,
     workflowAccessActor,
+    workflowCompleteActor,
+    workflowDestroyActor,
+    workflowFailedStepActor,
     workflowSleepActor,
     workflowStopTeardownActor,
+    workflowErrorHookActor,
+    workflowErrorHookEffectsActor,
+    workflowErrorHookSleepActor,
+    workflowNestedLoopActor,
+    workflowNestedJoinActor,
+    workflowNestedRaceActor,
+    workflowSpawnChildActor,
+    workflowSpawnParentActor,
     // From actor-db-raw.ts
     dbActorRaw,
     // From actor-db-drizzle.ts
@@ -2560,7 +2682,9 @@ var registry = setup({
     startStopRaceActor,
     lifecycleObserver,
     // From conn-error-serialization.ts
-    connErrorSerializationActor
+    connErrorSerializationActor,
+    // From db-kv-stats.ts
+    dbKvStatsActor
   }
 });