@shivaedev/effect-contract 0.3.0 → 0.4.1

package/src/keys.ts

@@ -1,36 +1,43 @@
-import type { Schema } from "effect";
+import { Schema } from "effect";
 
 export type Identity = string | number;
 
-export interface ListKey<Name extends string = string> {
+export interface ListKey<TName extends string = string> {
 	readonly _tag: "List";
-	readonly collection: Name;
+	readonly collection: TName;
 }
 
-export interface ItemKey<Name extends string = string> {
+export interface ItemKey<TName extends string = string> {
 	readonly _tag: "Item";
-	readonly collection: Name;
+	readonly collection: TName;
 	readonly id: Identity;
 }
 
 export type Key = ListKey | ItemKey;
 
-export interface Collection<Name extends string, Id extends Identity> {
-	readonly item: (id: Id) => ItemKey<Name>;
-	readonly list: ListKey<Name>;
-	readonly name: Name;
+export const Key = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("List"), collection: Schema.String }),
+	Schema.Struct({ _tag: Schema.Literal("Item"), collection: Schema.String, id: Schema.Union([Schema.String, Schema.Number]) }),
+]);
+
+export interface Collection<TName extends string, TId extends Identity> {
+	readonly item: (id: TId) => ItemKey<TName>;
+	readonly list: ListKey<TName>;
+	readonly name: TName;
 }
 
-export const collection = <const Name extends string, Id extends Schema.Top & { readonly Type: Identity }>(
-	name: Name,
-	_id: Id,
-): Collection<Name, Id["Type"]> => ({
+export const collection = <const TName extends string, TId extends Schema.Top & { readonly Type: Identity }>(
+	name: TName,
+	_id: TId,
+): Collection<TName, TId["Type"]> => ({
 	item: (id) => ({ _tag: "Item", collection: name, id }),
 	list: { _tag: "List", collection: name },
 	name,
 });
 
-const own = (key: Key): string => (key._tag === "List" ? key.collection : `${key.collection}:${key.id}`);
+function own(key: Key): string {
+	return key._tag === "List" ? key.collection : `${key.collection}:${key.id}`;
+}
 
 export const readKeys = (keys: readonly Key[]): readonly string[] => [...new Set(keys.map(own))];
 

package/src/live.ts

@@ -0,0 +1,81 @@
+import { type Cause, type Duration, Effect, Option, Schema, Stream } from "effect";
+import * as Atom from "effect/unstable/reactivity/Atom";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { invalidationKeys, Key, readKeys } from "./keys.ts";
+
+export const LiveHint = Schema.Union([
+	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key) }),
+	Schema.Struct({ _tag: Schema.Literal("Resync") }),
+]);
+export type LiveHint = typeof LiveHint.Type;
+export interface LiveStatus<E> {
+	readonly connection: "connecting" | "live" | "reconnecting";
+	readonly failure: Option.Option<Cause.Cause<E>>;
+	readonly needsResync: boolean;
+	readonly pending: number;
+}
+export interface LiveOptions<E, R> {
+	readonly resume?: Atom.Atom<unknown>;
+	readonly resyncKeys: readonly Key[];
+	readonly retryDelay?: Duration.Input;
+	readonly stream: Stream.Stream<LiveHint, E, R>;
+}
+
+const MAX_PENDING = 256;
+
+export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeError>, options: LiveOptions<E, R>) {
+	const paused = Atom.make(false);
+	const status = Atom.make<LiveStatus<E>>({ connection: "connecting", failure: Option.none(), needsResync: true, pending: 0 });
+	const connection = runtime
+		.atom((get) =>
+			Effect.gen(function* () {
+				get.mount(status);
+				const reactivity = yield* Reactivity.Reactivity;
+				function update(value: Partial<LiveStatus<E>>) {
+					get.set(status, { ...get.once(status), ...value });
+				}
+				function resync() {
+					if (get.once(paused)) {
+						update({ needsResync: true });
+						return;
+					}
+					reactivity.invalidateUnsafe(readKeys(options.resyncKeys));
+					update({ needsResync: false, pending: 0 });
+				}
+				get.subscribe(paused, (value) => {
+					if (!value) {
+						resync();
+					}
+				});
+				if (options.resume !== undefined) {
+					// A subscription alone does not initialize a derived signal's dependencies.
+					get.once(options.resume);
+					get.subscribe(options.resume, resync);
+				}
+				const attempt = Effect.suspend(() => {
+					let isFirst = true;
+					function observe(hint: LiveHint) {
+						update({ connection: "live", failure: Option.none() });
+						if (get.once(paused)) {
+							update({ needsResync: true, pending: Math.min(MAX_PENDING, get.once(status).pending + 1) });
+						} else if (isFirst || hint._tag === "Resync") {
+							resync();
+						} else {
+							reactivity.invalidateUnsafe(invalidationKeys(hint.keys));
+						}
+						isFirst = false;
+					}
+					return options.stream.pipe(
+						Stream.runForEach((hint) => Effect.sync(() => observe(hint))),
+						Effect.scoped,
+						Effect.catchCause((failure) => Effect.sync(() => update({ failure: Option.some(failure) }))),
+						Effect.andThen(Effect.sync(() => update({ connection: "reconnecting", needsResync: true }))),
+						Effect.andThen(Effect.sleep(options.retryDelay ?? "1 second")),
+					);
+				});
+				yield* Effect.forever(attempt);
+			}),
+		)
+		.pipe(Atom.setIdleTTL(0));
+	return { connection, paused, status };
+}

package/src/makeLiveServer.ts

@@ -0,0 +1,32 @@
+import { Effect, Stream } from "effect";
+import * as Reactivity from "effect/unstable/reactivity/Reactivity";
+import { type Key, readKeys } from "./keys.ts";
+import type { LiveHint } from "./live.ts";
+
+export const makeLiveServer = Effect.gen(function* () {
+	const reactivity = yield* Reactivity.Reactivity;
+	const resyncKey = `@shivaedev/effect-contract/resync/${crypto.randomUUID()}`;
+	let generation = 0;
+	function stream(keys: readonly Key[]) {
+		return Stream.unwrap(
+			Effect.sync(() => {
+				let seen = -1;
+				return reactivity.stream(
+					[...readKeys(keys), resyncKey],
+					Effect.sync((): LiveHint => {
+						if (seen !== generation) {
+							seen = generation;
+							return { _tag: "Resync" };
+						}
+						return { _tag: "Changed", keys };
+					}),
+				);
+			}),
+		);
+	}
+	const resync = Effect.sync(() => {
+		generation += 1;
+		reactivity.invalidateUnsafe([resyncKey]);
+	});
+	return { resync, stream };
+});

package/src/operation.ts

@@ -3,15 +3,15 @@ import type { Bivariant } from "@shivaedev/types/bivariant.ts";
 import type { Key } from "./keys.ts";
 import { type MatchingTags, type Reject, type RejectionSpecs, type Rejections, type RejectionUnion, rejectionSet } from "./rejection.ts";
 
-export type PayloadSchema<Payload extends Schema.Top | Schema.Struct.Fields> = Payload extends Schema.Struct.Fields
-	? Schema.Struct<Payload>
-	: Payload;
+export type PayloadSchema<TPayload extends Schema.Top | Schema.Struct.Fields> = TPayload extends Schema.Struct.Fields
+	? Schema.Struct<TPayload>
+	: TPayload;
 
 type NoRejections = Record<never, never>;
 
 export interface OperationShape {
 	readonly error: Schema.Top;
-	readonly kind: "query" | "command";
+	readonly kind: "query" | "command" | "stream";
 	readonly name: string;
 	readonly payload: Schema.Top;
 	readonly Rejection: object;
@@ -25,38 +25,49 @@ export interface QueryShape extends OperationShape {
 	reads: Bivariant<(payload: unknown) => readonly Key[]>;
 }
 
+export interface StreamShape extends OperationShape {
+	readonly kind: "stream";
+	reads: Bivariant<(payload: unknown) => readonly Key[]>;
+}
+
 export interface CommandShape extends OperationShape {
 	invalidates: Bivariant<(payload: unknown, result: unknown) => readonly Key[]>;
 	readonly kind: "command";
 }
 
-interface Operation<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
+interface Operation<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
 	extends OperationShape {
-	readonly error: RejectionUnion<Specs>;
-	readonly name: Name;
-	readonly payload: Payload;
-	readonly Rejection: Rejections<Specs>;
-	readonly reject: Reject<Specs>;
-	readonly rejections: Specs;
-	readonly success: Success;
+	readonly error: RejectionUnion<TSpecs>;
+	readonly name: TName;
+	readonly payload: TPayload;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
+	readonly rejections: TSpecs;
+	readonly success: TSuccess;
 }
 
-export interface Query<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
+export interface Query<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
 	readonly kind: "query";
-	reads: (payload: Payload["Type"]) => readonly Key[];
+	reads: (payload: TPayload["Type"]) => readonly Key[];
 }
 
-export interface Command<Name extends string, Payload extends Schema.Top, Success extends Schema.Top, Specs extends RejectionSpecs>
-	extends Operation<Name, Payload, Success, Specs> {
-	invalidates: (payload: Payload["Type"], result: Success["Type"]) => readonly Key[];
+export interface Streaming<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	readonly kind: "stream";
+	reads: (payload: TPayload["Type"]) => readonly Key[];
+}
+
+export interface Command<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
+	extends Operation<TName, TPayload, TSuccess, TSpecs> {
+	invalidates: (payload: TPayload["Type"], result: TSuccess["Type"]) => readonly Key[];
 	readonly kind: "command";
 }
 
-interface Declaration<Payload extends Schema.Top | Schema.Struct.Fields, Success extends Schema.Top, Specs extends RejectionSpecs> {
-	readonly payload?: Payload;
-	readonly rejections?: Specs & MatchingTags<Specs>;
-	readonly success?: Success;
+interface Declaration<TPayload extends Schema.Top | Schema.Struct.Fields, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs> {
+	readonly payload?: TPayload;
+	readonly rejections?: TSpecs & MatchingTags<TSpecs>;
+	readonly success?: TSuccess;
 }
 
 interface Loose {
@@ -65,14 +76,14 @@ interface Loose {
 	readonly success?: Schema.Top;
 }
 
-const payloadSchema = (payload: Loose["payload"]): Schema.Top => {
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
 	if (payload === undefined) {
 		return Schema.Void;
 	}
 	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
-};
+}
 
-const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string, declaration: Loose) => {
+function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
 	const { payload, success, rejections = {} } = declaration;
 	return {
 		kind,
@@ -82,37 +93,53 @@ const operation = <Kind extends OperationShape["kind"]>(kind: Kind, name: string
 		success: success ?? Schema.Void,
 		...rejectionSet(rejections),
 	};
-};
+}
 
 export function query<
-	const Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
 >(
-	name: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly reads: (payload: PayloadSchema<Payload>["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
 	},
-): NoInfer<Query<Name, PayloadSchema<Payload>, Success, Specs>>;
+): NoInfer<Query<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
 export function query(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): QueryShape {
 	return { ...operation("query", name, declaration), reads: declaration.reads };
 }
 
 export function command<
-	const Name extends string,
-	Payload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
-	Success extends Schema.Top = Schema.Void,
-	const Specs extends RejectionSpecs = NoRejections,
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
 >(
-	name: Name,
-	declaration: Declaration<Payload, Success, Specs> & {
-		readonly invalidates: (payload: PayloadSchema<Payload>["Type"], result: Success["Type"]) => readonly Key[];
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"]) => readonly Key[];
 	},
-): NoInfer<Command<Name, PayloadSchema<Payload>, Success, Specs>>;
+): NoInfer<Command<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
 export function command(
 	name: string,
 	declaration: Loose & { readonly invalidates: (payload: unknown, result: unknown) => readonly Key[] },
 ): CommandShape {
 	return { ...operation("command", name, declaration), invalidates: declaration.invalidates };
 }
+
+export function stream<
+	const TName extends string,
+	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
+	TSuccess extends Schema.Top = Schema.Void,
+	const TSpecs extends RejectionSpecs = NoRejections,
+>(
+	name: TName,
+	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
+		readonly success: TSuccess;
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
+	},
+): NoInfer<Streaming<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
+export function stream(name: string, declaration: Loose & { readonly reads: (payload: unknown) => readonly Key[] }): StreamShape {
+	return { ...operation("stream", name, declaration), reads: declaration.reads };
+}

package/src/rejection.ts

@@ -1,10 +1,11 @@
 import { type Cause, Effect, Schema } from "effect";
 
-export type RejectionValue<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.TaggedStruct<Tag, Fields>["Type"] & Cause.YieldableError;
+export type RejectionValue<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.TaggedStruct<TTag, TFields>["Type"] &
+	Cause.YieldableError;
 
-export type RejectionClass<Tag extends string, Fields extends Schema.Struct.Fields> = Schema.Class<
-	RejectionValue<Tag, Fields>,
-	Schema.TaggedStruct<Tag, Fields>,
+export type RejectionClass<TTag extends string, TFields extends Schema.Struct.Fields> = Schema.Class<
+	RejectionValue<TTag, TFields>,
+	Schema.TaggedStruct<TTag, TFields>,
 	Cause.YieldableError
 >;
 
@@ -14,42 +15,42 @@ export interface RejectionSpecs {
 	readonly [tag: string]: Schema.Struct.Fields | TaggedRejection;
 }
 
-export type Rejections<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs & string]: Specs[Tag] extends TaggedRejection
-		? Specs[Tag]
-		: Specs[Tag] extends Schema.Struct.Fields
-			? RejectionClass<Tag, Specs[Tag]>
+export type Rejections<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]
+		: TSpecs[TTag] extends Schema.Struct.Fields
+			? RejectionClass<TTag, TSpecs[TTag]>
 			: never;
 };
 
-export type RejectedBy<Specs extends RejectionSpecs> = {
-	[Tag in keyof Specs & string]: Rejections<Specs>[Tag]["Type"];
-}[keyof Specs & string];
+export type RejectedBy<TSpecs extends RejectionSpecs> = {
+	[TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag]["Type"];
+}[keyof TSpecs & string];
 
-export type Reject<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs & string]: Rejections<Specs>[Tag] extends new (
-		...args: infer Arguments
-	) => infer Value
-		? (...args: Arguments) => Effect.Effect<never, Value>
+export type Reject<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs & string]: Rejections<TSpecs>[TTag] extends new (
+		...args: infer TArguments
+	) => infer TValue
+		? (...args: TArguments) => Effect.Effect<never, TValue>
 		: never;
 };
 
-export type RejectionUnion<Specs extends RejectionSpecs> = [keyof Specs & string] extends [never]
+export type RejectionUnion<TSpecs extends RejectionSpecs> = [keyof TSpecs & string] extends [never]
 	? Schema.Never
-	: Schema.Union<readonly Rejections<Specs>[keyof Specs & string][]>;
+	: Schema.Union<readonly Rejections<TSpecs>[keyof TSpecs & string][]>;
 
-export type MatchingTags<Specs extends RejectionSpecs> = {
-	readonly [Tag in keyof Specs]: Specs[Tag] extends TaggedRejection
-		? Specs[Tag]["Type"] extends { readonly _tag: Tag }
-			? Specs[Tag]
-			: `The rejection class under "${Tag & string}" must have that _tag`
-		: Specs[Tag];
+export type MatchingTags<TSpecs extends RejectionSpecs> = {
+	readonly [TTag in keyof TSpecs]: TSpecs[TTag] extends TaggedRejection
+		? TSpecs[TTag]["Type"] extends { readonly _tag: TTag }
+			? TSpecs[TTag]
+			: `The rejection class under "${TTag & string}" must have that _tag`
+		: TSpecs[TTag];
 };
 
-export interface RejectionSet<Specs extends RejectionSpecs> {
-	readonly error: RejectionUnion<Specs>;
-	readonly Rejection: Rejections<Specs>;
-	readonly reject: Reject<Specs>;
+export interface RejectionSet<TSpecs extends RejectionSpecs> {
+	readonly error: RejectionUnion<TSpecs>;
+	readonly Rejection: Rejections<TSpecs>;
+	readonly reject: Reject<TSpecs>;
 }
 
 interface LooseRejectionSet {
@@ -58,7 +59,7 @@ interface LooseRejectionSet {
 	readonly reject: { readonly [tag: string]: (...args: readonly unknown[]) => Effect.Effect<never, unknown> };
 }
 
-export function rejectionSet<const Specs extends RejectionSpecs>(specs: Specs): RejectionSet<Specs>;
+export function rejectionSet<const TSpecs extends RejectionSpecs>(specs: TSpecs): RejectionSet<TSpecs>;
 export function rejectionSet(specs: RejectionSpecs): LooseRejectionSet {
 	const classes = Object.entries(specs).map(([tag, spec]): readonly [string, TaggedRejection] => [
 		tag,
@@ -73,16 +74,18 @@ export function rejectionSet(specs: RejectionSpecs): LooseRejectionSet {
 	};
 }
 
-export type FieldRejection<Field extends string> = Readonly<{
-	field: Schema.Literals<readonly Field[]>;
+export type FieldRejection<TField extends string> = Readonly<{
+	field: Schema.Literals<readonly TField[]>;
 	message: Schema.String;
 }>;
 
-export function fieldRejection<const Fields extends Schema.Struct.Fields>(struct: { readonly fields: Fields }): FieldRejection<keyof Fields & string>;
-export function fieldRejection<const Fields extends Schema.Struct.Fields, const Field extends keyof Fields & string>(
-	struct: { readonly fields: Fields },
-	fields: readonly Field[],
-): FieldRejection<Field>;
+export function fieldRejection<const TFields extends Schema.Struct.Fields>(struct: {
+	readonly fields: TFields;
+}): FieldRejection<keyof TFields & string>;
+export function fieldRejection<const TFields extends Schema.Struct.Fields, const TField extends keyof TFields & string>(
+	struct: { readonly fields: TFields },
+	fields: readonly TField[],
+): FieldRejection<TField>;
 export function fieldRejection(struct: { readonly fields: Schema.Struct.Fields }, fields?: readonly string[]): FieldRejection<string> {
 	return { field: Schema.Literals(fields ?? Object.keys(struct.fields)), message: Schema.String };
 }

package/src/resume.ts

@@ -0,0 +1,44 @@
+import * as Atom from "effect/unstable/reactivity/Atom";
+
+export type ResumeSource = (resume: () => void) => () => void;
+
+type ResumeEvent = "online" | "visibilitychange";
+
+export interface ResumeWindow {
+	readonly addEventListener: (type: ResumeEvent, listener: () => void) => void;
+	readonly document: { readonly visibilityState: string };
+	readonly removeEventListener: (type: ResumeEvent, listener: () => void) => void;
+}
+
+export interface ResumeOptions {
+	readonly native?: ResumeSource;
+	readonly window?: ResumeWindow;
+}
+
+function whileVisible(target: ResumeWindow, type: ResumeEvent): ResumeSource {
+	return (resume) => {
+		function visible() {
+			if (target.document.visibilityState === "visible") {
+				resume();
+			}
+		}
+		target.addEventListener(type, visible);
+		return () => target.removeEventListener(type, visible);
+	};
+}
+
+export function resumeSignal({ window, native }: ResumeOptions): Atom.Atom<number> {
+	const browser = window === undefined ? [] : [whileVisible(window, "visibilitychange"), whileVisible(window, "online")];
+	const sources = native === undefined ? browser : [...browser, native];
+	return Atom.readable((get) => {
+		let count = 0;
+		function resume() {
+			count += 1;
+			get.setSelf(count);
+		}
+		for (const source of sources) {
+			get.addFinalizer(source(resume));
+		}
+		return count;
+	});
+}