@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/connections/harness.js

@@ -0,0 +1,142 @@
+import { Cause, Effect, Exit, Layer, Option, Predicate, Schedule, Stream } from "effect";
+import { SqlClient } from "effect/sql";
+import { ActorError } from "../../../errors/actor.js";
+import { System } from "../../../identity/caller.js";
+import { connectionHolder, RESYNC_DEADLINE_MS, } from "../../../runtime/connections/holder.js";
+import { ClientMessage, HolderItem } from "../../../runtime/connections/protocol.js";
+import { FrameworkClock } from "../../../runtime/turn/admission.js";
+import { ActorTest } from "../../actor-test.js";
+import { ActorCluster } from "../../cluster.js";
+import { Live, Room, connectionsLayer } from "./actors.js";
+export const isFrame = (message) => Predicate.isTagged(message, "Frame");
+export const frameOf = (message) => isFrame(message) ? message.frame : undefined;
+export const cursorOf = (message) => isFrame(message) ? message.cursor : undefined;
+/** Reads the next `count` envelopes, control frames included. */
+export const next = (connection, count = 1) => connection.messages.pipe(Stream.take(count), Stream.runCollect, Effect.map((chunk) => [...chunk]), Effect.timeoutOrElse({
+    duration: "20 seconds",
+    orElse: () => Effect.die(new Error("No connection frame arrived")),
+}));
+/** Drains envelopes until the session ends and returns how it ended. */
+export const endOf = (connection) => connection.messages.pipe(Stream.runDrain, Effect.exit, Effect.timeoutOrElse({
+    duration: "20 seconds",
+    orElse: () => Effect.die(new Error("The session did not end")),
+}), Effect.map((exit) => Exit.isFailure(exit) ? Option.getOrUndefined(Cause.findErrorOption(exit.cause)) : undefined));
+export const reasonOf = (error) => error?.reason;
+export const rows = Effect.fnUntraced(function* (ref) {
+    const sql = yield* SqlClient.SqlClient;
+    return yield* sql `
+    SELECT member, frame_seq::text AS frame_seq, session FROM actor_connections
+    WHERE tenant_id = ${ref.tenant} AND actor_type = ${ref.actor} AND actor_id = ${ref.id}`;
+}, Effect.orDie);
+export const connect = (id, name = "alice") => Effect.gen(function* () {
+    const test = yield* ActorTest;
+    const room = yield* Room.get(id);
+    const connection = yield* test.connect(room.ref, Live, { name });
+    return { test, room, connection };
+});
+/** The `Echo` executor, which every cluster runner builds. */
+const connectionsEffects = (fixture) => Room.toJobLayer(Effect.succeed({
+    LiveEcho: ({ text }) => Effect.suspend(() => fixture.echo).pipe(Effect.as(text)),
+}));
+/** Reports whether no envelope arrives within one second. */
+export const quiet = (connection) => connection.messages.pipe(Stream.take(1), Stream.runCollect, Effect.timeout("1 second"), Effect.option, Effect.map(Option.isNone));
+/** Reads envelopes through the next `ResyncReplayed`. */
+export const throughReplayed = (connection) => connection.messages.pipe(Stream.takeUntil((message) => Predicate.isTagged(message, "ResyncReplayed")), Stream.runCollect, Effect.map((chunk) => [...chunk]), Effect.timeoutOrElse({
+    duration: "60 seconds",
+    orElse: () => Effect.die(new Error("No ResyncReplayed arrived")),
+}));
+/** Collects envelopes until the session ends and returns them with how it ended. */
+export const untilEnd = (connection) => Effect.gen(function* () {
+    const seen = [];
+    const exit = yield* connection.messages.pipe(Stream.runForEach((message) => Effect.sync(() => seen.push(message))), Effect.exit, Effect.timeoutOrElse({
+        duration: "60 seconds",
+        orElse: () => Effect.die(new Error("The session did not end")),
+    }));
+    const failure = Exit.isFailure(exit) ? Cause.findErrorOption(exit.cause) : Option.none();
+    return { seen, ended: reasonOf(Option.getOrUndefined(failure)) };
+});
+export const posts = (ref) => ActorTest.use((test) => test.inspect(ref)).pipe(Effect.map(({ state }) => state.posts ?? 0));
+const EXPIRATION_SECONDS = 3;
+export const withCluster = (environment, fixture, options, body) => environment.run(Effect.gen(function* () {
+    const database = yield* environment.freshDatabase;
+    const context = yield* Layer.build(ActorTest.cluster({
+        database,
+        runners: options.runners,
+        holdersOnly: options.holdersOnly,
+        shardLockExpiration: `${EXPIRATION_SECONDS} seconds`,
+        actors: connectionsLayer(fixture),
+        runnerActors: () => connectionsEffects(fixture),
+    }));
+    return yield* body.pipe(Effect.provideContext(context));
+}));
+const OWNER = { generation: "1", owner: "owner", ownerEpoch: "owner-epoch" };
+/**
+ * A holder on its own transport whose owner side is `channel`, for cases that
+ * need an owner answer the real one never gives. Unless `channel.open` says
+ * otherwise, opening copies the row of the real connection `template`, so the
+ * holder's liveness check keeps the session.
+ */
+export const fakeHolder = Effect.fnUntraced(function* (options) {
+    const sql = yield* SqlClient.SqlClient;
+    const holderName = `${options.name}-holder`;
+    const epoch = `${options.name}-epoch`;
+    const copyRow = (request) => sql `
+      INSERT INTO actor_connections (
+        routing_key, connection_id, bucket, tenant_id, actor_type, actor_id, member,
+        holder, holder_epoch, caller, session, opened_at_ms, opened_through
+      )
+      SELECT routing_key, ${request.connectionId}, bucket, tenant_id, actor_type, actor_id,
+        member, ${request.holder}, ${request.holderEpoch}, caller, NULL, opened_at_ms, 0
+      FROM actor_connections WHERE connection_id = ${options.template}`.pipe(Effect.orDie, Effect.as({ _tag: "Opened", ...OWNER, baseline: "0" }));
+    const type = {
+        deliveryMs: 1_000,
+        takeoverMs: 5_000,
+        reauthorizeMs: 60_000,
+        retryWindowMs: 60_000,
+        placement: "actor",
+        hasResync: () => true,
+        hasMember: () => true,
+        routingKey: () => 0n,
+        ...options.type,
+        channel: {
+            open: copyRow,
+            frame: () => Effect.die(new Error("No frame is sent")),
+            close: () => Effect.void,
+            resync: () => Effect.never,
+            ...options.channel?.(copyRow),
+        },
+    };
+    const holder = yield* connectionHolder({
+        transport: () => ({
+            holder: holderName,
+            epoch,
+            deliver: () => Effect.die(new Error("No owner delivers")),
+            ping: () => Effect.sync(() => options.alive?.() ?? true),
+        }),
+        actorType: () => type,
+        authorize: () => Effect.succeed(true),
+    }).pipe(Effect.provideService(FrameworkClock, { offsetMillis: () => options.offset?.() ?? 0 }));
+    const open = (ref) => holder.open({ ref, member: Live.tag, caller: System.make({ source: "actor" }), params: "{}" });
+    /** An owner message on the generation's channel carrying `items`. */
+    const message = (ref, generation, seq, items) => ({ epoch, ...OWNER, ref, generation, seq, through: "0", items });
+    return { holder, open, message };
+});
+/** An owner frame to `to`; the fake holder never decodes it. */
+export const rawFrame = (to, frame) => HolderItem.cases.Frame.make({ member: Live.tag, to, frame, stamp: true });
+/** Collects a held connection's messages until it ends and returns them with how it ended. */
+export const heldUntilEnd = (held) => Effect.gen(function* () {
+    const seen = [];
+    const exit = yield* held.messages.pipe(Stream.runForEach((message) => Effect.sync(() => seen.push(message))), Effect.exit, Effect.timeoutOrElse({
+        duration: "20 seconds",
+        orElse: () => Effect.die(new Error("The held session did not end")),
+    }));
+    const failure = Exit.isFailure(exit) ? Cause.findErrorOption(exit.cause) : Option.none();
+    return { seen, ended: reasonOf(Option.getOrUndefined(failure)) };
+});
+/** The `Resync` a holder sends when an owner is lost, proving continuity through `after`. */
+export const resyncFrom = (after) => ClientMessage.cases.Resync.make({ after, reason: "OwnerLost", deadlineMs: RESYNC_DEADLINE_MS });
+/** Polls `check` until it holds. */
+export const eventually = (check, what) => check.pipe(Effect.repeat({ schedule: Schedule.spaced("25 millis"), until: (held) => held }), Effect.timeoutOrElse({
+    duration: "20 seconds",
+    orElse: () => Effect.die(new Error(`Timed out waiting for ${what}`)),
+}), Effect.asVoid);

package/dist/testing/conformance/connections/holders.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type ConnectionsFixture } from "./actors.ts";
+/** Holder-side generation, liveness, redelivery, and close handling of connections. */
+export declare const connectionHolderConformance: ReadonlyArray<ConformanceCase<ConnectionsFixture>>;

package/dist/testing/conformance/connections/holders.js

@@ -0,0 +1,165 @@
+import { Cause, Effect, Exit, Option, Predicate, Schema, Stream } from "effect";
+import { SqlClient } from "effect/sql";
+import { ActorError, SessionEnded, Unauthorized } from "../../../errors/actor.js";
+import { MAX_OUTBOUND_BYTES, MAX_OUTBOUND_FRAMES } from "../../../runtime/connections/holder.js";
+import { ClientMessage } from "../../../runtime/connections/protocol.js";
+import { Hello, Said, Say, receipted } from "./actors.js";
+import { connect, eventually, fakeHolder, frameOf, heldUntilEnd, isFrame, next, rawFrame, resyncFrom, untilEnd, } from "./harness.js";
+/** Holder-side generation, liveness, redelivery, and close handling of connections. */
+export const connectionHolderConformance = [
+    {
+        name: "a command and a frame that wake one parked actor together acquire one generation",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-together");
+            yield* next(connection);
+            yield* test.hibernate(room.ref);
+            const parked = BigInt((yield* test.inspect(room.ref)).generation);
+            yield* Effect.all([room.Post("together"), connection.send(Say.make({ text: "whoami" }))], { concurrency: "unbounded", discard: true });
+            const woken = (yield* next(connection, 2)).map(frameOf);
+            const said = woken.find((frame) => Predicate.isTagged(frame, "Said"));
+            const hello = woken.find((frame) => Predicate.isTagged(frame, "Hello"));
+            expect(said).toEqual(Said.make({ text: "together" }));
+            expect(hello).toEqual(Hello.make({ name: "alice", resumed: true, frames: 1 }));
+            expect(BigInt((yield* test.inspect(room.ref)).generation)).toBe(parked + 1n);
+        })),
+    },
+    {
+        name: "a holder whose liveness check fails for a whole reauthorization bound ends its sessions, and later opens are not blamed for it",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const { test, connection } = yield* connect("connections-blind");
+            yield* next(connection);
+            yield* sql `ALTER TABLE actor_connections RENAME TO actor_connections_hidden`.pipe(Effect.orDie);
+            const { ended } = yield* Effect.gen(function* () {
+                yield* test.advance("11 seconds");
+                yield* Effect.sleep("500 millis");
+                yield* test.advance("40 seconds");
+                yield* Effect.sleep("500 millis");
+                yield* test.advance("21 seconds");
+                return yield* untilEnd(connection);
+            }).pipe(Effect.ensuring(sql `ALTER TABLE actor_connections_hidden RENAME TO actor_connections`.pipe(Effect.orDie)));
+            expect(Schema.is(SessionEnded)(ended)).toBe(true);
+            expect(ended).toMatchObject({ cause: "ActorUnavailable", resync: true });
+            const after = yield* connect("connections-sighted");
+            yield* next(after.connection);
+            yield* Effect.sleep("300 millis");
+            yield* after.connection.send(Say.make({ text: "whoami" }));
+            const [answer] = yield* next(after.connection);
+            expect(frameOf(answer)).toEqual(Hello.make({ name: "alice", resumed: false, frames: 1 }));
+        })),
+    },
+    {
+        name: "a holder applies a redelivered owner message once and counts resync-deferred frames against the outbound limits",
+        timeoutMs: 30_000,
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-redelivered");
+            yield* next(connection);
+            let alive = true;
+            const fake = yield* fakeHolder({
+                name: "redelivered",
+                template: connection.connectionId,
+                alive: () => alive,
+                type: { takeoverMs: 60_000 },
+            });
+            const frames = yield* fake.open(room.ref);
+            const bytes = yield* fake.open(room.ref);
+            const once = fake.message(room.ref, "1", 1, [rawFrame([frames.connectionId], "once")]);
+            yield* fake.holder.deliver(once);
+            expect(yield* fake.holder.deliver(once)).toEqual({ wrongEpoch: false, unknown: [] });
+            yield* fake.holder.deliver(fake.message(room.ref, "1", 2, [rawFrame([frames.connectionId], "twice")]));
+            const delivered = yield* frames.messages.pipe(Stream.take(2), Stream.runCollect, Effect.timeout("5 seconds"), Effect.orDie);
+            expect([...delivered].map((message) => ClientMessage.guards.Frame(message) ? message.frame : undefined)).toEqual(["once", "twice"]);
+            alive = false;
+            for (const held of [frames, bytes]) {
+                const [resync] = yield* held.messages.pipe(Stream.take(1), Stream.runCollect, Effect.timeout("10 seconds"), Effect.orDie);
+                expect(resync?._tag).toBe("Resync");
+            }
+            const half = "x".repeat(MAX_OUTBOUND_BYTES / 2 + 1);
+            yield* fake.holder.deliver(fake.message(room.ref, "2", 1, [
+                ...Array.from({ length: MAX_OUTBOUND_FRAMES + 1 }, (_, index) => rawFrame([frames.connectionId], `deferred ${index}`)),
+                rawFrame([bytes.connectionId], half),
+                rawFrame([bytes.connectionId], half),
+            ]));
+            for (const held of [frames, bytes]) {
+                const { seen, ended } = yield* heldUntilEnd(held);
+                expect(seen).toEqual([]);
+                expect(ended).toMatchObject({ cause: "SlowConsumer", resync: true });
+            }
+        })),
+    },
+    {
+        name: "a holder never delivers a broadcast that arrives past the session's authorization bound",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-late-broadcast");
+            yield* next(connection);
+            let offset = 0;
+            const fake = yield* fakeHolder({
+                name: "late-broadcast",
+                template: connection.connectionId,
+                offset: () => offset,
+            });
+            const held = yield* fake.open(room.ref);
+            offset = 60_001;
+            yield* fake.holder.deliver(fake.message(room.ref, "1", 1, [rawFrame([held.connectionId], "late")]));
+            const { seen, ended } = yield* heldUntilEnd(held);
+            expect(seen).toEqual([]);
+            expect(ended).toMatchObject(Unauthorized.make({ code: "reauthorization_unavailable" }));
+        })),
+    },
+    {
+        name: "a holder closes a connection again when its owner commits the open after the holder gave up",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-late-open");
+            yield* next(connection);
+            const closes = [];
+            const fake = yield* fakeHolder({
+                name: "late-open",
+                template: connection.connectionId,
+                type: { deliveryMs: 200 },
+                channel: (copyRow) => ({
+                    open: (request) => copyRow(request).pipe(Effect.delay("600 millis")),
+                    close: (request) => Effect.sync(() => closes.push(request.cause)),
+                }),
+            });
+            const exit = yield* fake.open(room.ref).pipe(Effect.exit);
+            const failure = Exit.isFailure(exit) ? Cause.findErrorOption(exit.cause) : Option.none();
+            const reason = Option.filter(failure, Schema.is(ActorError)).pipe(Option.map((error) => error.reason), Option.getOrUndefined);
+            expect(reason).toMatchObject({ cause: "ActorUnavailable", resync: true });
+            yield* eventually(Effect.sync(() => closes.length > 0), "the late open to be closed");
+            expect(closes).toMatchObject([{ cause: "ActorUnavailable", resync: true }]);
+        })),
+    },
+    {
+        name: "a resync whose new owner never answers within the takeover bound closes with OwnerLost",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-unanswered");
+            yield* next(connection);
+            const requests = [];
+            const fake = yield* fakeHolder({
+                name: "unanswered",
+                template: connection.connectionId,
+                type: { takeoverMs: 300 },
+                channel: (copyRow) => ({
+                    open: (request) => copyRow(request).pipe(Effect.map((opened) => ({ ...opened, baseline: "4", recovered: true }))),
+                    resync: (request) => Effect.sync(() => requests.push(request.after)).pipe(Effect.andThen(Effect.never)),
+                }),
+            });
+            const held = yield* fake.open(room.ref);
+            const { seen, ended } = yield* heldUntilEnd(held);
+            expect(seen).toMatchObject([resyncFrom("4")]);
+            expect(requests).toEqual(["4"]);
+            expect(ended).toMatchObject({ cause: "OwnerLost", resync: true });
+        })),
+    },
+    {
+        name: "sends a server frame shaped like an event entry as the frame itself when its event is no server frame",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { connection } = yield* connect("connections-receipted");
+            yield* next(connection);
+            yield* connection.send(Say.make({ text: "receipted" }));
+            const [sent] = yield* next(connection);
+            expect(frameOf(sent)).toEqual(receipted);
+            expect(isFrame(sent) ? sent.event : "stamped").toBe(undefined);
+        })),
+    },
+];

package/dist/testing/conformance/connections/lifecycle.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type ConnectionsFixture } from "./actors.ts";
+/** Opening, ordered frames, stored sessions, parking, and broadcasts of connections. */
+export declare const connectionLifecycleConformance: ReadonlyArray<ConformanceCase<ConnectionsFixture>>;

package/dist/testing/conformance/connections/lifecycle.js

@@ -0,0 +1,113 @@
+import { Cause, Effect, Exit, Option, Schedule } from "effect";
+import { CurrentCaller, System, Tenant } from "../../../identity/caller.js";
+import { ActorTest } from "../../actor-test.js";
+import { Banned, Hello, Live, Room, Said, Say } from "./actors.js";
+import { connect, cursorOf, frameOf, isFrame, next, rows } from "./harness.js";
+/** Opening, ordered frames, stored sessions, parking, and broadcasts of connections. */
+export const connectionLifecycleConformance = [
+    {
+        name: "a connection opened after every earlier one to a resident actor closed still receives broadcasts",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-reopen");
+            yield* next(connection);
+            yield* room.Post("first");
+            expect(frameOf((yield* next(connection))[0])).toEqual(Said.make({ text: "first" }));
+            yield* connection.close;
+            const again = yield* test.connect(room.ref, Live, { name: "bob" });
+            yield* next(again);
+            yield* room.Post("second");
+            expect(frameOf((yield* next(again))[0])).toEqual(Said.make({ text: "second" }));
+        })),
+    },
+    {
+        name: "connection opens, answers frames in order, stores its session, and leaves no row once closed",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-open");
+            const [hello] = yield* next(connection);
+            expect(frameOf(hello)).toEqual(Hello.make({ name: "alice", resumed: false, frames: 0 }));
+            yield* connection.send(Say.make({ text: "whoami" }));
+            yield* connection.send(Say.make({ text: "whoami" }));
+            const answers = yield* next(connection, 2);
+            expect(answers.map(frameOf)).toEqual([
+                Hello.make({ name: "alice", resumed: false, frames: 1 }),
+                Hello.make({ name: "alice", resumed: false, frames: 2 }),
+            ]);
+            const [row] = yield* rows(room.ref);
+            expect(row).toMatchObject({ member: "Live", frame_seq: "2" });
+            expect(row.session === null).toBe(false);
+            yield* connection.close;
+            yield* rows(room.ref).pipe(Effect.repeat({
+                schedule: Schedule.spaced("20 millis"),
+                until: (found) => found.length === 0,
+            }), Effect.timeout("5 seconds"), Effect.orDie);
+        })),
+    },
+    {
+        name: "runs a frame handler in the actor's tenant as the caller stored at open",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-caller");
+            yield* next(connection);
+            yield* connection
+                .send(Say.make({ text: "caller" }))
+                .pipe(Effect.provideService(CurrentCaller, System.make({ source: "actor" })), Effect.provideService(Tenant, "elsewhere"));
+            const [answer] = yield* next(connection);
+            expect(frameOf(answer)).toEqual(Hello.make({ name: `${room.ref.tenant}/User/alice`, resumed: false, frames: 1 }));
+        })),
+    },
+    {
+        name: "a declared open failure rejects the connection and stores nothing",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const room = yield* Room.get("connections-banned");
+            const exit = yield* test.connect(room.ref, Live, { name: "mallory" }).pipe(Effect.exit);
+            expect(Exit.isFailure(exit) && Cause.findErrorOption(exit.cause)).toMatchObject(Option.some(Banned.make({ name: "mallory" })));
+            expect(yield* rows(room.ref)).toEqual([]);
+        })),
+    },
+    {
+        name: "a parked connection survives hibernation and its next frame wakes the actor with the stored session",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-park");
+            yield* next(connection);
+            yield* connection.send(Say.make({ text: "whoami" }));
+            yield* next(connection);
+            const before = (yield* test.inspect(room.ref)).generation;
+            yield* test.hibernate(room.ref);
+            yield* connection.send(Say.make({ text: "whoami" }));
+            const [woken] = yield* next(connection);
+            expect(frameOf(woken)).toEqual(Hello.make({ name: "alice", resumed: true, frames: 2 }));
+            expect(BigInt((yield* test.inspect(room.ref)).generation) > BigInt(before)).toBe(true);
+        })),
+    },
+    {
+        name: "hibernating before the owner sends anything seals the holder, so the next frame resyncs nothing",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-park-quiet");
+            yield* next(connection);
+            for (let round = 0; round < 3; round++) {
+                yield* test.hibernate(room.ref);
+                yield* connection.send(Say.make({ text: "whoami" }));
+                const [woken] = yield* next(connection);
+                expect(isFrame(woken)).toBe(true);
+            }
+        })),
+    },
+    {
+        name: "a turn's broadcast wakes a parked actor, flushes only after commit, and carries cursor stamps",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-broadcast");
+            yield* next(connection);
+            yield* test.hibernate(room.ref);
+            const refused = yield* room.Post("refuse").pipe(Effect.exit);
+            expect(Exit.isFailure(refused)).toBe(true);
+            yield* room.Post("hello");
+            const [said] = yield* next(connection);
+            expect(frameOf(said)).toEqual(Said.make({ text: "hello" }));
+            expect(cursorOf(said)).toBe(connection.cursor);
+            yield* room.Post("again");
+            const [again] = yield* next(connection);
+            expect(frameOf(again)).toEqual(Said.make({ text: "again" }));
+            expect(BigInt(cursorOf(again) ?? "0") > BigInt(connection.cursor)).toBe(true);
+        })),
+    },
+];

package/dist/testing/conformance/connections/limits.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type ConnectionsFixture } from "./actors.ts";
+/** Session and frame limits, broadcast ordering, and rejected opens of connections. */
+export declare const connectionLimitConformance: ReadonlyArray<ConformanceCase<ConnectionsFixture>>;

package/dist/testing/conformance/connections/limits.js

@@ -0,0 +1,127 @@
+import { Cause, Effect, Exit, Fiber, Option, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import { ActorUnavailable, SessionEnded, Unauthorized } from "../../../errors/actor.js";
+import { MAX_SESSION_BYTES } from "../../../runtime/connections/owner.js";
+import { decompress } from "../../../runtime/storage/codec.js";
+import { ActorTest } from "../../actor-test.js";
+import { Hello, Live, Room, Said, Say, Undeclared, holdNext, sessionJson, storedSession, } from "./actors.js";
+import { connect, eventually, frameOf, next, posts, rows, untilEnd } from "./harness.js";
+/** Session and frame limits, broadcast ordering, and rejected opens of connections. */
+export const connectionLimitConformance = [
+    {
+        name: "rejects a session above 16 KiB as a defect, closes the connection, and stores nothing of it",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-session-limit");
+            yield* next(connection);
+            const fits = MAX_SESSION_BYTES - (yield* sessionJson({ name: "", frames: 1 })).length;
+            yield* connection.send(Say.make({ text: `grow:${fits}` }));
+            const [grown] = yield* next(connection);
+            expect(frameOf(grown)).toEqual(Hello.make({ name: `${fits}`, resumed: false, frames: 1 }));
+            const [stored] = yield* rows(room.ref);
+            expect(stored?.frame_seq).toBe("1");
+            const session = (yield* storedSession(decompress(stored.session))).value;
+            const json = yield* sessionJson(session);
+            expect(new TextEncoder().encode(json).byteLength).toBe(MAX_SESSION_BYTES);
+            yield* connection.send(Say.make({ text: `grow:${fits + 1}` }));
+            const { seen, ended } = yield* untilEnd(connection);
+            expect(seen).toEqual([]);
+            expect(Schema.is(SessionEnded)(ended)).toBe(true);
+            expect(ended).toMatchObject({ cause: "Defect", resync: false });
+            expect(yield* rows(room.ref)).toEqual([]);
+        })),
+    },
+    {
+        name: "sends a broadcast committed while open runs after the open's own frames",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const room = yield* Room.get("connections-opening");
+            const hold = yield* holdNext(fixture);
+            const opening = yield* test
+                .connect(room.ref, Live, { name: "held" })
+                .pipe(Effect.forkChild({ startImmediately: true }));
+            yield* hold.reached;
+            yield* room.Post("during open");
+            yield* hold.release;
+            const connection = yield* Fiber.join(opening);
+            const opened = yield* next(connection, 2);
+            expect(opened.map(frameOf)).toEqual([
+                Hello.make({ name: "held", resumed: false, frames: 0 }),
+                Said.make({ text: "during open" }),
+            ]);
+        })),
+    },
+    {
+        name: "a failed row delete keeps the connection open and still reached by broadcasts",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const sql = yield* SqlClient.SqlClient;
+            const { room, connection } = yield* connect("connections-undeletable");
+            yield* next(connection);
+            yield* sql `CREATE FUNCTION connections_keep_row() RETURNS trigger LANGUAGE plpgsql
+            AS $$ BEGIN RAISE EXCEPTION 'row delete refused'; END $$`.pipe(Effect.orDie);
+            yield* sql `CREATE TRIGGER connections_keep_row BEFORE DELETE ON actor_connections
+            FOR EACH ROW WHEN (OLD.actor_id = 'connections-undeletable')
+            EXECUTE FUNCTION connections_keep_row()`.pipe(Effect.orDie);
+            yield* Effect.gen(function* () {
+                yield* connection.send(Say.make({ text: "leave" }));
+                yield* room.Post("still here");
+                const [still] = yield* next(connection);
+                expect(frameOf(still)).toEqual(Said.make({ text: "still here" }));
+                expect((yield* rows(room.ref)).length).toBe(1);
+            }).pipe(Effect.ensuring(Effect.all([
+                sql `DROP TRIGGER connections_keep_row ON actor_connections`,
+                sql `DROP FUNCTION connections_keep_row()`,
+            ]).pipe(Effect.orDie)));
+        })),
+    },
+    {
+        name: "a connection queues at most 1,024 inbound frames and never runs the queue it dropped",
+        run: ({ expect, environment, fixture }) => environment.run(Effect.gen(function* () {
+            const { room, connection } = yield* connect("connections-inbound");
+            yield* next(connection);
+            const hold = yield* holdNext(fixture);
+            yield* connection.send(Say.make({ text: "hold" }));
+            yield* hold.reached;
+            for (let index = 0; index <= 1_024; index++)
+                yield* connection.send(Say.make({ text: "queued" })).pipe(Effect.ignore);
+            const { ended } = yield* untilEnd(connection);
+            expect(Schema.is(SessionEnded)(ended)).toBe(true);
+            expect(ended).toMatchObject({ cause: "SlowConsumer", resync: true });
+            yield* hold.release;
+            yield* Effect.sleep("500 millis");
+            expect(yield* posts(room.ref)).toBe(0);
+        })),
+    },
+    {
+        name: "a revoked connection drops its unread outbound frames and its queued inbound frames",
+        run: ({ expect, environment, fixture, access }) => environment.run(Effect.gen(function* () {
+            const { test, room, connection } = yield* connect("connections-revoked-queue");
+            yield* next(connection);
+            yield* room.Post("unread");
+            const hold = yield* holdNext(fixture);
+            yield* connection.send(Say.make({ text: "hold" }));
+            yield* hold.reached;
+            yield* connection.send(Say.make({ text: "queued" }));
+            access.allowed = false;
+            const { seen, ended } = yield* test.advance("55 seconds").pipe(Effect.andThen(eventually(Effect.map(rows(room.ref), (found) => found.length === 0), "the revoked row to go")), Effect.andThen(untilEnd(connection)), Effect.ensuring(Effect.sync(() => (access.allowed = true))));
+            expect(ended).toMatchObject(Unauthorized.make({ code: "access_denied" }));
+            expect(seen).toEqual([]);
+            yield* hold.release;
+            yield* Effect.sleep("500 millis");
+            expect(yield* posts(room.ref)).toBe(1);
+        })),
+    },
+    {
+        name: "rejects an open for a member the actor does not declare before authorizing it",
+        run: ({ expect, environment, access }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const room = yield* Room.get("connections-undeclared");
+            access.allowed = false;
+            const exit = yield* test
+                .connect(room.ref, Undeclared, {})
+                .pipe(Effect.exit, Effect.ensuring(Effect.sync(() => (access.allowed = true))));
+            const failure = Exit.isFailure(exit) ? Cause.findErrorOption(exit.cause) : Option.none();
+            expect(Schema.is(ActorUnavailable)(Option.getOrUndefined(failure)?.reason)).toBe(true);
+            expect(yield* rows(room.ref)).toEqual([]);
+        })),
+    },
+];

package/dist/testing/conformance/connections/reauthorization.d.ts

@@ -0,0 +1,4 @@
+import type { ConformanceCase } from "../../conformance.ts";
+import { type ConnectionsFixture } from "./actors.ts";
+/** Reauthorization, holder liveness checks, and server-side closes of connections. */
+export declare const connectionReauthorizationConformance: ReadonlyArray<ConformanceCase<ConnectionsFixture>>;