effect-app 4.0.0-beta.27 → 4.0.0-beta.272

package/dist/rpc/Invalidation.d.ts

@@ -0,0 +1,420 @@
+import * as Ref from "effect/Ref";
+import { Rpc } from "effect/unstable/rpc";
+import { type ClientForOptions } from "../client/clientFor.js";
+import * as Context from "../Context.js";
+import * as Effect from "../Effect.js";
+import * as S from "../Schema.js";
+/**
+ * Shorthand for a handler-derived invalidation key.
+ * Accepts an RPC handler object so `add(GetMe)` is equivalent to
+ * `add(makeQueryKey(GetMe))`.
+ */
+export type InvalidationKeyInput = InvalidationKey | {
+    readonly id: string;
+    readonly options?: ClientForOptions;
+};
+/**
+ * A single segment within an `InvalidationKey` array.
+ * Accepts any JSON-compatible value: string, number, boolean, null,
+ * arrays and objects recursively — matching TanStack Query's `queryKey` element type.
+ */
+export declare const InvalidationKeySegment: S.Codec<S.Json, S.Json, never, never>;
+export type InvalidationKeySegment = S.Schema.Type<typeof InvalidationKeySegment>;
+/** Schema for a single invalidation key – an array of segments compatible with TanStack Query `queryKey`. */
+export declare const InvalidationKey: S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+};
+export type InvalidationKey = S.Schema.Type<typeof InvalidationKey>;
+/** Schema for the full set of invalidation keys – an array of `InvalidationKey`. */
+export declare const InvalidationKeys: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+}> & {
+    withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }>, never>;
+};
+export type InvalidationKeys = S.Schema.Type<typeof InvalidationKeys>;
+/** Metadata included in every command response for server-driven cache invalidation. */
+export declare const CommandMetaData: S.Struct<{
+    readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+    }> & {
+        withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }>, never>;
+    };
+}>;
+export type CommandMetaData = S.Schema.Type<typeof CommandMetaData>;
+/**
+ * Wraps a command's success schema so that the wire format carries both the `payload`
+ * (the handler's actual return value) and `metadata` (server-driven cache invalidation keys).
+ * Transparent to users: the server handler returns the plain payload and the client receives
+ * the plain payload — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export declare const CommandResponseWithMetaData: <S extends S.Top>(success: S) => S.Struct<{
+    readonly payload: S;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>;
+/**
+ * Wraps a command's failure schema so that the wire format carries both the `error`
+ * (the handler's actual failure value) and `metadata` (server-driven cache invalidation keys
+ * accumulated thus far before the failure occurred).
+ * Transparent to users: the server handler fails with the plain error and the client receives
+ * the plain error — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export declare const CommandFailureWithMetaData: <E extends S.Top>(error: E) => S.Struct<{
+    readonly _tag: S.Literal<"CommandFailureWithMetaData">;
+    readonly error: E;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>;
+/**
+ * Stream chunk schema for stream responses with metadata.
+ * Each item is either a data value, an intermediate "metadata" signal carrying cache
+ * invalidation keys accumulated since the previous drain, or a final "done" signal.
+ * Transparent to users: stream handlers return plain values and clients receive plain values —
+ * wrapping/unwrapping is handled internally by the routing layer.
+ *
+ * The "done" chunk is always the last item in the stream and carries any remaining invalidation
+ * keys. An optional "metadata" chunk may appear after any "value" chunk and carries keys
+ * accumulated since the last drain (V3: mid-stream invalidation).
+ */
+export declare const StreamResponseChunk: <S extends S.Top>(success: S) => S.Union<readonly [S.Struct<{
+    readonly _tag: S.Literal<"value">;
+    readonly value: S;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"metadata">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"done">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>]>;
+export type StreamResponseChunk<A> = {
+    readonly _tag: "value";
+    readonly value: A;
+} | {
+    readonly _tag: "metadata";
+    readonly metadata: CommandMetaData;
+} | {
+    readonly _tag: "done";
+    readonly metadata: CommandMetaData;
+};
+/**
+ * Stream chunk schema for stream failures with metadata.
+ * Used to signal a stream failure while still carrying cache invalidation keys
+ * accumulated thus far.
+ */
+export declare const StreamFailureChunk: <E extends S.Top>(error: E) => S.Struct<{
+    readonly _tag: S.Literal<"error">;
+    readonly error: E;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>;
+export type StreamFailureChunk<E> = {
+    readonly _tag: "error";
+    readonly error: E;
+    readonly metadata: CommandMetaData;
+};
+/**
+ * Context annotation for declaring static cache invalidation keys on a low-level `Rpc` definition.
+ * These keys are always included in the command response metadata, regardless of the handler logic.
+ *
+ * Prefer using `makeQueryKey` over raw string arrays to stay in sync with the actual query
+ * definitions without manual string maintenance:
+ *
+ * ```ts
+ * import { makeQueryKey } from "effect-app/client"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as UserRsc from "../User/index.js"  // separate module to avoid circular deps
+ *
+ * class UpdateProfile extends Rpc.make("UpdateProfile", { ... })
+ *   .annotate(Invalidation.Invalidates, [makeQueryKey(UserRsc.GetMe), makeQueryKey(UserRsc.GetProfile)]) {}
+ * ```
+ *
+ * **Circular dependency note:** if mutations and queries live in the same file you may hit a
+ * circular reference at evaluation time. The idiomatic fix is to move mutations into their own
+ * module (e.g. `User/mutations.ts`) that directly imports the relevant query classes rather than
+ * re-exporting them through a barrel.
+ *
+ * For the higher-level `Command`/`Query` builders from `makeRpcClient`, use the
+ * `invalidatesQueries` callback argument instead (it receives the same query keys at runtime).
+ */
+export declare const Invalidates: Context.Reference<readonly (readonly S.Json[])[]>;
+export type Invalidates = typeof Invalidates;
+/** The shape of the per-request service that accumulates invalidation keys. */
+export interface InvalidationSetService {
+    readonly add: (input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>) => Effect.Effect<void>;
+    readonly get: Effect.Effect<ReadonlyArray<InvalidationKey>>;
+    /**
+     * V3: Reads all currently accumulated keys and resets the bucket to empty.
+     * Used by the stream routing layer to emit intermediate "metadata" chunks
+     * without re-sending keys that have already been forwarded to the client.
+     */
+    readonly drain: Effect.Effect<ReadonlyArray<InvalidationKey>>;
+}
+/**
+ * Request-scoped service for accumulating invalidation keys dynamically inside a handler.
+ * Provided by `InvalidationMiddlewareLive` for every RPC call; has a no-op default so it is
+ * safe to use even when the HTTP middleware is absent (tests, workers, etc.).
+ *
+ * Use `InvalidationSet.add(key)` as a shorthand to skip `.use(_ => _.add(key))`. The
+ * underlying service is still available via `.use` / `.useSync` for advanced cases.
+ *
+ * `add` accepts an RPC handler directly (e.g. `UserRsc.GetMe`) — its query key is derived via
+ * `makeQueryKey` so keys stay in sync with the actual query definitions. Raw `InvalidationKey`
+ * arrays and arrays of either form are also accepted.
+ *
+ * ```ts
+ * import * as Effect from "effect/Effect"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as CartRsc from "../Cart/queries.js"
+ * import * as UserRsc from "../User/queries.js"
+ *
+ * const handler = Effect.fnUntraced(function*(req: UpdateCartRequest) {
+ *   const cart = yield* CartRepo.save(req.cart)
+ *
+ *   // single handler
+ *   yield* Invalidation.InvalidationSet.add(UserRsc.GetMe)
+ *
+ *   // batch
+ *   if (cart.isCheckedOut) {
+ *     yield* Invalidation.InvalidationSet.add([CartRsc.GetCartStats, UserRsc.GetMe])
+ *   }
+ *
+ *   return cart
+ * })
+ * ```
+ *
+ * You can combine static (`Invalidates` annotation) and dynamic (`InvalidationSet.use`) keys:
+ * the annotation pre-populates the set before the handler runs; dynamic additions accumulate
+ * throughout the handler. All keys are included in the command response metadata.
+ */
+declare const InvalidationSetRef: Context.Reference<InvalidationSetService>;
+export declare const InvalidationSet: Context.Reference<InvalidationSetService> & {
+    /**
+     * Shortcut for `InvalidationSet.use(_ => _.add(input))`. Accepts a single
+     * `InvalidationKeyInput` or an array of them.
+     */
+    add: (input: InvalidationKeyInput | ReadonlyArray<InvalidationKeyInput>) => Effect.Effect<void, never, never>;
+};
+export type InvalidationSet = typeof InvalidationSetRef;
+/** Creates a fresh `InvalidationSet` implementation backed by a `Ref`. */
+export declare const makeInvalidationSet: (ref: Ref.Ref<ReadonlyArray<InvalidationKey>>) => InvalidationSetService;
+/**
+ * `Rpc.Custom` definition for command RPCs that wrap the success/error schemas
+ * with `CommandResponseWithMetaData` / `CommandFailureWithMetaData`. The wrap
+ * lets server forward accumulated invalidation keys on both success and
+ * handler-thrown failure paths. Middleware-thrown errors bypass the wrap
+ * (the handler never ran, so no metadata) and flow raw at the Cause level —
+ * the client decodes them via the `rpc.middlewares[*].error` failure-union
+ * channel of `Rpc.exitSchema`.
+ */
+export interface CommandRpc extends Rpc.Custom {
+    readonly out: Rpc.Custom.Out<ReturnType<typeof CommandResponseWithMetaData<this["success"] & S.Top>>, ReturnType<typeof CommandFailureWithMetaData<this["error"] & S.Top>>>;
+}
+/**
+ * Custom Rpc constructor for command RPCs.
+ * Wraps the success schema with `CommandResponseWithMetaData` and the error
+ * schema with `CommandFailureWithMetaData`.
+ */
+export declare const makeCommandRpc: <const Tag extends string, Payload extends S.Top | import("effect/Schema").Struct.Fields = S.Void, Success extends S.Top = S.Void, Error extends S.Top = S.Never, const Stream extends boolean = false, Out extends Rpc.Custom.OutDefault = Rpc.Custom.Out<S.Struct<{
+    readonly payload: S.Top & Success;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"CommandFailureWithMetaData">;
+    readonly error: S.Top & Error;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>>>(tag: Tag, options?: {
+    readonly payload?: Payload;
+    readonly success?: Success;
+    readonly error?: Error;
+    readonly defect?: Rpc.DefectSchema;
+    readonly stream?: Stream;
+    readonly primaryKey?: [Payload] extends [import("effect/Schema").Struct.Fields] ? (payload: Payload extends import("effect/Schema").Struct.Fields ? (import("effect/Schema").Struct.Type_<Payload, import("effect/Schema").Struct.TypeOptionalKeys<Payload>, import("effect/Schema").Struct.TypeMutableKeys<Payload>> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never : Payload["Type"]) => string : never;
+} | undefined) => Rpc.Rpc<Tag, Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct<Payload> : Payload, Stream extends true ? import("effect/unstable/rpc/RpcSchema").Stream<Out["success"], Out["error"]> : Out["success"], Stream extends true ? S.Never : Out["error"], never, never>;
+/**
+ * `Rpc.Custom` definition for stream RPCs that wrap the success/error schemas
+ * with `StreamResponseChunk` / `StreamFailureChunk`.
+ */
+export interface StreamRpc extends Rpc.Custom {
+    readonly out: Rpc.Custom.Out<ReturnType<typeof StreamResponseChunk<this["success"] & S.Top>>, ReturnType<typeof StreamFailureChunk<this["error"] & S.Top>>>;
+}
+/**
+ * Custom Rpc constructor for stream RPCs.
+ * Wraps the success schema with `StreamResponseChunk` and
+ * the error schema with `StreamFailureChunk`.
+ */
+export declare const makeStreamRpc: <const Tag extends string, Payload extends S.Top | import("effect/Schema").Struct.Fields = S.Void, Success extends S.Top = S.Void, Error extends S.Top = S.Never, const Stream extends boolean = false, Out extends Rpc.Custom.OutDefault = Rpc.Custom.Out<S.Union<readonly [S.Struct<{
+    readonly _tag: S.Literal<"value">;
+    readonly value: S.Top & Success;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"metadata">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>, S.Struct<{
+    readonly _tag: S.Literal<"done">;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>]>, S.Struct<{
+    readonly _tag: S.Literal<"error">;
+    readonly error: S.Top & Error;
+    readonly metadata: S.Struct<{
+        readonly invalidateQueries: S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+        }> & {
+            withConstructorDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withConstructorDefault: S.withConstructorDefault<S.$Array<S.Codec<S.Json, S.Json, never, never>>>;
+                withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.Codec<S.Json, S.Json, never, never>>, never>;
+            }>, never>;
+        };
+    }>;
+}>>>(tag: Tag, options?: {
+    readonly payload?: Payload;
+    readonly success?: Success;
+    readonly error?: Error;
+    readonly defect?: Rpc.DefectSchema;
+    readonly stream?: Stream;
+    readonly primaryKey?: [Payload] extends [import("effect/Schema").Struct.Fields] ? (payload: Payload extends import("effect/Schema").Struct.Fields ? (import("effect/Schema").Struct.Type_<Payload, import("effect/Schema").Struct.TypeOptionalKeys<Payload>, import("effect/Schema").Struct.TypeMutableKeys<Payload>> extends infer T_1 ? { [K in keyof T_1]: T_1[K]; } : never) extends infer T ? { [K in keyof T]: T[K]; } : never : Payload["Type"]) => string : never;
+} | undefined) => Rpc.Rpc<Tag, Payload extends import("effect/Schema").Struct.Fields ? import("effect/Schema").Struct<Payload> : Payload, Stream extends true ? import("effect/unstable/rpc/RpcSchema").Stream<Out["success"], Out["error"]> : Out["success"], Stream extends true ? S.Never : Out["error"], never, never>;
+export {};
+//# sourceMappingURL=Invalidation.d.ts.map

package/dist/rpc/Invalidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Invalidation.d.ts","sourceRoot":"","sources":["../../src/rpc/Invalidation.ts"],"names":[],"mappings":"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"}

package/dist/rpc/Invalidation.js

@@ -0,0 +1,168 @@
+import * as Ref from "effect/Ref";
+import { Rpc } from "effect/unstable/rpc";
+import { makeQueryKey } from "../client/clientFor.js";
+import * as Context from "../Context.js";
+import * as Effect from "../Effect.js";
+import * as S from "../Schema.js";
+const normalizeKey = (input) => {
+    if (Array.isArray(input))
+        return input;
+    const handler = input;
+    return makeQueryKey(handler.options ? { id: handler.id, options: handler.options } : { id: handler.id });
+};
+// Disambiguates `add` overloads: a `string[]` means a single key; an array
+// containing arrays-or-objects means a batch of inputs.
+const isBatch = (input) => Array.isArray(input) && input.length > 0 && typeof input[0] !== "string";
+const normalizeInputs = (input) => isBatch(input) ? input.map(normalizeKey) : [normalizeKey(input)];
+/**
+ * A single segment within an `InvalidationKey` array.
+ * Accepts any JSON-compatible value: string, number, boolean, null,
+ * arrays and objects recursively — matching TanStack Query's `queryKey` element type.
+ */
+export const InvalidationKeySegment = S.Json;
+/** Schema for a single invalidation key – an array of segments compatible with TanStack Query `queryKey`. */
+export const InvalidationKey = S.Array(InvalidationKeySegment);
+/** Schema for the full set of invalidation keys – an array of `InvalidationKey`. */
+export const InvalidationKeys = S.Array(InvalidationKey);
+/** Metadata included in every command response for server-driven cache invalidation. */
+export const CommandMetaData = S.Struct({ invalidateQueries: InvalidationKeys });
+/**
+ * Wraps a command's success schema so that the wire format carries both the `payload`
+ * (the handler's actual return value) and `metadata` (server-driven cache invalidation keys).
+ * Transparent to users: the server handler returns the plain payload and the client receives
+ * the plain payload — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export const CommandResponseWithMetaData = (success) => S.Struct({ payload: success, metadata: CommandMetaData });
+/**
+ * Wraps a command's failure schema so that the wire format carries both the `error`
+ * (the handler's actual failure value) and `metadata` (server-driven cache invalidation keys
+ * accumulated thus far before the failure occurred).
+ * Transparent to users: the server handler fails with the plain error and the client receives
+ * the plain error — wrapping/unwrapping is handled internally by the routing layer.
+ */
+export const CommandFailureWithMetaData = (error) => S.Struct({ _tag: S.Literal("CommandFailureWithMetaData"), error, metadata: CommandMetaData });
+/**
+ * Stream chunk schema for stream responses with metadata.
+ * Each item is either a data value, an intermediate "metadata" signal carrying cache
+ * invalidation keys accumulated since the previous drain, or a final "done" signal.
+ * Transparent to users: stream handlers return plain values and clients receive plain values —
+ * wrapping/unwrapping is handled internally by the routing layer.
+ *
+ * The "done" chunk is always the last item in the stream and carries any remaining invalidation
+ * keys. An optional "metadata" chunk may appear after any "value" chunk and carries keys
+ * accumulated since the last drain (V3: mid-stream invalidation).
+ */
+export const StreamResponseChunk = (success) => S.Union([
+    S.Struct({ _tag: S.Literal("value"), value: success }),
+    S.Struct({ _tag: S.Literal("metadata"), metadata: CommandMetaData }),
+    S.Struct({ _tag: S.Literal("done"), metadata: CommandMetaData })
+]);
+/**
+ * Stream chunk schema for stream failures with metadata.
+ * Used to signal a stream failure while still carrying cache invalidation keys
+ * accumulated thus far.
+ */
+export const StreamFailureChunk = (error) => S.Struct({ _tag: S.Literal("error"), error, metadata: CommandMetaData });
+/**
+ * Context annotation for declaring static cache invalidation keys on a low-level `Rpc` definition.
+ * These keys are always included in the command response metadata, regardless of the handler logic.
+ *
+ * Prefer using `makeQueryKey` over raw string arrays to stay in sync with the actual query
+ * definitions without manual string maintenance:
+ *
+ * ```ts
+ * import { makeQueryKey } from "effect-app/client"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as UserRsc from "../User/index.ts"  // separate module to avoid circular deps
+ *
+ * class UpdateProfile extends Rpc.make("UpdateProfile", { ... })
+ *   .annotate(Invalidation.Invalidates, [makeQueryKey(UserRsc.GetMe), makeQueryKey(UserRsc.GetProfile)]) {}
+ * ```
+ *
+ * **Circular dependency note:** if mutations and queries live in the same file you may hit a
+ * circular reference at evaluation time. The idiomatic fix is to move mutations into their own
+ * module (e.g. `User/mutations.ts`) that directly imports the relevant query classes rather than
+ * re-exporting them through a barrel.
+ *
+ * For the higher-level `Command`/`Query` builders from `makeRpcClient`, use the
+ * `invalidatesQueries` callback argument instead (it receives the same query keys at runtime).
+ */
+export const Invalidates = Context.Reference("effect-app/rpc/Invalidates", { defaultValue: () => [] });
+/**
+ * Request-scoped service for accumulating invalidation keys dynamically inside a handler.
+ * Provided by `InvalidationMiddlewareLive` for every RPC call; has a no-op default so it is
+ * safe to use even when the HTTP middleware is absent (tests, workers, etc.).
+ *
+ * Use `InvalidationSet.add(key)` as a shorthand to skip `.use(_ => _.add(key))`. The
+ * underlying service is still available via `.use` / `.useSync` for advanced cases.
+ *
+ * `add` accepts an RPC handler directly (e.g. `UserRsc.GetMe`) — its query key is derived via
+ * `makeQueryKey` so keys stay in sync with the actual query definitions. Raw `InvalidationKey`
+ * arrays and arrays of either form are also accepted.
+ *
+ * ```ts
+ * import * as Effect from "effect/Effect"
+ * import { Invalidation } from "effect-app/rpc"
+ * import * as CartRsc from "../Cart/queries.ts"
+ * import * as UserRsc from "../User/queries.ts"
+ *
+ * const handler = Effect.fnUntraced(function*(req: UpdateCartRequest) {
+ *   const cart = yield* CartRepo.save(req.cart)
+ *
+ *   // single handler
+ *   yield* Invalidation.InvalidationSet.add(UserRsc.GetMe)
+ *
+ *   // batch
+ *   if (cart.isCheckedOut) {
+ *     yield* Invalidation.InvalidationSet.add([CartRsc.GetCartStats, UserRsc.GetMe])
+ *   }
+ *
+ *   return cart
+ * })
+ * ```
+ *
+ * You can combine static (`Invalidates` annotation) and dynamic (`InvalidationSet.use`) keys:
+ * the annotation pre-populates the set before the handler runs; dynamic additions accumulate
+ * throughout the handler. All keys are included in the command response metadata.
+ */
+const InvalidationSetRef = Context.Reference("effect-app/rpc/InvalidationSet", {
+    defaultValue: () => ({
+        add: (_input) => Effect.void,
+        get: Effect.succeed([]),
+        drain: Effect.succeed([])
+    })
+});
+export const InvalidationSet = Object.assign(InvalidationSetRef, {
+    /**
+     * Shortcut for `InvalidationSet.use(_ => _.add(input))`. Accepts a single
+     * `InvalidationKeyInput` or an array of them.
+     */
+    add: (input) => InvalidationSetRef.use((_) => _.add(input))
+});
+/** Creates a fresh `InvalidationSet` implementation backed by a `Ref`. */
+export const makeInvalidationSet = (ref) => ({
+    add: (input) => Ref.update(ref, (keys) => [...keys, ...normalizeInputs(input)]),
+    get: Ref.get(ref),
+    drain: Ref.getAndSet(ref, [])
+});
+/**
+ * Custom Rpc constructor for command RPCs.
+ * Wraps the success schema with `CommandResponseWithMetaData` and the error
+ * schema with `CommandFailureWithMetaData`.
+ */
+export const makeCommandRpc = Rpc.custom(({ defect, error, success }) => ({
+    success: CommandResponseWithMetaData(success),
+    error: CommandFailureWithMetaData(error),
+    defect
+}));
+/**
+ * Custom Rpc constructor for stream RPCs.
+ * Wraps the success schema with `StreamResponseChunk` and
+ * the error schema with `StreamFailureChunk`.
+ */
+export const makeStreamRpc = Rpc.custom(({ defect, error, success }) => ({
+    success: StreamResponseChunk(success),
+    error: StreamFailureChunk(error),
+    defect
+}));
+//# sourceMappingURL=data:application/json;base64,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