@rikalabs/akter 0.1.0-alpha.0

package/dist/testing/conformance/transports/harness.d.ts

@@ -0,0 +1,93 @@
+import { type Cause, Effect, Queue, Schema } from "effect";
+import { SqlClient } from "effect/sql";
+import type { ActorRef } from "../../../identity/caller.ts";
+import type { ServeOptions } from "../../../serve/layer.ts";
+import { ActorTest } from "../../actor-test.ts";
+import type { ConformanceEnvironment } from "../../conformance.ts";
+import { type WireSocket } from "./wire.ts";
+interface SseMessage {
+    readonly id: string | undefined;
+    readonly event: string | undefined;
+    readonly data: string;
+}
+export declare const decodeEntry: (input: unknown, options?: import("effect/SchemaAST").ParseOptions) => Effect.Effect<{
+    readonly event: {
+        readonly _tag: "Said";
+        readonly text: string;
+    };
+    readonly commandId: string;
+    readonly timestamp: number;
+}, Schema.SchemaError, never>;
+/**
+ * An event feed read over `fetch`, as the Promise client reads one: SSE
+ * messages parsed from the body, comments skipped. Closed with the scope.
+ */
+export declare const feed: (host: string, id: string, query: string, headers: Readonly<Record<string, string>>) => Effect.Effect<{
+    status: number;
+    body: string;
+    messages: Queue.Queue<SseMessage, Cause.Done<void>>;
+}, never, import("effect/Scope").Scope>;
+/** The next `count` feed messages, failing the test if they don't arrive in time. */
+export declare const take: (messages: Queue.Dequeue<SseMessage, Cause.Done>, count: number, timeout?: number) => Effect.Effect<SseMessage[], never, never>;
+/** The `Said` text a feed message carries. */
+export declare const textOf: (message: SseMessage) => Effect.Effect<string, never, never>;
+/** The reason of a feed's `end` message or a refused feed's body, without its `_tag` key. */
+export declare const feedReason: (data: string) => Effect.Effect<{
+    tag: string;
+    code: string | undefined;
+    cause: string | undefined;
+}, never, never>;
+export declare const cursorError: (body: string) => Effect.Effect<{
+    tag: string;
+    cursor: string;
+}, never, never>;
+export declare const rows: (ref: {
+    readonly tenant: string;
+    readonly actor: string;
+    readonly id: string;
+}) => Effect.Effect<{
+    connections: number;
+    generations: number;
+}, never, SqlClient.SqlClient>;
+export declare const setup: (environment: ConformanceEnvironment, options?: Partial<ServeOptions<never>>) => Effect.Effect<{
+    test: {
+        readonly tenant: string;
+        readonly actor: <D extends import("../../actor-test.ts").TestDefinition, O extends import("../../actor-test.ts").TestActorOptions = {}>(definition: D, id?: string, options?: O) => Effect.Effect<{
+            readonly system: D extends import("../../../actor/definition.ts").DefinitionWithInternal<infer H> ? H : never;
+            readonly inspect: Effect.Effect<import("../../actor-test.ts").Inspection>;
+        }, never, import("../../../index.ts").Actors | (O extends {
+            readonly seed: string;
+        } ? import("effect/FileSystem").FileSystem : never)>;
+        readonly inspect: (ref: ActorRef) => Effect.Effect<import("../../actor-test.ts").Inspection>;
+        readonly crashNext: (point: import("../../index.ts").TurnPoint, options?: import("../../actor-test.ts").FaultOptions) => Effect.Effect<void>;
+        readonly pauseNext: (point: import("../../index.ts").TurnPoint, options?: import("../../actor-test.ts").FaultOptions) => Effect.Effect<{
+            readonly reached: Effect.Effect<void>;
+            readonly release: Effect.Effect<void>;
+        }>;
+        readonly clearFaults: Effect.Effect<ReadonlyArray<import("../../index.ts").TurnPoint>>;
+        readonly invalidate: (ref: ActorRef) => Effect.Effect<void>;
+        readonly connect: <C extends import("../../../index.ts").AnyConnection>(ref: ActorRef, member: C, params: C["payload"]["Type"]) => Effect.Effect<import("../../actor-test.ts").TestConnection<C>, import("../../../index.ts").ActorError | C["error"]["Type"]>;
+        readonly hibernate: (ref: ActorRef) => Effect.Effect<void>;
+        readonly advance: (duration: import("effect/Duration").Input) => Effect.Effect<void>;
+        readonly now: Effect.Effect<import("effect/DateTime").Utc>;
+        readonly cleanup: Effect.Effect<import("../../../runtime/storage/retention.ts").Swept>;
+        readonly receiptsFor: (ref: ActorRef, command: string) => Effect.Effect<number>;
+        readonly seed: (ref: ActorRef, state: {
+            readonly [key: string]: Schema.Json;
+        }, version: number) => Effect.Effect<void>;
+        readonly progress: Effect.Effect<ReadonlyArray<import("../../actor-test.ts").ProgressRecord>>;
+        readonly resendProgress: (message: import("../../../runtime/jobs/progress.ts").ProgressMessage) => Effect.Effect<void>;
+        readonly dropCommitted: (dropping: boolean) => Effect.Effect<void>;
+        readonly dropProgress: (predicate: (message: import("../../../runtime/jobs/progress.ts").ProgressMessage | import("../../../runtime/jobs/progress.ts").ProgressClosed) => boolean) => Effect.Effect<void>;
+    };
+    host: string;
+    token: (subject?: string) => string;
+}, never, ActorTest | import("../../index.ts").InternalActors | import("../../../runtime/drain.ts").RuntimeControl | import("effect/Scope").Scope>;
+/** Says `hello` and reads through `open` and the open handler's greeting. */
+export declare const greet: (ws: WireSocket, authorization: string, name?: string) => Effect.Effect<{
+    readonly t: "open";
+    readonly connectionId: string;
+    readonly baseline?: string | undefined;
+    readonly reauthenticateBy?: number | undefined;
+}, never, never>;
+export {};

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

@@ -0,0 +1,84 @@
+import { Context, Effect, Layer, Queue, Schema, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { SqlClient } from "effect/sql";
+import { ActorTest } from "../../actor-test.js";
+import { Said } from "./actors.js";
+import { decodeReason, opened, serveSockets } from "./wire.js";
+const FeedEntry = Schema.fromJsonString(Schema.Struct({
+    event: Schema.toCodecJson(Said),
+    commandId: Schema.String,
+    timestamp: Schema.Finite,
+}));
+export const decodeEntry = Schema.decodeUnknownEffect(FeedEntry);
+const decodeBody = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Json));
+/**
+ * An event feed read over `fetch`, as the Promise client reads one: SSE
+ * messages parsed from the body, comments skipped. Closed with the scope.
+ */
+export const feed = (host, id, query, headers) => Effect.gen(function* () {
+    const client = Context.get(yield* Layer.build(FetchHttpClient.layer), HttpClient.HttpClient);
+    const response = yield* client
+        .execute(HttpClientRequest.get(`http://${host}/api/actors/FeedRoom/${id}/events?${query}`, {
+        headers,
+    }))
+        .pipe(Effect.orDie);
+    const messages = yield* Queue.unbounded();
+    if (response.status !== 200)
+        return { status: response.status, body: yield* response.text.pipe(Effect.orDie), messages };
+    let text = "";
+    yield* response.stream.pipe(Stream.decodeText, Stream.runForEach((chunk) => Effect.gen(function* () {
+        text += chunk;
+        let end = text.indexOf("\n\n");
+        while (end !== -1) {
+            const block = text.slice(0, end);
+            text = text.slice(end + 2);
+            end = text.indexOf("\n\n");
+            const fields = new Map();
+            for (const line of block.split("\n"))
+                if (!line.startsWith(":")) {
+                    const colon = line.indexOf(":");
+                    fields.set(line.slice(0, colon), line.slice(colon + 2));
+                }
+            if (fields.has("data"))
+                yield* Queue.offer(messages, {
+                    id: fields.get("id"),
+                    event: fields.get("event"),
+                    data: fields.get("data"),
+                });
+        }
+    })), Effect.ignore, Effect.andThen(Queue.end(messages)), Effect.forkScoped);
+    return { status: 200, body: "", messages };
+});
+/** The next `count` feed messages, failing the test if they don't arrive in time. */
+export const take = (messages, count, timeout = 20_000) => Effect.forEach(Array.from({ length: count }, (_, index) => index), () => Queue.take(messages).pipe(Effect.catch(() => Effect.die(new Error("The feed ended"))), Effect.timeoutOrElse({
+    duration: timeout,
+    orElse: () => Effect.die(new Error("No feed message arrived")),
+})));
+/** The `Said` text a feed message carries. */
+export const textOf = (message) => decodeEntry(message.data).pipe(Effect.orDie, Effect.map((entry) => entry.event.text));
+/** The reason of a feed's `end` message or a refused feed's body, without its `_tag` key. */
+export const feedReason = (data) => decodeBody(data).pipe(Effect.flatMap(decodeReason), Effect.orDie, Effect.map(({ reason }) => ({ tag: reason._tag, code: reason.code, cause: reason.cause })));
+const CursorBody = Schema.Struct({ _tag: Schema.String, cursor: Schema.String });
+export const cursorError = (body) => decodeBody(body).pipe(Effect.flatMap(Schema.decodeUnknownEffect(CursorBody)), Effect.orDie, Effect.map((error) => ({ tag: error._tag, cursor: error.cursor })));
+export const rows = Effect.fnUntraced(function* (ref) {
+    const sql = yield* SqlClient.SqlClient;
+    const [counts] = yield* sql `
+    SELECT
+      (SELECT count(*)::int FROM actor_connections WHERE tenant_id = ${ref.tenant}
+        AND actor_type = ${ref.actor} AND actor_id = ${ref.id}) AS connections,
+      (SELECT count(*)::int FROM actor_generations WHERE tenant_id = ${ref.tenant}
+        AND actor_type = ${ref.actor} AND actor_id = ${ref.id}) AS generations`;
+    return counts;
+}, Effect.orDie);
+export const setup = (environment, options) => Effect.gen(function* () {
+    const test = yield* ActorTest;
+    const host = yield* serveSockets(environment, options);
+    return { test, host, token: (subject = "alice") => `Bearer ${test.tenant}:${subject}` };
+});
+/** Says `hello` and reads through `open` and the open handler's greeting. */
+export const greet = (ws, authorization, name = "alice") => Effect.gen(function* () {
+    yield* ws.send({ t: "hello", authorization, params: { name } });
+    const open = yield* opened((yield* ws.until("open")).at(-1));
+    yield* ws.until("frame");
+    return open;
+});

package/dist/testing/conformance/transports/streams.d.ts

@@ -0,0 +1,3 @@
+import type { ConformanceCase } from "../../conformance.ts";
+/** Unwritable sockets and stream members served over SSE. */
+export declare const transportStreamConformance: ReadonlyArray<ConformanceCase>;

package/dist/testing/conformance/transports/streams.js

@@ -0,0 +1,96 @@
+import { Context, Effect, Layer, Stream } from "effect";
+import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/http";
+import { Socket } from "effect/socket";
+import { User } from "../../../index.js";
+import { InternalActors } from "../../../runtime/actors.js";
+import { descriptorOf } from "../../../actor/descriptor.js";
+import { socketSession } from "../../../serve/sessions/socket.js";
+import { ActorTest } from "../../actor-test.js";
+import { Chat, FeedRoom, Refused, SocketRoom } from "./actors.js";
+import { asFailure, encodeClient } from "./wire.js";
+import { rows, setup } from "./harness.js";
+/** Unwritable sockets and stream members served over SSE. */
+export const transportStreamConformance = [
+    {
+        name: "ends a WebSocket session whose socket can no longer be written, and deletes its row",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const test = yield* ActorTest;
+            const actors = yield* InternalActors;
+            const ref = (yield* SocketRoom.get("ws-unwritable")).ref;
+            const hello = yield* encodeClient({ t: "hello", params: { name: "alice" } }).pipe(Effect.orDie);
+            let pulled = false;
+            let writes = 0;
+            const socket = Socket.make({
+                reader: Effect.succeed({
+                    pull: Effect.suspend(() => {
+                        if (pulled)
+                            return Effect.never;
+                        pulled = true;
+                        return Effect.succeed([hello]);
+                    }),
+                    upgrade: () => Effect.void,
+                }),
+                writer: Effect.succeed({
+                    write: () => Effect.suspend(() => {
+                        writes += 1;
+                        return writes > 1
+                            ? Effect.fail(Socket.SocketError.make({
+                                reason: Socket.SocketWriteError.make({ cause: new Error("peer gone") }),
+                            }))
+                            : Effect.void;
+                    }),
+                    writeAll: () => Effect.void,
+                }),
+            });
+            const principal = { tenant: test.tenant, caller: User.make({ subject: "alice" }) };
+            yield* socketSession({
+                socket,
+                connection: descriptorOf(SocketRoom).served.connections.find((connection) => connection.tag === Chat.tag),
+                holder: actors.holder,
+                ref: () => ref,
+                upgrade: principal,
+                authenticate: () => Effect.succeed(principal),
+                reauthenticate: () => Effect.succeed(principal),
+                greeted: Effect.void,
+            }).pipe(Effect.scoped, Effect.timeout("10 seconds"), Effect.orDie);
+            expect(writes).toBe(2);
+            yield* Effect.gen(function* () {
+                while ((yield* rows(ref)).connections > 0)
+                    yield* Effect.sleep("20 millis");
+            }).pipe(Effect.timeout("10 seconds"), Effect.orDie);
+        })),
+    },
+    {
+        name: "serves a stream over SSE: element messages, then end, with a declared failure in its end message",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            yield* (yield* FeedRoom.get("sse-stream")).Tell("x");
+            const client = Context.get(yield* Layer.build(FetchHttpClient.layer), HttpClient.HttpClient);
+            const subscribe = (body) => client
+                .execute(HttpClientRequest.post(`http://${host}/api/actors/FeedRoom/sse-stream/Count`, {
+                headers: { authorization: token(), accept: "text/event-stream" },
+            }).pipe(HttpClientRequest.bodyText(body, "application/json")))
+                .pipe(Effect.flatMap((response) => response.text), Effect.orDie);
+            expect(yield* subscribe("3")).toBe("event: element\ndata: 1\n\nevent: element\ndata: 2\n\nevent: element\ndata: 3\n\nevent: end\ndata: null\n\n");
+            expect(yield* subscribe("101")).toBe('event: element\ndata: 1\n\nevent: end\ndata: {"_tag":"Refused","at":1}\n\n');
+        })),
+    },
+    {
+        name: "client subscribes to a stream as an AsyncIterable, and gets its declared failure as its class",
+        run: ({ expect, environment }) => environment.run(Effect.gen(function* () {
+            const { host, token } = yield* setup(environment);
+            const room = yield* FeedRoom.get("client-stream");
+            yield* room.Tell("one");
+            const handle = FeedRoom.client({
+                baseUrl: `http://${host}/api`,
+                headers: { authorization: token() },
+            }).get("client-stream");
+            const counted = yield* Stream.fromAsyncIterable(handle.Count(3), asFailure).pipe(Stream.runCollect);
+            expect([...counted]).toEqual([1, 2, 3]);
+            const refused = yield* Stream.fromAsyncIterable(handle.Count(101), asFailure).pipe(Stream.runDrain, Effect.flip);
+            expect(refused).toBeInstanceOf(Refused);
+            const heard = yield* Stream.fromAsyncIterable(handle.Heard({}), asFailure).pipe(Stream.tap((text) => (text === "one" ? room.Tell("two") : Effect.void)), Stream.take(2), Stream.runCollect, Effect.timeout("20 seconds"), Effect.orDie);
+            expect([...heard]).toEqual(["one", "two"]);
+        })),
+    },
+];

package/dist/testing/conformance/transports/websocket.d.ts

@@ -0,0 +1,3 @@
+import type { ConformanceCase } from "../../conformance.ts";
+/** WebSocket handshake, framing, limits, reauthentication, parking, and resync. */
+export declare const transportWebSocketConformance: ReadonlyArray<ConformanceCase>;