@shivaedev/contract 0.18.0 → 0.19.0

package/src/internal/clientOperations.ts

@@ -1,17 +1,21 @@
-import { Effect, type Schema, Stream } from "effect";
+import { Effect, Option, type 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";
 import type { Rpc, RpcSchema } from "effect/rpc";
+import { invalidationKeys, type Key, readKeys } from "@shivaedev/changes/keys.ts";
 import type { automaticLive } from "#automaticLive.ts";
 import type { QueryOptions } from "#bind.ts";
-import { invalidationKeys, readKeys } from "#keys.ts";
 import type { CommandShape, QueryShape } from "#operation.ts";
+import { MissingReadPolicy } from "#readPolicyErrors.ts";
 import type { BindingOwner } from "./bindingOwner.ts";
 import { queryReactivity } from "./queryReactivity.ts";
 
 type ErasedClient = AtomRpc.AtomRpcClient<unknown, string, Rpc.Rpc<string, Schema.Top, Schema.Top, Schema.Top>>;
 
+const queryIds = new WeakMap<object, number>();
+let nextQueryId = 0;
+
 type ErasedStreamingClient = AtomRpc.AtomRpcClient<
 	unknown,
 	string,
@@ -32,15 +36,29 @@ export function boundQuery(
 	const reactive = queryReactivity(service.runtime);
 	return {
 		query: (payload: unknown, options: QueryOptions = {}) => {
+			if (query.readPolicy === undefined) {
+				return service.runtime.atom(
+					Effect.fail(new MissingReadPolicy({ message: `Declare a readPolicy on query ${query.name} before running it live or subscribing` })),
+				);
+			}
 			const atom = service.query(tag, payload, options);
-			const keys = query.reads(payload);
+			let id = queryIds.get(atom);
+			if (id === undefined) {
+				id = nextQueryId;
+				nextQueryId += 1;
+				queryIds.set(atom, id);
+			}
+			const local = query.reads(payload, Option.none());
+			const keys = [...local, { _tag: "List" as const, collection: `@query/${tag}/${id}` }];
+			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(keys, owner?.context),
+				readKeys(dependencies, owner?.context),
 				(registry) => (owner === undefined ? () => undefined : track(registry, reference, keys)),
 				owner?.registry,
 			);
@@ -55,15 +73,16 @@ export function boundQuery(
 }
 
 export function boundCommand(service: ErasedClient, tag: string, command: CommandShape, owner?: BindingOwner) {
+	function invalidate(payload: unknown, result: unknown) {
+		const keys: readonly Key[] = [
+			...command.invalidates(payload, result),
+			{ _tag: "List", collection: `@query/${tag.slice(0, tag.lastIndexOf("."))}` },
+		];
+		return Reactivity.invalidate(invalidationKeys(keys, owner?.context));
+	}
 	return {
 		run: (payload: unknown) =>
-			run(
-				service,
-				service
-					.use((client) => client(tag, payload))
-					.pipe(Effect.tap((result) => Reactivity.invalidate(invalidationKeys(command.invalidates(payload, result), owner?.context)))),
-				owner,
-			),
+			run(service, service.use((client) => client(tag, payload)).pipe(Effect.tap((result) => invalidate(payload, result))), owner),
 	};
 }
 

package/src/internal/httpClient.ts

@@ -0,0 +1,21 @@
+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 });
+}

package/src/internal/operationDeclaration.ts

@@ -0,0 +1,28 @@
+import { Schema } from "effect";
+import type { OperationShape } from "#operation.ts";
+import { type RejectionSpecs, rejectionSet } from "#rejection.ts";
+
+export interface Loose {
+	readonly payload?: Schema.Top | Schema.Struct.Fields;
+	readonly rejections?: RejectionSpecs;
+	readonly success?: Schema.Top;
+}
+
+function payloadSchema(payload: Loose["payload"]): Schema.Top {
+	if (payload === undefined) {
+		return Schema.Void;
+	}
+	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
+}
+
+export function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
+	const { payload, success, rejections = {} } = declaration;
+	return {
+		kind,
+		name,
+		payload: payloadSchema(payload),
+		rejections,
+		success: success ?? Schema.Void,
+		...rejectionSet(rejections),
+	};
+}

package/src/internal/queryHints.ts

@@ -0,0 +1,38 @@
+import { invalidationKeys, type Key, readKeys } from "@shivaedev/changes/keys.ts";
+import type { LiveHint } from "#live.ts";
+
+export function localQueryKeys(keys: readonly Key[]) {
+	return keys.filter((key) => key.collection.startsWith("@query/"));
+}
+
+export function queryHint(hint: LiveHint, tracked: readonly { readonly keys: readonly Key[] }[]): LiveHint {
+	if (hint._tag === "Resync") {
+		return hint;
+	}
+	const invalidated = invalidationKeys(hint.keys);
+	return {
+		_tag: "Changed",
+		keys: [
+			...hint.keys,
+			...tracked.flatMap(({ keys }, index) => {
+				const local = keys.filter((key) => !key.collection.startsWith("@query/"));
+				const affected =
+					hint.queryIndexes === undefined
+						? local.length === 0 || hint.keys.some((key) => key._tag === "Bucket") || readKeys(local).some((key) => invalidated.includes(key))
+						: hint.queryIndexes.includes(index);
+				return affected ? localQueryKeys(keys) : [];
+			}),
+		],
+	};
+}
+
+export function changedHint(keys: readonly Key[], scopes?: readonly (readonly Key[])[]): LiveHint {
+	const changed = new Set(keys.map((key) => JSON.stringify(key)));
+	return {
+		_tag: "Changed",
+		keys,
+		...(scopes === undefined
+			? {}
+			: { queryIndexes: scopes.flatMap((scope, index) => (scope.some((key) => changed.has(JSON.stringify(key))) ? [index] : [])) }),
+	};
+}

package/src/live.ts

@@ -2,11 +2,11 @@ import { type Cause, Duration, Effect, Option, Schema, Stream } from "effect";
 import * as Atom from "effect/reactivity/Atom";
 import type * as AtomRegistry from "effect/reactivity/AtomRegistry";
 import * as Reactivity from "effect/reactivity/Reactivity";
+import { invalidationKeys, Key, type KeyContext, readKeys } from "@shivaedev/changes/keys.ts";
 import { invalidateLive } from "#internal/liveInvalidation.ts";
-import { invalidationKeys, Key, type KeyContext, readKeys } from "#keys.ts";
 
 export const LiveHint = Schema.Union([
-	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key) }),
+	Schema.Struct({ _tag: Schema.Literal("Changed"), keys: Schema.Array(Key), queryIndexes: Schema.optional(Schema.Array(Schema.Number)) }),
 	Schema.Struct({ _tag: Schema.Literal("Resync") }),
 ]);
 export type LiveHint = typeof LiveHint.Type;

package/src/makeLiveServer.ts

@@ -1,20 +1,18 @@
 import { Effect, Queue, Stream } from "effect";
 import * as Reactivity from "effect/reactivity/Reactivity";
-import { makeHintPolicy } from "#internal/makeHintPolicy.ts";
-import { type Key, type KeyContext, readKeys } from "#keys.ts";
+import { type Key, type KeyContext, readKeys } from "@shivaedev/changes/keys.ts";
+import { changedHint } from "#internal/queryHints.ts";
 import type { LiveHint } from "#live.ts";
+import type { QuerySubscription } from "#querySubscription.ts";
 
 export const makeLiveServer = Effect.gen(function* () {
 	const reactivity = yield* Reactivity.Reactivity;
 	let openStreams = 0;
 	const resyncKey = `@shivaedev/contract/resync/${crypto.randomUUID()}`;
-	function stream(keys: readonly Key[], context?: KeyContext) {
+	function open(keys: readonly Key[], context?: KeyContext, subscription?: QuerySubscription) {
 		return Stream.unwrap(
 			Effect.gen(function* () {
 				const queue = yield* Queue.unbounded<LiveHint>();
-				const allowedKeys = yield* makeHintPolicy(keys.length, (retryKeys) =>
-					Queue.offer(queue, { _tag: "Changed", keys: retryKeys }).pipe(Effect.asVoid),
-				);
 				const pending = new Map<string, Key>();
 				let scheduled = false;
 				let resync = false;
@@ -57,12 +55,16 @@ 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 Stream.fromQueue(queue).pipe(
-					Stream.mapEffect((hint) =>
-						hint._tag === "Resync"
-							? Effect.succeed(hint)
-							: Effect.map(allowedKeys(hint.keys), (allowed): LiveHint => ({ _tag: "Changed", keys: allowed })),
-					),
+					Stream.mapEffect(authorizeHint),
 					Stream.filter((hint) => hint._tag === "Resync" || hint.keys.length > 0),
 				);
 			}),
@@ -72,5 +74,9 @@ export const makeLiveServer = Effect.gen(function* () {
 		reactivity.invalidateUnsafe([resyncKey]);
 		return openStreams;
 	});
-	return { resync, stream };
+	return {
+		resync,
+		stream: (keys: readonly Key[], context?: KeyContext) => open(keys, context),
+		subscribe: (subscription: QuerySubscription, context?: KeyContext) => open(subscription.keys, context, subscription),
+	};
 });

package/src/operation.ts

@@ -1,7 +1,9 @@
-import { Schema } from "effect";
+import type { Option, Schema } from "effect";
+import type { Key } from "@shivaedev/changes/keys.ts";
 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";
+import { type Loose, operation } from "#internal/operationDeclaration.ts";
+import type { QueryReadPolicy, Viewer } from "#readPolicy.ts";
+import type { MatchingTags, Reject, RejectionSpecs, Rejections, RejectionUnion } from "./rejection.ts";
 
 export type PayloadSchema<TPayload extends Schema.Top | Schema.Struct.Fields> = TPayload extends Schema.Struct.Fields
 	? Schema.Struct<TPayload>
@@ -22,7 +24,8 @@ export interface OperationShape {
 
 export interface QueryShape extends OperationShape {
 	readonly kind: "query";
-	reads: Bivariant<(payload: unknown) => readonly Key[]>;
+	readonly readPolicy?: Bivariant<QueryReadPolicy<unknown>>;
+	reads: Bivariant<(payload: unknown, viewer: Option.Option<Viewer>) => readonly Key[]>;
 }
 
 export interface StreamShape extends OperationShape {
@@ -31,7 +34,7 @@ export interface StreamShape extends OperationShape {
 }
 
 export interface CommandShape extends OperationShape {
-	invalidates: Bivariant<(payload: unknown, result: unknown) => readonly Key[]>;
+	invalidates: Bivariant<(payload: unknown, result: unknown, viewer?: Option.Option<Viewer>) => readonly Key[]>;
 	readonly kind: "command";
 }
 
@@ -49,7 +52,8 @@ interface Operation<TName extends string, TPayload extends Schema.Top, TSuccess
 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: TPayload["Type"]) => readonly Key[];
+	readonly readPolicy?: QueryReadPolicy<TPayload["Type"]>;
+	reads: (payload: TPayload["Type"], viewer: Option.Option<Viewer>) => readonly Key[];
 }
 
 export interface Streaming<TName extends string, TPayload extends Schema.Top, TSuccess extends Schema.Top, TSpecs extends RejectionSpecs>
@@ -60,7 +64,7 @@ export interface Streaming<TName extends string, TPayload extends Schema.Top, TS
 
 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[];
+	invalidates: (payload: TPayload["Type"], result: TSuccess["Type"], viewer?: Option.Option<Viewer>) => readonly Key[];
 	readonly kind: "command";
 }
 
@@ -70,31 +74,6 @@ interface Declaration<TPayload extends Schema.Top | Schema.Struct.Fields, TSucce
 	readonly success?: TSuccess;
 }
 
-interface Loose {
-	readonly payload?: Schema.Top | Schema.Struct.Fields;
-	readonly rejections?: RejectionSpecs;
-	readonly success?: Schema.Top;
-}
-
-function payloadSchema(payload: Loose["payload"]): Schema.Top {
-	if (payload === undefined) {
-		return Schema.Void;
-	}
-	return Schema.isSchema(payload) ? payload : Schema.Struct(payload);
-}
-
-function operation<TKind extends OperationShape["kind"]>(kind: TKind, name: string, declaration: Loose) {
-	const { payload, success, rejections = {} } = declaration;
-	return {
-		kind,
-		name,
-		payload: payloadSchema(payload),
-		rejections,
-		success: success ?? Schema.Void,
-		...rejectionSet(rejections),
-	};
-}
-
 export function query<
 	const TName extends string,
 	TPayload extends Schema.Top | Schema.Struct.Fields = Schema.Void,
@@ -103,11 +82,22 @@ export function query<
 >(
 	name: TName,
 	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
-		readonly reads: (payload: PayloadSchema<TPayload>["Type"]) => readonly Key[];
+		readonly reads: (payload: PayloadSchema<TPayload>["Type"], viewer: Option.Option<Viewer>) => readonly Key[];
+		readonly readPolicy?: QueryReadPolicy<PayloadSchema<TPayload>["Type"]>;
 	},
 ): 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 query(
+	name: string,
+	declaration: Loose & {
+		readonly reads: (payload: unknown, viewer: Option.Option<Viewer>) => readonly Key[];
+		readonly readPolicy?: QueryReadPolicy<unknown>;
+	},
+): QueryShape {
+	return {
+		...operation("query", name, declaration),
+		reads: declaration.reads,
+		...(declaration.readPolicy === undefined ? {} : { readPolicy: declaration.readPolicy }),
+	};
 }
 
 export function command<
@@ -118,12 +108,12 @@ export function command<
 >(
 	name: TName,
 	declaration: Declaration<TPayload, TSuccess, TSpecs> & {
-		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"]) => readonly Key[];
+		readonly invalidates: (payload: PayloadSchema<TPayload>["Type"], result: TSuccess["Type"], viewer?: Option.Option<Viewer>) => readonly Key[];
 	},
 ): NoInfer<Command<TName, PayloadSchema<TPayload>, TSuccess, TSpecs>>;
 export function command(
 	name: string,
-	declaration: Loose & { readonly invalidates: (payload: unknown, result: unknown) => readonly Key[] },
+	declaration: Loose & { readonly invalidates: (payload: unknown, result: unknown, viewer?: Option.Option<Viewer>) => readonly Key[] },
 ): CommandShape {
 	return { ...operation("command", name, declaration), invalidates: declaration.invalidates };
 }

package/src/publicConfig.ts

@@ -1,9 +1,9 @@
-import type { Schema } from "effect";
+import { Effect, type Schema } from "effect";
 import { contract } from "#contract.ts";
 import { query } from "#operation.ts";
 
 export function publicConfig<T, E>(schema: Schema.Codec<T, E>) {
 	return contract("platform.publicConfig", {
-		queries: [query("get", { reads: () => [], success: schema })],
+		queries: [query("get", { readPolicy: () => Effect.succeed(true), reads: () => [], success: schema })],
 	});
 }

package/src/querySubscription.ts

@@ -0,0 +1,21 @@
+import { Context, Effect, type Option } from "effect";
+import type { Key } from "@shivaedev/changes/keys.ts";
+import { checkQuery, type Viewer } from "#readPolicy.ts";
+import type { QueryRequest } from "#serverMetadata.ts";
+
+export interface QuerySubscription {
+	readonly authorized: Effect.Effect<boolean>;
+	readonly keys: readonly Key[];
+	readonly scopes: readonly (readonly Key[])[];
+}
+
+export const querySubscription = Effect.fnUntraced(function* (queries: readonly QueryRequest[], viewer: Option.Option<Viewer>) {
+	yield* Effect.forEach(queries, ({ query, payload }) => checkQuery(query, payload, viewer));
+	const context = Context.makeUnsafe<unknown>((yield* Effect.context<never>()).mapUnsafe);
+	const scopes = queries.map(({ query, payload }) => query.reads(payload, viewer));
+	const authorized = Effect.map(
+		Effect.forEach(queries, ({ query, payload }) => Effect.provideContext(query.readPolicy?.(payload, viewer) ?? Effect.succeed(false), context)),
+		(permissions) => permissions.every(Boolean),
+	);
+	return { authorized, keys: scopes.flat(), scopes } satisfies QuerySubscription;
+});

package/src/readPolicy.ts

@@ -1,33 +1,33 @@
-import { Context, type Duration, Effect, Option } from "effect";
+import { Context, Effect, Option } from "effect";
 import type { Rpc } from "effect/rpc";
-import type { Key } from "./keys.ts";
-import { QueryReads } from "./serverMetadata.ts";
+import type { QueryShape } from "#operation.ts";
+import { MissingReadPolicy, QueryReadDenied } from "#readPolicyErrors.ts";
+import { QueryDefinition } from "#serverMetadata.ts";
 
-export const ReadPolicy = Context.Reference<(key: Key) => Effect.Effect<boolean, unknown>>("@shivaedev/contract/ReadPolicy", {
-	defaultValue: () => () => Effect.succeed(true),
-});
+export interface Viewer {
+	readonly id: string;
+}
+export type QueryReadPolicy<TPayload> = (payload: TPayload, viewer: Option.Option<Viewer>) => Effect.Effect<boolean, never, unknown>;
 
-export const ReadPolicyMemoWindow = Context.Reference<Duration.Input>("@shivaedev/contract/ReadPolicyMemoWindow", {
-	defaultValue: () => "1 second",
+export const CurrentViewer = Context.Reference<Option.Option<Viewer>>("@shivaedev/contract/CurrentViewer", { defaultValue: Option.none });
+export const checkQuery = Effect.fnUntraced(function* (query: QueryShape, payload: unknown, viewer: Option.Option<Viewer>) {
+	if (query.readPolicy === undefined) {
+		return yield* new MissingReadPolicy({ message: `Declare a readPolicy on query ${query.name} before running it live or subscribing` });
+	}
+	const context = Context.makeUnsafe<unknown>((yield* Effect.context<never>()).mapUnsafe);
+	if (!(yield* Effect.provideContext(query.readPolicy(payload, viewer), context))) {
+		return yield* new QueryReadDenied({ message: `Read not allowed for query ${query.name}` });
+	}
 });
 
-export const authorizeReads = Effect.fnUntraced(function* <A, E, R, TPolicyServices, TDenied, TPolicyError>(
+export const authorizeReads = Effect.fnUntraced(function* <A, E, R>(
 	effect: Effect.Effect<A, E, R>,
 	request: { readonly rpc: Rpc.AnyWithProps; readonly payload: unknown },
-	policy: (key: Key) => Effect.Effect<boolean, TPolicyError, TPolicyServices>,
-	denied: Effect.Effect<never, TDenied>,
+	viewer: Option.Option<Viewer>,
 ) {
-	const context = yield* Effect.context<TPolicyServices>();
-	function canRead(key: Key) {
-		return Effect.provideContext(policy(key), context);
-	}
-	const reads = Context.getOption(request.rpc.annotations, QueryReads);
-	if (Option.isSome(reads)) {
-		for (const key of reads.value(request.payload)) {
-			if (!(yield* canRead(key))) {
-				return yield* denied;
-			}
-		}
+	const definition = Context.getOption(request.rpc.annotations, QueryDefinition);
+	if (Option.isSome(definition) && definition.value.definition.readPolicy !== undefined) {
+		yield* checkQuery(definition.value.definition, request.payload, viewer);
 	}
-	return yield* Effect.provideService(effect, ReadPolicy, canRead);
+	return yield* Effect.provideService(effect, CurrentViewer, viewer);
 });

package/src/readPolicyErrors.ts

@@ -0,0 +1,4 @@
+import { Schema } from "effect";
+
+export class MissingReadPolicy extends Schema.TaggedError<MissingReadPolicy>()("MissingReadPolicy", { message: Schema.String }) {}
+export class QueryReadDenied extends Schema.TaggedError<QueryReadDenied>()("QueryReadDenied", { message: Schema.String }) {}

package/src/serverMetadata.ts

@@ -1,12 +1,24 @@
-import { Context, Schema } from "effect";
+import { Context, Effect, Option, Schema } from "effect";
 import { Rpc } from "effect/rpc";
-import type { Key } from "#keys.ts";
+import type { Key } from "@shivaedev/changes/keys.ts";
 import { LiveHint } from "#live.ts";
 import type { CommandShape, QueryShape } from "#operation.ts";
+import type { Viewer } from "#readPolicy.ts";
+import { MissingReadPolicy, QueryReadDenied } from "#readPolicyErrors.ts";
 
-export class QueryReads extends Context.Service<QueryReads, QueryShape["reads"]>()("@shivaedev/contract/QueryReads") {}
+export class QueryDefinition extends Context.Service<QueryDefinition, { readonly definition: QueryShape }>()("@shivaedev/contract/QueryDefinition") {}
+export interface QueryRequest {
+	readonly payload: unknown;
+	readonly query: QueryShape;
+}
+export class ChangesQueries extends Context.Service<
+	ChangesQueries,
+	{
+		readonly resolve: (references: readonly QueryReference[]) => Effect.Effect<readonly QueryRequest[]>;
+	}
+>()("@shivaedev/contract/ChangesQueries") {}
 
-export class CommandInvalidation extends Context.Service<CommandInvalidation, CommandShape["invalidates"]>()(
+export class CommandInvalidation extends Context.Service<CommandInvalidation, { readonly invalidates: CommandShape["invalidates"] }>()(
 	"@shivaedev/contract/CommandInvalidation",
 ) {}
 
@@ -21,20 +33,22 @@ 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 resolveQueries(queries: readonly QueryShape[], requested: readonly QueryReference[]) {
+	return Effect.forEach(requested, (reference) => {
+		const query = queries.find((candidate) => candidate.name === reference.query);
+		return query === undefined ? Effect.die(new Error(`Unknown query: ${reference.query}`)) : Effect.succeed({ payload: reference.payload, query });
 	});
 }
 
+export const queryKeys = Effect.fnUntraced(function* (
+	queries: readonly QueryShape[],
+	requested: readonly QueryReference[],
+	viewer: Option.Option<Viewer> = Option.none(),
+): Effect.fn.Return<readonly Key[]> {
+	const resolved = yield* resolveQueries(queries, requested);
+	return resolved.flatMap(({ query, payload }) => query.reads(payload, viewer));
+});
+
 function referenceSchemas<const TQueries extends readonly QueryShape[]>(
 	queries: TQueries,
 ): Schema.$Array<Schema.Union<readonly ReferenceSchema<TQueries[number]>[]>>;
@@ -43,8 +57,10 @@ function referenceSchemas(queries: readonly QueryShape[]) {
 }
 
 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),
-	);
+	return Rpc.make(`${name}.$changes`, {
+		error: Schema.Union([MissingReadPolicy, QueryReadDenied]),
+		payload: { queries: referenceSchemas(queries) },
+		stream: true,
+		success: LiveHint,
+	}).annotate(ChangesQueries, { resolve: (references) => resolveQueries(queries, references) });
 }

package/src/testing.ts

@@ -1,5 +1,5 @@
 import { Deferred, type Duration, Effect, Fiber, Stream, SubscriptionRef } from "effect";
-import type { Key } from "./keys.ts";
+import type { Key } from "@shivaedev/changes/keys.ts";
 import type { LiveHint } from "./live.ts";
 
 export interface HintViewer<E> {
@@ -37,15 +37,5 @@ export const heard = Effect.fn("Live.heard")(function* <E>(
 });
 
 function namesKeys(hint: LiveHint, keys: readonly Key[]): boolean {
-	return (
-		hint._tag === "Changed"
-		&& keys.every((key) =>
-			hint.keys.some(
-				(actual) =>
-					actual._tag === key._tag
-					&& actual.collection === key.collection
-					&& (key._tag === "List" || (actual._tag === "Item" && actual.id === key.id)),
-			),
-		)
-	);
+	return hint._tag === "Changed" && keys.every((key) => hint.keys.some((actual) => JSON.stringify(actual) === JSON.stringify(key)));
 }

package/dist/internal/makeHintPolicy.d.ts

@@ -1,4 +0,0 @@
-import { Effect } from "effect";
-import type { Key } from "#keys.ts";
-export declare const makeHintPolicy: (capacity: number, retry: (keys: readonly Key[]) => Effect.Effect<void>) => Effect.Effect<(keys: readonly Key[]) => Effect.Effect<Key[], never, never>, never, import("effect/Scope").Scope>;
-//# sourceMappingURL=makeHintPolicy.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"makeHintPolicy.d.ts","sourceRoot":"","sources":["../../src/internal/makeHintPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,MAAM,EAAe,MAAM,QAAQ,CAAC;AAC1D,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAGpC,eAAO,MAAM,cAAc,mCAAgE,SAAS,GAAG,EAAE,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,0BAqBlH,SAAS,GAAG,EAAE,6EAc3B,CAAC"}

package/dist/internal/makeHintPolicy.js

@@ -1,25 +0,0 @@
-import { Cache, Data, Effect, Exit, Queue } from "effect";
-import { ReadPolicy, ReadPolicyMemoWindow } from "#readPolicy.ts";
-export const makeHintPolicy = Effect.fnUntraced(function* (capacity, retry) {
-    const policy = yield* ReadPolicy;
-    const window = yield* ReadPolicyMemoWindow;
-    const cache = yield* Cache.makeWith(policy, {
-        capacity: Math.max(1, capacity),
-        timeToLive: (exit) => (Exit.isSuccess(exit) ? window : 0),
-    });
-    const failed = new Map();
-    const wake = yield* Queue.unbounded();
-    yield* Queue.take(wake).pipe(Effect.andThen(Effect.sleep("1 second")), Effect.andThen(Effect.suspend(() => {
-        const keys = [...failed.values()];
-        failed.clear();
-        return retry(keys);
-    })), Effect.forever, Effect.forkScoped);
-    return (keys) => Effect.filter(keys, (key) => Cache.get(cache, new Data.Class(key)).pipe(Effect.catch(() => Effect.gen(function* () {
-        if (failed.size === 0) {
-            yield* Queue.offer(wake, undefined);
-        }
-        failed.set(JSON.stringify(key), key);
-        return false;
-    }))));
-});
-//# sourceMappingURL=makeHintPolicy.js.map

package/dist/internal/makeHintPolicy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"makeHintPolicy.js","sourceRoot":"","sources":["../../src/internal/makeHintPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE1D,OAAO,EAAE,UAAU,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAElE,MAAM,CAAC,MAAM,cAAc,GAAG,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,QAAgB,EAAE,KAAoD;IAChI,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,UAAU,CAAC;IACjC,MAAM,MAAM,GAAG,KAAK,CAAC,CAAC,oBAAoB,CAAC;IAC3C,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE;QAC3C,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,QAAQ,CAAC;QAC/B,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;KACzD,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,IAAI,GAAG,EAAe,CAAC;IACtC,MAAM,IAAI,GAAG,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,EAAQ,CAAC;IAC5C,KAAK,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAC3B,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,EACxC,MAAM,CAAC,OAAO,CACb,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE;QACnB,MAAM,IAAI,GAAG,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;QAClC,MAAM,CAAC,KAAK,EAAE,CAAC;QACf,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;IACpB,CAAC,CAAC,CACF,EACD,MAAM,CAAC,OAAO,EACd,MAAM,CAAC,UAAU,CACjB,CAAC;IACF,OAAO,CAAC,IAAoB,EAAE,EAAE,CAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,EAAE,CAC3B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,IAAI,CAAC,KAAK,CAAM,GAAG,CAAC,CAAC,CAAC,IAAI,CAC9C,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CACjB,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACnB,IAAI,MAAM,CAAC,IAAI,KAAK,CAAC,EAAE,CAAC;YACvB,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACrC,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC;IACd,CAAC,CAAC,CACF,CACD,CACD,CAAC;AACJ,CAAC,CAAC,CAAC"}

package/dist/keys.d.ts

@@ -1,34 +0,0 @@
-import { Schema } from "effect";
-export type Identity = string | number;
-export interface ListKey<TName extends string = string> {
-    readonly _tag: "List";
-    readonly collection: TName;
-}
-export interface ItemKey<TName extends string = string> {
-    readonly _tag: "Item";
-    readonly collection: TName;
-    readonly id: Identity;
-}
-export type Key = ListKey | ItemKey;
-export declare const Key: Schema.Union<readonly [Schema.Struct<{
-    readonly _tag: Schema.Literal<"List">;
-    readonly collection: Schema.String;
-}>, Schema.Struct<{
-    readonly _tag: Schema.Literal<"Item">;
-    readonly collection: Schema.String;
-    readonly id: Schema.Union<readonly [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 declare function collection<const TName extends string, TId extends Schema.Top & {
-    readonly Type: Identity;
-}>(name: TName, _id: TId): Collection<TName, TId["Type"]>;
-export interface KeyContext {
-    readonly scope: string;
-}
-export declare function readKeys(keys: readonly Key[], context?: KeyContext): readonly string[];
-export declare function invalidationKeys(keys: readonly Key[], context?: KeyContext): readonly string[];
-//# sourceMappingURL=keys.d.ts.map

package/dist/keys.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"keys.d.ts","sourceRoot":"","sources":["../src/keys.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;AAEvC,MAAM,WAAW,OAAO,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;CAC3B;AAED,MAAM,WAAW,OAAO,CAAC,KAAK,SAAS,MAAM,GAAG,MAAM;IACrD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC;IAC3B,QAAQ,CAAC,EAAE,EAAE,QAAQ,CAAC;CACtB;AAED,MAAM,MAAM,GAAG,GAAG,OAAO,GAAG,OAAO,CAAC;AAEpC,eAAO,MAAM,GAAG;;;;;;;IAGd,CAAC;AAEH,MAAM,WAAW,UAAU,CAAC,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,QAAQ;IACrE,QAAQ,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,OAAO,CAAC,KAAK,CAAC,CAAC;IAC3C,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IAC9B,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;CACrB;AAED,wBAAgB,UAAU,CAAC,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,MAAM,CAAC,GAAG,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,EAC1G,IAAI,EAAE,KAAK,EACX,GAAG,EAAE,GAAG,GACN,UAAU,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAMhC;AAED,MAAM,WAAW,UAAU;IAC1B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACvB;AAUD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAItF;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,GAAG,EAAE,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,SAAS,MAAM,EAAE,CAI9F"}