@rivetkit/effect 0.0.0-06-09-refactor-rivetkit-split-workflow-context-into-workflowcontext-workflowstepcontext.e0c9540

package/src/internal/ActorInstanceManager.ts

@@ -0,0 +1,143 @@
+import { Context, Effect, Exit, type Fiber, FiberSet, Scope } from "effect";
+import type * as Rivetkit from "rivetkit";
+import type * as RivetkitDb from "rivetkit/db";
+import type * as ActorStateAdapter from "./ActorStateAdapter.ts";
+import type * as StateOptions from "./StateOptions.ts";
+
+type RivetkitDefinitionFor<
+	StateDefinition extends StateOptions.Any,
+	Database extends RivetkitDb.AnyDatabaseProvider,
+> = Rivetkit.ActorDefinition<
+	StateOptions.Encoded<StateDefinition>,
+	undefined,
+	undefined,
+	undefined,
+	undefined,
+	Database,
+	Record<never, never>,
+	Record<never, never>,
+	any
+>;
+
+type WakeContext<
+	StateDefinition extends StateOptions.Any,
+	Database extends RivetkitDb.AnyDatabaseProvider,
+> = Rivetkit.WakeContextOf<RivetkitDefinitionFor<StateDefinition, Database>>;
+
+export type Instance<
+	ActionHandlers,
+	StateDefinition extends StateOptions.Any,
+> = {
+	readonly actionHandlers: ActionHandlers;
+	readonly runFork: <A, E>(
+		effect: Effect.Effect<A, E, any>,
+		options?: Effect.RunOptions,
+	) => Fiber.Fiber<A, E>;
+	readonly scope: Scope.Closeable;
+	readonly state?: ActorStateAdapter.ActorState<StateDefinition>;
+};
+
+export const make = Effect.fnUntraced(function* <
+	ActionHandlers,
+	StateDefinition extends StateOptions.Any,
+	Database extends RivetkitDb.AnyDatabaseProvider,
+	WakeOptions,
+>({
+	wakeHandler,
+	stateAdapter,
+	makeContext,
+	makeWakeOptions,
+}: {
+	readonly wakeHandler: (
+		wakeOptions: WakeOptions,
+	) => Effect.Effect<ActionHandlers, never, any>;
+	readonly stateAdapter:
+		| ActorStateAdapter.Adapter<StateDefinition>
+		| undefined;
+	readonly makeContext: (
+		c: WakeContext<StateDefinition, Database>,
+		scope: Scope.Closeable,
+	) => Context.Context<any>;
+	readonly makeWakeOptions: (
+		c: WakeContext<StateDefinition, Database>,
+		state: ActorStateAdapter.ActorState<StateDefinition> | undefined,
+	) => WakeOptions;
+}) {
+	const instances = new Map<
+		string,
+		Instance<ActionHandlers, StateDefinition>
+	>();
+
+	const services = yield* Effect.context<any>();
+	const runPromise = Effect.runPromiseWith(services);
+
+		const makeInstance = Effect.fnUntraced(function* (
+			c: WakeContext<StateDefinition, Database>,
+		): Effect.fn.Return<Instance<ActionHandlers, StateDefinition>, never, any> {
+			const scope = yield* Scope.make();
+			return yield* Effect.gen(function* () {
+				const state = stateAdapter
+					? yield* stateAdapter.makeStateView(c)
+					: undefined;
+				const context = makeContext(c, scope);
+				const actionHandlers = yield* wakeHandler(
+					makeWakeOptions(c, state),
+				).pipe(Effect.provide(context));
+				const runFork = yield* FiberSet.makeRuntime<
+					any,
+					unknown,
+					unknown
+				>().pipe(Effect.provide(Context.merge(services, context)));
+
+				return {
+					actionHandlers,
+					runFork,
+					scope,
+					state,
+				};
+			}).pipe(
+				Effect.onError((cause) =>
+					Scope.close(scope, Exit.failCause(cause)),
+				),
+			);
+		});
+
+	return {
+		get: (actorId: string) => instances.get(actorId),
+		onWake: async (c: WakeContext<StateDefinition, Database>) => {
+			await runPromise(
+				makeInstance(c).pipe(
+					Effect.tap((instance) =>
+						Effect.sync(() => {
+							instances.set(c.actorId, instance);
+						}),
+					),
+				),
+			);
+		},
+		onStateChange: stateAdapter
+			? (
+					c: WakeContext<StateDefinition, Database>,
+					newState: unknown,
+				) => {
+					const instance = instances.get(c.actorId);
+					// State changes can arrive after teardown removes the instance.
+					if (!instance) return;
+
+					stateAdapter.publishChange(instance, newState);
+				}
+			: undefined,
+		onTeardown: async (c: { readonly actorId: string }) => {
+			return runPromise(
+				Effect.gen(function* () {
+					const instance = instances.get(c.actorId);
+					// Teardown can be reported through multiple lifecycle callbacks.
+					if (!instance) return;
+
+					instances.delete(c.actorId);
+					yield* Scope.close(instance.scope, Exit.void);
+				}),
+			);
+		},
+	};
+});

package/src/internal/ActorStateAdapter.ts

@@ -0,0 +1,88 @@
+import { Effect, type Fiber, Schema, Semaphore } from "effect";
+import * as State from "../State.ts";
+import type * as StateOptions from "./StateOptions.ts";
+
+export type ActorState<StateDefinition extends StateOptions.Any> = State.State<
+	StateOptions.Decoded<StateDefinition>,
+	Schema.SchemaError
+>;
+
+type StateInstance<StateDefinition extends StateOptions.Any> = {
+	readonly runFork: <A, E>(
+		effect: Effect.Effect<A, E, any>,
+		options?: Effect.RunOptions,
+	) => Fiber.Fiber<A, E>;
+	readonly state?: ActorState<StateDefinition>;
+};
+
+export type Adapter<StateDefinition extends StateOptions.Any> = {
+	readonly makeStateView: (c: {
+		state: StateOptions.Encoded<StateDefinition>;
+	}) => Effect.Effect<ActorState<StateDefinition>, never, any>;
+	readonly createInitialState: () => Promise<
+		StateOptions.Encoded<StateDefinition>
+	>;
+	readonly publishChange: (
+		instance: StateInstance<StateDefinition>,
+		newState: unknown,
+	) => void;
+};
+
+export const make = Effect.fnUntraced(function* <
+	StateDefinition extends StateOptions.Any,
+>(
+	stateOptions: StateDefinition,
+): Effect.fn.Return<Adapter<StateDefinition>, never, any> {
+	const services = yield* Effect.context<any>();
+
+	const stateCodec = {
+		decodeUnknown: Schema.decodeUnknownEffect(
+			Schema.toCodecJson(stateOptions.schema),
+		),
+		encode: Schema.encodeEffect(Schema.toCodecJson(stateOptions.schema)),
+	};
+
+	return {
+		makeStateView: (c) =>
+			State.make(
+				() => stateCodec.decodeUnknown(c.state),
+				(next) =>
+					stateCodec.encode(next).pipe(
+						Effect.tap((encoded) =>
+							Effect.sync(() => {
+								c.state = encoded;
+							}),
+						),
+						Effect.asVoid,
+					),
+			).pipe(
+				Effect.orDie,
+				Effect.map((state) => state as ActorState<StateDefinition>),
+			),
+		createInitialState: () =>
+			Effect.runPromiseWith(services)(
+				stateCodec
+					.encode(stateOptions.initialValue())
+					.pipe(Effect.orDie),
+			),
+		publishChange: (instance, newState) => {
+			instance.runFork(
+				Effect.gen(function* () {
+					const state = yield* Effect.fromNullishOr(
+						instance.state,
+					).pipe(Effect.orDie);
+
+					yield* Semaphore.withPermit(
+						state.semaphore,
+						Effect.gen(function* () {
+							const decoded = yield* stateCodec
+								.decodeUnknown(newState)
+								.pipe(Effect.orDie);
+							State.publishUnsafe(state, decoded);
+						}),
+					);
+				}),
+			);
+		},
+	};
+});

package/src/internal/StateOptions.ts

@@ -0,0 +1,17 @@
+import type { Schema } from "effect";
+
+export interface StateOptions<in out S extends Schema.Top> {
+	readonly schema: S;
+	readonly initialValue: () => S["Type"];
+}
+
+export interface Any {
+	readonly schema: Schema.Top;
+	readonly initialValue: () => unknown;
+}
+
+export type Encoded<State extends Any> =
+	| State["schema"]["Encoded"]
+	| ([State] extends [never] ? undefined : never);
+
+export type Decoded<State extends Any> = State["schema"]["Type"];

package/src/internal/logging.test.ts

@@ -0,0 +1,288 @@
+import { assert, describe, it } from "@effect/vitest";
+import {
+	Config,
+	ConfigProvider,
+	Effect,
+	Layer,
+	Logger as EffectLogger,
+	References,
+} from "effect";
+import type { Logger as PinoLogger } from "rivetkit/log";
+import * as Logging from "./logging.ts";
+
+type LogEntry = {
+	readonly level: string;
+	readonly fields: Record<string, unknown>;
+	readonly msg: string | undefined;
+};
+
+function makeTestLogger(entries: Array<LogEntry>): PinoLogger {
+	const logger: Record<string, unknown> = {};
+	for (const level of [
+		"trace",
+		"debug",
+		"info",
+		"warn",
+		"error",
+		"fatal",
+	]) {
+		logger[level] = (
+			fields: Record<string, unknown>,
+			msg?: string,
+		): void => {
+			entries.push({ level, fields, msg });
+		};
+	}
+
+	return logger as unknown as PinoLogger;
+}
+
+describe("internal/logging", () => {
+	it("serializes actor keys like the RivetKit actor runtime logger", () => {
+		assert.strictEqual(Logging.serializeActorKey([]), "/");
+		assert.strictEqual(Logging.serializeActorKey(["room", "1"]), "room/1");
+		assert.strictEqual(Logging.serializeActorKey(["room/1"]), "room\\/1");
+		assert.strictEqual(Logging.serializeActorKey([""]), "\\0");
+		assert.strictEqual(Logging.serializeActorKey(["a\\b"]), "a\\\\b");
+	});
+
+	it("builds actor log annotations with serialized keys", () => {
+		assert.deepStrictEqual(
+			Logging.makeActorLogAnnotations({
+				name: "ChatRoom",
+				key: ["room/1"],
+				actorId: "actor-1",
+			}),
+			{
+				actor: "ChatRoom",
+				key: "room\\/1",
+				actorId: "actor-1",
+			},
+		);
+	});
+
+	it.effect("writes Effect logs through the RivetKit base logger", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+
+			yield* Effect.logInfo("room awake", { roomId: "abc" }).pipe(
+				Effect.annotateLogs({
+					actor: "ChatRoom",
+					key: "room-1",
+					actorId: "actor-1",
+				}),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			assert.deepStrictEqual(entries, [
+				{
+					level: "info",
+					fields: {
+						roomId: "abc",
+						actor: "ChatRoom",
+						key: "room-1",
+						actorId: "actor-1",
+					},
+					msg: "room awake",
+				},
+			]);
+		}),
+	);
+
+	it.effect("preserves Error log messages as structured error fields", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+			const error = new Error("room failed to wake");
+
+			yield* Effect.logError(error).pipe(
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			const entry = entries[0];
+			assert.ok(entry !== undefined);
+			assert.strictEqual(entry.level, "error");
+			assert.strictEqual(entry.fields.error, error);
+			assert.strictEqual(entry.msg, error.message);
+		}),
+	);
+
+	it.effect("preserves Error log messages with additional fields", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+			const error = new Error("action dispatch failed");
+
+			yield* Effect.logError(error, {
+				actorId: "actor-1",
+				action: "SendMessage",
+			}).pipe(
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			const entry = entries[0];
+			assert.ok(entry !== undefined);
+			assert.strictEqual(entry.level, "error");
+			assert.strictEqual(entry.fields.error, error);
+			assert.strictEqual(entry.fields.actorId, "actor-1");
+			assert.strictEqual(entry.fields.action, "SendMessage");
+			assert.strictEqual(entry.msg, error.message);
+		}),
+	);
+
+	it.effect("uses References.MinimumLogLevel when creating the base logger", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "debug");
+		}).pipe(Effect.provideService(References.MinimumLogLevel, "Debug")),
+	);
+
+	it.effect("accepts the shared Pino RIVET_LOG_LEVEL values", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "silent");
+		}).pipe(
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "silent",
+					},
+				}),
+			),
+		),
+	);
+
+	it.effect("prefers References.MinimumLogLevel over shared env values", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "debug");
+		}).pipe(
+			Effect.provideService(References.MinimumLogLevel, "Debug"),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "silent",
+					},
+				}),
+			),
+		),
+	);
+
+	it.effect("preserves an explicit Info minimum log level", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "info");
+		}).pipe(
+			Effect.provideService(References.MinimumLogLevel, "Info"),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "silent",
+					},
+				}),
+			),
+		),
+	);
+
+	it.effect("uses Config.logLevel values provided to References.MinimumLogLevel", () =>
+		Effect.gen(function* () {
+			const baseLogger = yield* Logging.makeDefaultBaseLogger;
+
+			assert.strictEqual(baseLogger.level, "trace");
+		}).pipe(
+			Effect.provide(
+				Layer.effect(
+					References.MinimumLogLevel,
+					Config.logLevel("RIVET_LOG_LEVEL"),
+				),
+			),
+			Effect.provideService(
+				ConfigProvider.ConfigProvider,
+				ConfigProvider.fromEnv({
+					env: {
+						RIVET_LOG_LEVEL: "Trace",
+					},
+				}),
+			),
+		),
+	);
+
+	it.effect("uses References.CurrentLogLevel for plain Effect.log calls", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+
+			yield* Effect.log("plain log").pipe(
+				Effect.provideService(References.CurrentLogLevel, "Debug"),
+				Effect.provideService(References.MinimumLogLevel, "Debug"),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			assert.deepStrictEqual(entries, [
+				{
+					level: "debug",
+					fields: {},
+					msg: "plain log",
+				},
+			]);
+		}),
+	);
+
+	it.effect("does not call a Pino method for the None current log level", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+
+			yield* Effect.log("hidden log").pipe(
+				Effect.provideService(References.CurrentLogLevel, "None"),
+				Effect.provideService(References.MinimumLogLevel, "All"),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			assert.deepStrictEqual(entries, []);
+		}),
+	);
+
+	it.effect("emits References.CurrentLogSpans as structured span durations", () =>
+		Effect.gen(function* () {
+			const entries: Array<LogEntry> = [];
+			const baseLogger = makeTestLogger(entries);
+
+			yield* Effect.logInfo("checkout complete").pipe(
+				Effect.withLogSpan("checkout"),
+				Effect.provide(
+					EffectLogger.layer([Logging.makeEffectLogger(baseLogger)]),
+				),
+			);
+
+			assert.strictEqual(entries.length, 1);
+			assert.strictEqual(entries[0]?.level, "info");
+			assert.strictEqual(entries[0]?.msg, "checkout complete");
+			assert.deepStrictEqual(Object.keys(entries[0]?.fields ?? {}), [
+				"spans",
+			]);
+			const spans = entries[0]?.fields.spans as
+				| Record<string, unknown>
+				| undefined;
+			assert.strictEqual(typeof spans?.checkout, "number");
+		}),
+	);
+});