@shivaedev/contract 0.19.1 → 0.20.0

package/src/internal/clientOperations.ts

@@ -1,4 +1,4 @@
-import { Effect, MutableHashMap, Option, type Schema, Stream } from "effect";
+import { Effect, Option, Schema, Stream } from "effect";
 import * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import type * as AtomRpc from "effect/reactivity/AtomRpc";
 import * as Reactivity from "effect/reactivity/Reactivity";
@@ -13,10 +13,6 @@ import { queryReactivity } from "./queryReactivity.ts";
 
 type ErasedClient = AtomRpc.AtomRpcClient<unknown, string, Rpc.Rpc<string, Schema.Top, Schema.Top, Schema.Top>>;
 
-// AtomRpc holds query atoms weakly, so an id per atom object would change after a collection and make live tracking resubscribe.
-const queryIds = MutableHashMap.empty<{ readonly payload: unknown; readonly tag: string }, number>();
-let nextQueryId = 0;
-
 type ErasedStreamingClient = AtomRpc.AtomRpcClient<
 	unknown,
 	string,
@@ -27,14 +23,9 @@ function run<A, E>(service: ErasedClient, effect: Effect.Effect<A, E, unknown>,
 	return owner === undefined ? effect : Effect.suspend(() => AtomRegistry.getResult(owner.registry, service.runtime.atom(effect)));
 }
 
-export function boundQuery(
-	service: ErasedClient,
-	tag: string,
-	query: QueryShape,
-	track: ReturnType<typeof automaticLive>["track"],
-	owner?: BindingOwner,
-) {
+export function boundQuery(service: ErasedClient, tag: string, query: QueryShape, automatic: ReturnType<typeof automaticLive>, owner?: BindingOwner) {
 	const reactive = queryReactivity(service.runtime);
+	const cached = new WeakMap<ReturnType<typeof service.query>, ReturnType<typeof service.query>>();
 	return {
 		query: (payload: unknown, options: QueryOptions = {}) => {
 			if (query.readPolicy === undefined) {
@@ -43,27 +34,23 @@ export function boundQuery(
 				);
 			}
 			const atom = service.query(tag, payload, options);
-			const identity = { payload, tag };
-			let id = Option.getOrUndefined(MutableHashMap.get(queryIds, identity));
-			if (id === undefined) {
-				id = nextQueryId;
-				nextQueryId += 1;
-				MutableHashMap.set(queryIds, identity, id);
+			const existing = cached.get(atom);
+			if (existing !== undefined) {
+				return existing;
 			}
 			const local = query.reads(payload, Option.none());
-			const keys = [...local, { _tag: "List" as const, collection: `@query/${tag}/${id}` }];
+			const keys = [...local, { _tag: "List" as const, collection: `@query/${tag}/${crypto.randomUUID()}` }];
 			const dependencies =
 				local.length === 0 ? [...keys, { _tag: "List" as const, collection: `@query/${tag.slice(0, tag.lastIndexOf("."))}` }] : keys;
 			const reference = { payload, query: query.name };
-			if (owner === undefined) {
-				track(undefined, reference, keys);
-			}
-			return reactive(
-				atom,
-				readKeys(dependencies, owner?.context),
-				(registry) => (owner === undefined ? () => undefined : track(registry, reference, keys)),
-				owner?.registry,
+			const result = automatic.query(
+				reactive(atom, readKeys(dependencies, owner?.context), owner?.registry),
+				reference,
+				keys,
+				Schema.toEquivalence(query.success),
 			);
+			cached.set(atom, result);
+			return result;
 		},
 		run: (payload: unknown) =>
 			run(

package/src/internal/queryReactivity.ts

@@ -10,12 +10,7 @@ export function queryReactivity<R, E>(runtime: Atom.AtomRuntime<R, E>) {
 	const service = runtime.atom(Effect.service(Reactivity.Reactivity));
 	type Query = Atom.Atom<AsyncResult.AsyncResult<unknown, unknown>>;
 	const cached = new WeakMap<Query, Query>();
-	return (
-		atom: Query,
-		keys: readonly string[],
-		track: (registry: AtomRegistry.AtomRegistry) => () => void,
-		owner?: AtomRegistry.AtomRegistry,
-	): Query => {
+	return (atom: Query, keys: readonly string[], owner?: AtomRegistry.AtomRegistry): Query => {
 		const existing = cached.get(atom);
 		if (existing !== undefined) {
 			return existing;
@@ -35,7 +30,6 @@ export function queryReactivity<R, E>(runtime: Atom.AtomRuntime<R, E>) {
 					return get(source);
 				}
 				const reactivity = context.value;
-				get.addFinalizer(track(get.registry));
 				let pending: (() => boolean) | undefined;
 				let timer: ReturnType<typeof setTimeout> | undefined;
 				function clear() {

package/src/internal/queryResult.ts

@@ -0,0 +1,19 @@
+import * as AsyncResult from "effect/reactivity/AsyncResult";
+
+export function queryResult<A, E>(equivalent: (left: A, right: A) => boolean, publish: (value: AsyncResult.AsyncResult<A, E>) => void) {
+	let settled: AsyncResult.Success<A, E> | undefined;
+	return (value: AsyncResult.AsyncResult<A, E>) => {
+		if (!AsyncResult.isSuccess(value)) {
+			publish(value);
+			return;
+		}
+		if (settled !== undefined && equivalent(settled.value, value.value)) {
+			publish(value.waiting ? AsyncResult.waiting(settled) : settled);
+			return;
+		}
+		if (!value.waiting) {
+			settled = value;
+		}
+		publish(value);
+	};
+}

package/src/internal/rpcClient.ts

@@ -0,0 +1,53 @@
+import { type Context, Effect, Layer } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRpc from "effect/reactivity/AtomRpc";
+import { type Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
+import * as Socket from "effect/socket/Socket";
+import type { ClientOptions } from "#clientOptions.ts";
+
+export interface RpcSource {
+	readonly annotations: Context.Context<never>;
+	readonly requests: ReadonlyMap<string, Rpc.Any>;
+}
+
+export function rpcClient(name: string, source: RpcSource, options: ClientOptions) {
+	const group = RpcGroup.make(...source.requests.values()).annotateMerge(source.annotations);
+	function sharedProtocol(identity?: string) {
+		return socketProtocol({
+			headers: options.headers,
+			identity,
+			url: options.url.replace(/^http/u, "ws"),
+			webSocketConstructor: options.webSocketConstructor,
+		});
+	}
+	const protocol = options.protocol ?? sharedProtocol();
+	const Client = AtomRpc.Service<unknown>()(`${name}/Client`, {
+		group,
+		protocol: options.protocol ?? ((get) => sharedProtocol(get(socketIdentity))),
+	});
+	const client = Effect.flatMap(Layer.build(protocol), (context) => RpcClient.make(group).pipe(Effect.provideContext(context)));
+	const layer = Layer.effect(Client, RpcClient.make(group, { flatten: true })).pipe(Layer.provide(protocol));
+	return Object.assign(layer, { Client, client, runtime: Client.runtime });
+}
+
+export const socketIdentity = Atom.make<string | undefined>(undefined);
+
+const socketMemoMap = Layer.makeMemoMapUnsafe();
+const socketProtocol = Atom.family(
+	(options: {
+		readonly url: string;
+		readonly headers: ClientOptions["headers"];
+		readonly identity: string | undefined;
+		readonly webSocketConstructor: ClientOptions["webSocketConstructor"];
+	}) => {
+		const protocol = RpcClient.layerProtocolSocket().pipe(
+			Layer.provide(
+				Socket.layerWebSocket(options.url, { headers: options.headers }).pipe(
+					Layer.provide(options.webSocketConstructor ?? Socket.layerWebSocketConstructorGlobal),
+				),
+			),
+			Layer.provide(RpcSerialization.layerNdjson),
+		);
+		return Layer.effectContext(Effect.flatMap(Effect.scope, (scope) => Layer.buildWithMemoMap(protocol, socketMemoMap, scope)));
+	},
+);

package/src/live.ts

@@ -18,6 +18,7 @@ export interface LiveStatus<E> {
 }
 export interface LiveOptions<E, R> {
 	readonly coalesceWindow?: Duration.Input;
+	readonly initialResync?: boolean;
 	readonly keyContext?: KeyContext | undefined;
 	readonly resume?: Atom.Atom<unknown>;
 	readonly resyncKeys: readonly Key[] | ((registry: AtomRegistry.AtomRegistry) => readonly Key[]);
@@ -50,6 +51,9 @@ export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeE
 				get.addFinalizer(() => {
 					active = false;
 					clear();
+					if (get.registry.getNodes().has(status)) {
+						update({ connection: "connecting", failure: Option.none(), needsResync: true, pending: 0 });
+					}
 				});
 				function changed(changedKeys: readonly Key[]) {
 					const window = get.once(coalesceWindow);
@@ -93,6 +97,14 @@ export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeE
 					get.once(options.resume);
 					get.subscribe(options.resume, resync);
 				}
+				let connected = false;
+				function reconcile() {
+					if (connected || options.initialResync !== false) {
+						resync();
+					} else {
+						update({ needsResync: false });
+					}
+				}
 				const attempt = Effect.suspend(() => {
 					let isFirst = true;
 					function observe(hint: LiveHint) {
@@ -100,10 +112,11 @@ export function live<R, E, TRuntimeError>(runtime: Atom.AtomRuntime<R, TRuntimeE
 						if (get.once(paused)) {
 							update({ needsResync: true, pending: Math.min(MAX_PENDING, get.once(status).pending + 1) });
 						} else if (isFirst || hint._tag === "Resync") {
-							resync();
+							reconcile();
 						} else {
 							changed(hint.keys);
 						}
+						connected = true;
 						isFirst = false;
 					}
 					return options.stream.pipe(

package/src/makeLiveServer.ts

@@ -56,12 +56,12 @@ export const makeLiveServer = Effect.gen(function* () {
 				);
 				yield* Queue.offer(queue, { _tag: "Resync" });
 				function authorizeHint(hint: LiveHint) {
-					if (hint._tag === "Resync") {
-						return Effect.succeed(hint);
-					}
-					return Effect.map(subscription?.authorized ?? Effect.succeed(true), (allowed) =>
-						changedHint(allowed ? hint.keys : [], subscription?.scopes),
-					);
+					return Effect.map(subscription?.authorized ?? Effect.succeed(true), (allowed) => {
+						if (!allowed) {
+							return changedHint([], subscription?.scopes);
+						}
+						return hint._tag === "Resync" ? hint : changedHint(hint.keys, subscription?.scopes);
+					});
 				}
 				return Stream.fromQueue(queue).pipe(
 					Stream.mapEffect(authorizeHint),

package/dist/internal/httpClient.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpClient.d.ts","sourceRoot":"","sources":["../../src/internal/httpClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAErD,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAE,KAAK,GAAG,EAAyC,MAAM,YAAY,CAAC;AAC7E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAEvD,MAAM,WAAW,SAAS;IACzB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;IAC7C,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;CAChD;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,aAAa;;;;;;;;;;;EASjF"}

package/dist/internal/httpClient.js

@@ -1,13 +0,0 @@
-import { Effect, Layer } from "effect";
-import { FetchHttpClient } from "effect/http";
-import * as AtomRpc from "effect/reactivity/AtomRpc";
-import { RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
-export function httpClient(name, source, options) {
-    const group = RpcGroup.make(...source.requests.values()).annotateMerge(source.annotations);
-    const protocol = RpcClient.layerProtocolHttp(options).pipe(Layer.provide([options.httpClient ?? FetchHttpClient.layer, options.serialization ?? RpcSerialization.layerNdjson]));
-    const Client = AtomRpc.Service()(`${name}/Client`, { group, protocol });
-    const client = RpcClient.make(group).pipe(Effect.provide(protocol));
-    const layer = Layer.effect(Client, RpcClient.make(group, { flatten: true })).pipe(Layer.provide(protocol));
-    return Object.assign(layer, { Client, client, runtime: Client.runtime });
-}
-//# sourceMappingURL=httpClient.js.map

package/dist/internal/httpClient.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpClient.js","sourceRoot":"","sources":["../../src/internal/httpClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AACrD,OAAO,EAAY,SAAS,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAQ7E,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,MAAiB,EAAE,OAAsB;IACjF,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,aAAa,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC3F,MAAM,QAAQ,GAAG,SAAS,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,IAAI,CACzD,KAAK,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,UAAU,IAAI,eAAe,CAAC,KAAK,EAAE,OAAO,CAAC,aAAa,IAAI,gBAAgB,CAAC,WAAW,CAAC,CAAC,CACnH,CAAC;IACF,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,EAAW,CAAC,GAAG,IAAI,SAAS,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;IACjF,MAAM,MAAM,GAAG,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IACpE,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC3G,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC,CAAC;AAC1E,CAAC"}

package/src/internal/httpClient.ts

@@ -1,21 +0,0 @@
-import { type Context, Effect, Layer } from "effect";
-import { FetchHttpClient } from "effect/http";
-import * as AtomRpc from "effect/reactivity/AtomRpc";
-import { type Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/rpc";
-import type { ClientOptions } from "#clientOptions.ts";
-
-export interface HttpGroup {
-	readonly annotations: Context.Context<never>;
-	readonly requests: ReadonlyMap<string, Rpc.Any>;
-}
-
-export function httpClient(name: string, source: HttpGroup, options: ClientOptions) {
-	const group = RpcGroup.make(...source.requests.values()).annotateMerge(source.annotations);
-	const protocol = RpcClient.layerProtocolHttp(options).pipe(
-		Layer.provide([options.httpClient ?? FetchHttpClient.layer, options.serialization ?? RpcSerialization.layerNdjson]),
-	);
-	const Client = AtomRpc.Service<unknown>()(`${name}/Client`, { group, protocol });
-	const client = RpcClient.make(group).pipe(Effect.provide(protocol));
-	const layer = Layer.effect(Client, RpcClient.make(group, { flatten: true })).pipe(Layer.provide(protocol));
-	return Object.assign(layer, { Client, client, runtime: Client.runtime });
-}