effect-app 4.0.0-beta.21 → 4.0.0-beta.210

package/dist/rpc/Invalidation.d.ts

@@ -0,0 +1,402 @@
+import * as Ref from "effect/Ref";
+import { Rpc } from "effect/unstable/rpc";
+import * as Context from "../Context.js";
+import * as Effect from "../Effect.js";
+import * as S from "../Schema.js";
+/**
+ * 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>> & {
+    withDefault: 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>>>;
+};
+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>> & {
+    withDefault: 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>>>;
+}> & {
+    withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withDefault: 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>>>;
+    }>>;
+    withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+        withDefault: 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>>>;
+    }>>;
+};
+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>> & {
+        withDefault: 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>>>;
+    }> & {
+        withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withDefault: 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>>>;
+        }>>;
+        withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+            withDefault: 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>>>;
+        }>>;
+    };
+}>;
+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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>;
+/**
+ * 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>;
+/**
+ * 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>, 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>]>;
+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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>;
+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: (key: InvalidationKey) => 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.use(_ => _.add(key))` (or `.useSync` for non-Effect callbacks) as a
+ * shorthand instead of yielding the service manually.
+ *
+ * Prefer `makeQueryKey` over raw string arrays so invalidation keys stay in sync with the
+ * actual query definitions automatically:
+ *
+ * ```ts
+ * import { makeQueryKey } from "effect-app/client"
+ * import { Effect } from "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)
+ *
+ *   // Stage 1 – unconditional: always invalidate after saving
+ *   yield* Invalidation.InvalidationSet.use(_ => _.add(makeQueryKey(UserRsc.GetMe)))
+ *
+ *   // Stage 2 – conditional: only if the cart changed state
+ *   if (cart.isCheckedOut) {
+ *     yield* Invalidation.InvalidationSet.use(_ => _.add(makeQueryKey(CartRsc.GetCartStats)))
+ *   }
+ *
+ *   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.
+ */
+export declare const InvalidationSet: Context.Reference<InvalidationSetService>;
+export type InvalidationSet = typeof InvalidationSet;
+/** 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>, 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>>>(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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>, 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>]>, 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>> & {
+            withDefault: 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>>>;
+        }> & {
+            withDefault: S.withConstructorDefault<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+            withDecodingDefaultType: S.withDecodingDefaultType<S.$Array<S.$Array<S.Codec<S.Json, S.Json, never, never>> & {
+                withDefault: 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>>>;
+            }>>;
+        };
+    }>;
+}>>>(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>;
+//# sourceMappingURL=data:application/json;base64,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

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,150 @@
+import * as Ref from "effect/Ref";
+import { Rpc } from "effect/unstable/rpc";
+import * as Context from "../Context.js";
+import * as Effect from "../Effect.js";
+import * as S from "../Schema.js";
+/**
+ * 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.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 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.use(_ => _.add(key))` (or `.useSync` for non-Effect callbacks) as a
+ * shorthand instead of yielding the service manually.
+ *
+ * Prefer `makeQueryKey` over raw string arrays so invalidation keys stay in sync with the
+ * actual query definitions automatically:
+ *
+ * ```ts
+ * import { makeQueryKey } from "effect-app/client"
+ * import { Effect } from "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)
+ *
+ *   // Stage 1 – unconditional: always invalidate after saving
+ *   yield* Invalidation.InvalidationSet.use(_ => _.add(makeQueryKey(UserRsc.GetMe)))
+ *
+ *   // Stage 2 – conditional: only if the cart changed state
+ *   if (cart.isCheckedOut) {
+ *     yield* Invalidation.InvalidationSet.use(_ => _.add(makeQueryKey(CartRsc.GetCartStats)))
+ *   }
+ *
+ *   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.
+ */
+export const InvalidationSet = Context.Reference("effect-app/rpc/InvalidationSet", {
+    defaultValue: () => ({
+        add: (_key) => Effect.void,
+        get: Effect.succeed([]),
+        drain: Effect.succeed([])
+    })
+});
+/** Creates a fresh `InvalidationSet` implementation backed by a `Ref`. */
+export const makeInvalidationSet = (ref) => ({
+    add: (key) => Ref.update(ref, (keys) => [...keys, key]),
+    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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

package/dist/rpc/MiddlewareMaker.d.ts

@@ -1,8 +1,9 @@
-import { Effect, Layer, type Schema, Schema as S, type Scope, ServiceMap } from "effect";
+import { Effect, Layer, type Schema, Schema as S, type Scope } from "effect";
 import { type NonEmptyArray, type NonEmptyReadonlyArray } from "effect/Array";
 import { type Simplify } from "effect/Types";
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc";
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup";
+import * as Context from "../Context.js";
 import { type TypeTestId } from "../TypeTest.js";
 import { type GetContextConfig, type RequestContextMapTagAny, type RpcContextMap } from "./RpcContextMap.js";
 import { type AddMiddleware, type AnyDynamic, type RpcDynamic, type TagClassAny } from "./RpcMiddleware.js";
@@ -18,11 +19,11 @@ export interface MiddlewareMaker<Self, Id extends string, RequestContextMap exte
     provides: MiddlewareMaker.ManyProvided<MiddlewareProviders> extends never ? never : MakeTags<MiddlewareMaker.ManyProvided<MiddlewareProviders>>;
     requires: Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>> extends never ? never : MakeTags<Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>>;
 }> {
-    readonly layer: Layer.Layer<Self, never, ServiceMap.Service.Identifier<MiddlewareProviders[number]>>;
+    readonly layer: Layer.Layer<Self, never, Context.Service.Identifier<MiddlewareProviders[number]>>;
     readonly requestContext: RequestContextTag<RequestContextMap>;
     readonly requestContextMap: RequestContextMap;
 }
-export interface RequestContextTag<RequestContextMap extends Record<string, RpcContextMap.Any>> extends ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>> {
+export interface RequestContextTag<RequestContextMap extends Record<string, RpcContextMap.Any>> extends Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>> {
 }
 export declare namespace MiddlewareMaker {
     type Any = TagClassAny;
@@ -131,4 +132,4 @@ export declare const middlewareGroup: <RequestContextMap extends Record<string,
     toLayerDynamic: <Handlers extends HandlersFrom<AddMiddleware<R, Middleware>>, EX = never, RX = never>(build: Handlers | Effect.Effect<Handlers, EX, RX>) => Layer.Layer<Rpc.ToHandler<AddMiddleware<R, Middleware>>, EX, Exclude<RX, Scope.Scope> | RpcMiddlewareX.HandlersContext<AddMiddleware<R, Middleware>, Handlers>>;
 };
 export {};
-//# sourceMappingURL=MiddlewareMaker.d.ts.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MiddlewareMaker.d.ts","sourceRoot":"","sources":["../../src/rpc/MiddlewareMaker.ts"],"names":[],"mappings":"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"}