@systemfsoftware/effect-atom 0.5.3

package/dist/AtomRpc.mjs

@@ -0,0 +1,111 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { O as runtime, g as keepAlive, k as serializable, l as family, tt as setIdleTTL } from "./Atom-DVWTGeoV.mjs";
+import { j as schemaCodec } from "./Result-rlUvoHzK.mjs";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Schema from "effect/Schema";
+import "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import * as Headers from "effect/unstable/http/Headers";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import * as RpcSchema from "effect/unstable/rpc/RpcSchema";
+//#region src/AtomRpc.ts
+/**
+* Connects typed RPC clients to atoms.
+*
+* The service created here exposes a flattened RPC client plus atom-based query
+* and mutation helpers. Query atoms call RPCs and track asynchronous or
+* streaming results, while mutations run RPC calls that can invalidate
+* reactivity keys after success. Query atoms can also use request headers,
+* time-to-live settings, and serialization keys for hydration.
+*
+* @since 4.0.0
+*/
+var AtomRpc_exports = /* @__PURE__ */ __exportAll({ Service: () => Service });
+/**
+* Creates a `Context.Service` class for an RPC client backed by an atom runtime.
+*
+* **Details**
+*
+* The options provide the RPC group, protocol layer, tracing options, request id generation, optional custom client
+* effect, and runtime factory used by the query and mutation helpers.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const Service = () => (id, options) => {
+	const service = Context.Service()(id);
+	const layer = Layer.effect(service, options.makeEffect ?? RpcClient.make(options.group, {
+		...options,
+		flatten: true
+	}));
+	const protocol = options.protocol;
+	const runtime$1 = (options.runtime ?? runtime)(typeof protocol === "function" ? (get) => Layer.provide(layer, Layer.orDie(protocol(get))) : Layer.provide(layer, Layer.orDie(protocol)));
+	const isAnyWithProps = (u) => (typeof u === "object" && u !== null || typeof u === "function") && "payloadSchema" in u && "successSchema" in u && "errorSchema" in u;
+	const getRpc = (tag) => {
+		const rpc = options.group.requests.get(tag);
+		if (rpc === void 0 || !isAnyWithProps(rpc)) throw new Error(`Unknown RPC tag: ${tag}`);
+		return rpc;
+	};
+	/** `Flat` is a callable, so this narrowing is a check rather than a claim. */
+	const isErasedFlatCall = (client) => typeof client === "function";
+	function callFlat(client, tag, payload, headers, _shape) {
+		if (!isErasedFlatCall(client)) throw new Error(`RpcClient.Flat is not callable for tag: ${tag}`);
+		return client(tag, payload, { headers });
+	}
+	const resultSchema = schemaCodec;
+	const mutationFamily = family((tag) => {
+		const rpc = getRpc(tag);
+		const fnAtom = runtime$1.fn()(Effect.fnUntraced(function* ({ headers, payload, reactivityKeys }) {
+			const effect = callFlat(yield* service, tag, payload, headers, "effect");
+			return yield* reactivityKeys ? Reactivity.mutation(effect, reactivityKeys) : effect;
+		}));
+		return serializable(fnAtom, {
+			key: `AtomRpc:mutation:${tag}`,
+			schema: resultSchema(rpc.successSchema, makeErrorSchema(rpc))
+		});
+	});
+	function mutation(arg) {
+		return mutationFamily(arg);
+	}
+	const queryFamily = family((key) => {
+		const { headers, payload, reactivityKeys, tag, timeToLive } = key;
+		const rpc = getRpc(tag);
+		const isStream = RpcSchema.isStreamSchema(rpc.successSchema);
+		let atom = isStream ? runtime$1.pull(Stream.unwrap(service.use((client) => Effect.succeed(callFlat(client, tag, payload, headers, "stream"))))) : runtime$1.atom(service.use((client) => callFlat(client, tag, payload, headers, "effect")));
+		if (reactivityKeys) atom = runtime$1.factory.withReactivity(reactivityKeys)(atom);
+		if (!isStream && key.serializationKey) atom = serializable(atom, {
+			key: `AtomRpc:${key.tag}:${key.serializationKey}`,
+			schema: resultSchema(rpc.successSchema, makeErrorSchema(rpc))
+		});
+		if (timeToLive) atom = Duration.isFinite(timeToLive) ? setIdleTTL(atom, timeToLive) : keepAlive(atom);
+		return atom;
+	});
+	function query(tag, payload, options) {
+		const key = {
+			tag,
+			payload,
+			headers: options?.headers ? Headers.fromInput(options.headers) : void 0,
+			reactivityKeys: options?.reactivityKeys,
+			timeToLive: options?.timeToLive ? Duration.fromInputUnsafe(options.timeToLive) : void 0,
+			serializationKey: options?.serializationKey
+		};
+		return queryFamily(key);
+	}
+	return Object.assign(service, {
+		runtime: runtime$1,
+		mutation,
+		query
+	});
+};
+const makeErrorSchema = (rpc) => Schema.Union([
+	rpc.errorSchema,
+	...Array.from(rpc.middlewares, (middleware) => middleware.error),
+	RpcClientError
+]);
+//#endregion
+export { Service, AtomRpc_exports as t };

package/dist/Hydration.d.ts

@@ -0,0 +1,75 @@
+import { _t as Registry } from "./Atom-BgqgP-Qc.js";
+import * as Fiber from "effect/Fiber";
+declare namespace Hydration_d_exports {
+  export { DehydratedAtom, DehydratedAtomValue, dehydrate, hydrate };
+}
+/**
+ * Marker interface for entries in a dehydrated atom registry state.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface DehydratedAtom {
+  readonly '~effect/reactivity/DehydratedAtom': true;
+}
+/**
+ * A dehydrated serializable atom value.
+ *
+ * **Details**
+ *
+ * It stores the atom serialization key, encoded value, and dehydration
+ * timestamp.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+interface DehydratedAtomValue extends DehydratedAtom {
+  readonly key: string;
+  readonly value: unknown;
+  readonly dehydratedAt: number;
+}
+/**
+ * Encodes the serializable atoms currently stored in a registry into dehydrated
+ * state.
+ *
+ * **Details**
+ *
+ * Only atoms marked with `Atom.serializable` are included. `encodeInitialAs`
+ * controls whether `AsyncResult.Initial` values are ignored, encoded as values,
+ * or carried as a pending update that completes when the atom leaves the
+ * initial state.
+ *
+ * @category dehydration
+ * @since 4.0.0
+ */
+declare const dehydrate: (registry: Registry, options?: {
+  /**
+   * How to encode `AsyncResult.Initial` values. Default is "ignore".
+   */
+  readonly encodeInitialAs?: 'ignore' | 'deferred' | 'value-only' | undefined;
+}) => DehydratedAtomValue[];
+/**
+ * Applies dehydrated atom state to a registry.
+ *
+ * **When to use**
+ *
+ * Use to preload serialized atom values into a target registry before those
+ * atoms are read.
+ *
+ * **Details**
+ *
+ * Encoded values are preloaded by serialization key. Entries whose initial
+ * state was carried as pending (see `dehydrate`'s `encodeInitialAs`) update the
+ * matching registry node, or preload the resolved value, when that pending
+ * value completes.
+ *
+ * Returns a fiber that completes once every pending update has been applied to
+ * the registry. Callers that need the state fully settled — tests, SSR flushes
+ * — can join it; fire-and-forget callers can ignore it.
+ *
+ * @category hydration
+ * @since 4.0.0
+ */
+declare const hydrate: (registry: Registry, dehydratedState: Iterable<DehydratedAtomValue>) => Fiber.Fiber<void, never>;
+//#endregion
+export { DehydratedAtom, DehydratedAtomValue, dehydrate, hydrate, Hydration_d_exports as t };

package/dist/Hydration.mjs

@@ -0,0 +1,113 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { h as isSerializable, i as SerializableTypeId } from "./Atom-DVWTGeoV.mjs";
+import { F as isResult, h as isInitial } from "./Result-rlUvoHzK.mjs";
+import * as Effect from "effect/Effect";
+import * as Clock from "effect/Clock";
+import * as Deferred from "effect/Deferred";
+//#region src/Hydration.ts
+/**
+* Saves and restores serializable atom state.
+*
+* `dehydrate` reads atoms marked with `Atom.serializable` from an
+* `AtomRegistry` and returns encoded entries keyed by their serialization keys.
+* `hydrate` preloads those entries into another registry before the atoms are
+* read. Initial `AsyncResult` values can be ignored, encoded as values, or
+* carried as a pending update that settles the target registry once the source
+* atom leaves the initial state.
+*
+* @since 4.0.0
+*/
+var Hydration_exports = /* @__PURE__ */ __exportAll({
+	dehydrate: () => dehydrate,
+	hydrate: () => hydrate
+});
+/**
+* Non-serializable completion channel for entries dehydrated in `'deferred'`
+* mode. Keyed by entry identity so nothing appears on the public surface: the
+* same objects `dehydrate` returns must be handed to `hydrate`. A `Deferred`
+* cannot cross a serialization boundary anyway, so entries that do cross one
+* are simply applied as plain preloads.
+*/
+const pendingResults = /* @__PURE__ */ new WeakMap();
+/**
+* Encodes the serializable atoms currently stored in a registry into dehydrated
+* state.
+*
+* **Details**
+*
+* Only atoms marked with `Atom.serializable` are included. `encodeInitialAs`
+* controls whether `AsyncResult.Initial` values are ignored, encoded as values,
+* or carried as a pending update that completes when the atom leaves the
+* initial state.
+*
+* @category dehydration
+* @since 4.0.0
+*/
+const dehydrate = (registry, options) => {
+	const encodeInitialResultMode = options?.encodeInitialAs ?? "ignore";
+	const arr = [];
+	const now = Effect.runSync(Clock.currentTimeMillis);
+	registry.getNodes().forEach((node, key) => {
+		if (!isSerializable(node.atom)) return;
+		const atom = node.atom;
+		const value = node.value();
+		const isInitial$1 = isResult(value) && isInitial(value);
+		if (encodeInitialResultMode === "ignore" && isInitial$1) return;
+		if (typeof key !== "string") return;
+		const serializer = atom[SerializableTypeId];
+		const entry = {
+			"~effect/reactivity/DehydratedAtom": true,
+			key,
+			value: serializer.encode(value),
+			dehydratedAt: now
+		};
+		if (encodeInitialResultMode === "deferred" && isInitial$1) {
+			const deferred = Deferred.makeUnsafe();
+			const unsubscribe = registry.subscribe(atom, (newValue) => {
+				if (isResult(newValue) && !isInitial(newValue)) {
+					Deferred.doneUnsafe(deferred, Effect.succeed(serializer.encode(newValue)));
+					unsubscribe();
+				}
+			});
+			pendingResults.set(entry, deferred);
+		}
+		arr.push(entry);
+	});
+	return arr;
+};
+/**
+* Applies dehydrated atom state to a registry.
+*
+* **When to use**
+*
+* Use to preload serialized atom values into a target registry before those
+* atoms are read.
+*
+* **Details**
+*
+* Encoded values are preloaded by serialization key. Entries whose initial
+* state was carried as pending (see `dehydrate`'s `encodeInitialAs`) update the
+* matching registry node, or preload the resolved value, when that pending
+* value completes.
+*
+* Returns a fiber that completes once every pending update has been applied to
+* the registry. Callers that need the state fully settled — tests, SSR flushes
+* — can join it; fire-and-forget callers can ignore it.
+*
+* @category hydration
+* @since 4.0.0
+*/
+const hydrate = (registry, dehydratedState) => {
+	const pending = [];
+	for (const datom of dehydratedState) {
+		registry.setSerializable(datom.key, datom.value);
+		const result = pendingResults.get(datom);
+		if (result === void 0) continue;
+		pending.push(Effect.flatMap(Deferred.await(result), (resolvedValue) => Effect.sync(() => {
+			registry.setSerializable(datom.key, resolvedValue);
+		})));
+	}
+	return Effect.runFork(Effect.forEach(pending, (effect) => effect, { discard: true }));
+};
+//#endregion
+export { dehydrate, hydrate, Hydration_exports as t };