@shivaedev/contract 0.0.0 → 0.17.0

package/src/resume.ts

@@ -0,0 +1,44 @@
+import * as Atom from "effect/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;
+	});
+}

package/src/serverMetadata.ts

@@ -0,0 +1,50 @@
+import { Context, Schema } from "effect";
+import { Rpc } from "effect/rpc";
+import type { Key } from "#keys.ts";
+import { LiveHint } from "#live.ts";
+import type { CommandShape, QueryShape } from "#operation.ts";
+
+export class QueryReads extends Context.Service<QueryReads, QueryShape["reads"]>()("@shivaedev/contract/QueryReads") {}
+
+export class CommandInvalidation extends Context.Service<CommandInvalidation, CommandShape["invalidates"]>()(
+	"@shivaedev/contract/CommandInvalidation",
+) {}
+
+export class KeyScope extends Context.Service<KeyScope, "session">()("@shivaedev/contract/KeyScope") {}
+
+export interface QueryReference {
+	readonly payload: unknown;
+	readonly query: string;
+}
+
+type ReferenceSchema<TQuery extends QueryShape> = TQuery extends QueryShape
+	? Schema.Struct<{ query: Schema.Literal<TQuery["name"]>; payload: TQuery["payload"] }>
+	: never;
+
+export class ChangesReads extends Context.Service<ChangesReads, (references: readonly QueryReference[]) => readonly Key[]>()(
+	"@shivaedev/contract/ChangesReads",
+) {}
+
+export function queryKeys(queries: readonly QueryShape[], requested: readonly QueryReference[]): readonly Key[] {
+	return requested.flatMap((reference) => {
+		const declared = queries.find((candidate) => candidate.name === reference.query);
+		if (declared === undefined) {
+			throw new Error(`Unknown query: ${reference.query}`);
+		}
+		return declared.reads(reference.payload);
+	});
+}
+
+function referenceSchemas<const TQueries extends readonly QueryShape[]>(
+	queries: TQueries,
+): Schema.$Array<Schema.Union<readonly ReferenceSchema<TQueries[number]>[]>>;
+function referenceSchemas(queries: readonly QueryShape[]) {
+	return Schema.Array(Schema.Union(queries.map((query) => Schema.Struct({ payload: query.payload, query: Schema.Literal(query.name) }))));
+}
+
+export function changesRpc<const TName extends string, const TQueries extends readonly QueryShape[]>(name: TName, queries: TQueries) {
+	return Rpc.make(`${name}.$changes`, { payload: { queries: referenceSchemas(queries) }, stream: true, success: LiveHint }).annotate(
+		ChangesReads,
+		(requested) => queryKeys(queries, requested),
+	);
+}