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

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

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

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

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

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

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