@rikalabs/akter 0.1.0-alpha.0 → 0.1.0-alpha.3

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

@@ -1,142 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,165 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,113 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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

@@ -1,4 +0,0 @@
-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>>;