rivetkit 2.0.31 → 2.0.32

package/dist/tsup/driver-test-suite/mod.d.cts

@@ -1,4 +1,4 @@
-import { E as Encoding, N as Registry, D as DriverConfig } from '../config-n3v1z7TT.cjs';
+import { E as Encoding, N as Registry, D as DriverConfig } from '../config-D6nMVDna.cjs';
 import 'zod';
 import 'hono';
 import 'pino';

package/dist/tsup/driver-test-suite/mod.d.ts

@@ -1,4 +1,4 @@
-import { E as Encoding, N as Registry, D as DriverConfig } from '../config-DcR9pByT.js';
+import { E as Encoding, N as Registry, D as DriverConfig } from '../config-DN0AurPi.js';
 import 'zod';
 import 'hono';
 import 'pino';

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

@@ -1,30 +1,30 @@
 import {
   getPort
-} from "../chunk-FA7X2CV7.js";
+} from "../chunk-KSKIKS4Q.js";
 import {
   actor,
   createManagerRouter
-} from "../chunk-JHYGSL2L.js";
-import {
-  configureInspectorAccessToken,
-  createActorInspectorClient,
-  createManagerInspectorClient
-} from "../chunk-FOF7U7VC.js";
+} from "../chunk-46RC64TZ.js";
 import {
   createClient
-} from "../chunk-NWFGFXKD.js";
+} from "../chunk-RQEUDCBR.js";
 import {
   ActorError,
   createClientWithDriver
-} from "../chunk-JCZW5OB3.js";
-import "../chunk-ZPEEPCYI.js";
+} from "../chunk-5MD6ZIUI.js";
 import {
   importWebSocket
-} from "../chunk-GOS2BQ7R.js";
+} from "../chunk-QCVN5ZWE.js";
 import {
   ClientConfigSchema,
   RunnerConfigSchema
-} from "../chunk-QMYZYUFA.js";
+} from "../chunk-2E6QYC2Y.js";
+import {
+  configureInspectorAccessToken,
+  createActorInspectorClient,
+  createManagerInspectorClient
+} from "../chunk-UMVOVPLU.js";
+import "../chunk-OKZQC52X.js";
 import {
   HEADER_ACTOR_ID,
   HEADER_ACTOR_QUERY,
@@ -35,15 +35,15 @@ import {
   WS_PROTOCOL_TARGET,
   WS_TEST_PROTOCOL_PATH,
   assertUnreachable
-} from "../chunk-TQ5TQ3EA.js";
+} from "../chunk-RSSAT5PN.js";
 import {
   getLogger,
   promiseWithResolvers
-} from "../chunk-276OQY5C.js";
+} from "../chunk-TK7XXGVD.js";
 import {
   INTERNAL_ERROR_CODE,
   INTERNAL_ERROR_DESCRIPTION
-} from "../chunk-P2RZJPYI.js";
+} from "../chunk-V35I3JSW.js";
 
 // src/driver-test-suite/mod.ts
 import { serve as honoServe } from "@hono/node-server";
@@ -663,6 +663,46 @@ function runActionFeaturesTests(driverTestConfig) {
         expect(results).toContain("delayed");
       });
     });
+    describe("Large Payloads", () => {
+      test("should handle large request within size limit", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.largePayloadActor.getOrCreate();
+        const items = [];
+        for (let i = 0; i < 800; i++) {
+          items.push(`Item ${i} with some additional text to increase size`);
+        }
+        const result = await instance.processLargeRequest({ items });
+        expect(result.itemCount).toBe(800);
+        expect(result.firstItem).toBe("Item 0 with some additional text to increase size");
+        expect(result.lastItem).toBe("Item 799 with some additional text to increase size");
+      });
+      test("should reject request exceeding maxIncomingMessageSize", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.largePayloadActor.getOrCreate();
+        const items = [];
+        for (let i = 0; i < 1500; i++) {
+          items.push(`Item ${i} with some additional text to increase size`);
+        }
+        await expect(
+          instance.processLargeRequest({ items })
+        ).rejects.toThrow();
+      });
+      test("should handle large response", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.largePayloadActor.getOrCreate();
+        const result = await instance.getLargeResponse(800);
+        expect(result.items).toHaveLength(800);
+        expect(result.items[0]).toBe("Item 0 with some additional text to increase size");
+        expect(result.items[799]).toBe("Item 799 with some additional text to increase size");
+      });
+      test("should reject response exceeding maxOutgoingMessageSize", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const instance = client.largePayloadActor.getOrCreate();
+        await expect(
+          instance.getLargeResponse(2e4)
+        ).rejects.toThrow();
+      });
+    });
   });
 }
 
@@ -982,6 +1022,64 @@ function runActorConnTests(driverTestConfig) {
         expect2(handler2Called).toBe(true);
       });
     });
+    describe2("Large Payloads", () => {
+      test2("should handle large request within size limit", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.largePayloadConnActor.getOrCreate([
+          "test-large-request"
+        ]);
+        const connection = handle.connect();
+        const items = [];
+        for (let i = 0; i < 800; i++) {
+          items.push(`Item ${i} with some additional text to increase size`);
+        }
+        const result = await connection.processLargeRequest({ items });
+        expect2(result.itemCount).toBe(800);
+        expect2(result.firstItem).toBe("Item 0 with some additional text to increase size");
+        expect2(result.lastItem).toBe("Item 799 with some additional text to increase size");
+        const lastRequestSize = await connection.getLastRequestSize();
+        expect2(lastRequestSize).toBe(800);
+        await connection.dispose();
+      });
+      test2("should reject request exceeding maxIncomingMessageSize", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.largePayloadConnActor.getOrCreate([
+          "test-large-request-exceed"
+        ]);
+        const connection = handle.connect();
+        const items = [];
+        for (let i = 0; i < 1500; i++) {
+          items.push(`Item ${i} with some additional text to increase size`);
+        }
+        await expect2(
+          connection.processLargeRequest({ items })
+        ).rejects.toThrow();
+        await connection.dispose();
+      });
+      test2("should handle large response", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.largePayloadConnActor.getOrCreate([
+          "test-large-response"
+        ]);
+        const connection = handle.connect();
+        const result = await connection.getLargeResponse(800);
+        expect2(result.items).toHaveLength(800);
+        expect2(result.items[0]).toBe("Item 0 with some additional text to increase size");
+        expect2(result.items[799]).toBe("Item 799 with some additional text to increase size");
+        await connection.dispose();
+      });
+      test2("should reject response exceeding maxOutgoingMessageSize", async (c) => {
+        const { client } = await setupDriverTest(c, driverTestConfig);
+        const handle = client.largePayloadConnActor.getOrCreate([
+          "test-large-response-exceed"
+        ]);
+        const connection = handle.connect();
+        await expect2(
+          connection.getLargeResponse(2e4)
+        ).rejects.toThrow();
+        await connection.dispose();
+      });
+    });
   });
 }