@rivetkit/effect 0.0.0-main.879b6a2 → 0.0.0-sqlite-uds.4e59a38

package/src/RivetLogger.ts

@@ -0,0 +1,60 @@
+import { Effect, Logger, Layer } from "effect";
+import * as RivetkitLog from "rivetkit/log";
+import {
+	BaseLogger,
+	getOrCreateBaseLogger,
+	makeLogger,
+} from "./internal/logging.ts";
+
+/**
+ * Builds an Effect logger from a custom Pino-compatible logger.
+ *
+ * Use this with Effect's `Logger.layer` when you only need to customize Effect
+ * log output. Use {@link layerFromPino} when RivetKit's underlying TypeScript SDK
+ * logs should use the same logger too.
+ *
+ * @example
+ * ```ts
+ * import { Logger } from "effect"
+ * import { RivetLogger } from "@rivetkit/effect"
+ * import { pino } from "pino"
+ *
+ * const baseLogger = pino({ transport: { target: "pino-pretty" } })
+ * const LoggerLive = Logger.layer([RivetLogger.fromPino(baseLogger)])
+ * ```
+ */
+export const fromPino = (
+	baseLogger: RivetkitLog.Logger,
+): Logger.Logger<unknown, void> => makeLogger(baseLogger);
+
+/**
+ * Builds a logging layer from a custom Pino-compatible logger.
+ *
+ * The layer installs the matching Effect logger and configures the underlying
+ * RivetKit TypeScript SDK logs to go through the same logger. The Effect tracer
+ * logger is installed alongside the Pino adapter so log events remain attached
+ * to active traces.
+ */
+export const layerFromPino = (
+	baseLogger: RivetkitLog.Logger,
+	options?: {
+		readonly mergeWithExisting?: boolean | undefined;
+	},
+): Layer.Layer<BaseLogger> =>
+	Layer.mergeAll(
+		Layer.succeed(BaseLogger, baseLogger),
+		Logger.layer([Logger.tracerLogger, fromPino(baseLogger)], {
+			mergeWithExisting: options?.mergeWithExisting,
+		}),
+	);
+
+/**
+ * Default RivetKit Effect logging layer.
+ *
+ * The layer creates a base logger from RivetKit log configuration and installs
+ * the Effect logger adapter. Applications that want custom formatting or
+ * transports should provide {@link layerFromPino} instead.
+ */
+export const defaultLayer: Layer.Layer<never> = Layer.unwrap(
+	Effect.map(getOrCreateBaseLogger, layerFromPino),
+);

package/src/State.test.ts

@@ -36,6 +36,26 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect(
+		"getAndSet returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndSet(s, 15);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
+	it.effect("setAndGet returns the committed value", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			const next = yield* State.setAndGet(s, 15);
+			assert.strictEqual(next, 15);
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
 	it.effect("update applies f over read/write", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState(10);
@@ -44,6 +64,38 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("updateEffect applies an Effectful f over read/write", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			yield* State.updateEffect(s, (n) => Effect.succeed(n + 5));
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
+	it.effect(
+		"getAndUpdate returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndUpdate(s, (n) => n + 5);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
+	it.effect(
+		"getAndUpdateEffect returns the previous value and commits the new value",
+		() =>
+			Effect.gen(function* () {
+				const { s, cell } = yield* makeCellState(10);
+				const previous = yield* State.getAndUpdateEffect(s, (n) =>
+					Effect.succeed(n + 5),
+				);
+				assert.strictEqual(previous, 10);
+				assert.strictEqual(cell.value, 15);
+			}),
+	);
+
 	it.effect("updateAndGet returns the new value and commits it", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState(10);
@@ -53,6 +105,17 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("updateAndGetEffect returns the new value and commits it", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(10);
+			const next = yield* State.updateAndGetEffect(s, (n) =>
+				Effect.succeed(n + 5),
+			);
+			assert.strictEqual(next, 15);
+			assert.strictEqual(cell.value, 15);
+		}),
+	);
+
 	it.effect("modify returns B and commits the new value", () =>
 		Effect.gen(function* () {
 			const { s, cell } = yield* makeCellState("a");
@@ -65,6 +128,17 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("modifyEffect returns B and commits the new value", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState("a");
+			const b = yield* State.modifyEffect(s, (str) =>
+				Effect.succeed([str.length, `${str}b`] as const),
+			);
+			assert.strictEqual(b, 1);
+			assert.strictEqual(cell.value, "ab");
+		}),
+	);
+
 	it.effect(
 		"update is atomic across concurrent fibers (no lost updates)",
 		() =>
@@ -89,7 +163,7 @@ describe("State", () => {
 			);
 			assert.deepStrictEqual(initial, [0]);
 
-			State.publishUnsafe(s, 7);
+			yield* s[State.RuntimeTypeId].publishEffect(Effect.succeed(7));
 			const later = yield* State.changes(s).pipe(
 				Stream.take(1),
 				Stream.runCollect,
@@ -103,11 +177,17 @@ describe("State", () => {
 			const { s } = yield* makeCellState(0);
 			yield* Effect.scoped(
 				Effect.gen(function* () {
-					const sub = yield* PubSub.subscribe(s.pubsub);
+					const sub = yield* PubSub.subscribe(
+						s[State.RuntimeTypeId].pubsub,
+					);
 					assert.strictEqual(yield* PubSub.take(sub), 0);
 
-					yield* State.publish(s, 1);
-					yield* State.publish(s, 2);
+					yield* s[State.RuntimeTypeId].publishEffect(
+						Effect.succeed(1),
+					);
+					yield* s[State.RuntimeTypeId].publishEffect(
+						Effect.succeed(2),
+					);
 					assert.strictEqual(yield* PubSub.take(sub), 1);
 					assert.strictEqual(yield* PubSub.take(sub), 2);
 				}),
@@ -115,6 +195,19 @@ describe("State", () => {
 		}),
 	);
 
+	it.effect("shuts down the backing pubsub when its scope closes", () =>
+		Effect.gen(function* () {
+			const pubsub = yield* Effect.scoped(
+				Effect.gen(function* () {
+					const { s } = yield* makeCellState(0);
+					return s[State.RuntimeTypeId].pubsub;
+				}),
+			);
+
+			assert.isTrue(yield* PubSub.isShutdown(pubsub));
+		}),
+	);
+
 	it.effect("set does NOT auto-publish — the runtime does", () =>
 		Effect.gen(function* () {
 			const { s } = yield* makeCellState(0);
@@ -146,6 +239,61 @@ describe("State", () => {
 
 			yield* s.pipe(State.update((n) => n * 2));
 			assert.strictEqual(yield* State.get(s), 10);
+
+			yield* s.pipe(State.updateEffect((n) => Effect.succeed(n + 1)));
+			assert.strictEqual(yield* State.get(s), 11);
+		}),
+	);
+
+	it.effect("supports instance methods", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(0);
+			assert.strictEqual(yield* s.get, 0);
+
+			yield* s.set(5);
+			assert.strictEqual(cell.value, 5);
+
+			const beforeSet = yield* s.getAndSet(6);
+			assert.strictEqual(beforeSet, 5);
+			assert.strictEqual(cell.value, 6);
+
+			const afterSet = yield* s.setAndGet(7);
+			assert.strictEqual(afterSet, 7);
+			assert.strictEqual(cell.value, 7);
+
+			yield* s.update((n) => n * 2);
+			assert.strictEqual(yield* s.get, 14);
+
+			yield* s.updateEffect((n) => Effect.succeed(n + 1));
+			assert.strictEqual(yield* s.get, 15);
+
+			const previousUpdate = yield* s.getAndUpdate((n) => n + 1);
+			assert.strictEqual(previousUpdate, 15);
+			assert.strictEqual(yield* s.get, 16);
+
+			const previousEffectUpdate = yield* s.getAndUpdateEffect((n) =>
+				Effect.succeed(n + 1),
+			);
+			assert.strictEqual(previousEffectUpdate, 16);
+			assert.strictEqual(yield* s.get, 17);
+
+			const next = yield* s.updateAndGet((n) => n + 1);
+			assert.strictEqual(next, 18);
+
+			const effectNext = yield* s.updateAndGetEffect((n) =>
+				Effect.succeed(n + 1),
+			);
+			assert.strictEqual(effectNext, 19);
+
+			const previous = yield* s.modify((n) => [n, n + 1] as const);
+			assert.strictEqual(previous, 19);
+			assert.strictEqual(yield* s.get, 20);
+
+			const effectPrevious = yield* s.modifyEffect((n) =>
+				Effect.succeed([n, n + 1] as const),
+			);
+			assert.strictEqual(effectPrevious, 20);
+			assert.strictEqual(yield* s.get, 21);
 		}),
 	);
 
@@ -178,4 +326,15 @@ describe("State", () => {
 			assert.isTrue(Exit.isFailure(exit));
 		}),
 	);
+
+	it.effect("Effectful update failure does not write", () =>
+		Effect.gen(function* () {
+			const { s, cell } = yield* makeCellState(0);
+			const exit = yield* Effect.exit(
+				State.updateEffect(s, () => Effect.fail("boom" as const)),
+			);
+			assert.isTrue(Exit.isFailure(exit));
+			assert.strictEqual(cell.value, 0);
+		}),
+	);
 });