effect-app 4.0.0-beta.281 → 4.0.0-beta.283

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

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

package/dist/rpc/Invalidation.js

@@ -2,6 +2,7 @@ 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 DataDependencies from "../DataDependencies.js";
 import * as Effect from "../Effect.js";
 import * as S from "../Schema.js";
 const normalizeKey = (input) => {
@@ -12,7 +13,7 @@ const normalizeKey = (input) => {
 };
 // 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 isBatch = (input) => Array.isArray(input) && input[0] !== undefined && typeof input[0] !== "string";
 const normalizeInputs = (input) => isBatch(input) ? input.map(normalizeKey) : [normalizeKey(input)];
 /**
  * A single segment within an `InvalidationKey` array.
@@ -25,7 +26,13 @@ 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 });
+export const CommandMetaData = S.Struct({
+    invalidateQueries: InvalidationKeys,
+    dataDependencies: DataDependencies.DataDependencySet
+});
+export const emptyDataDependencies = { reads: [], writes: [] };
+export const makeMetaData = (invalidateQueries, dataDependencies = emptyDataDependencies) => ({ invalidateQueries, dataDependencies });
+export const QueryResponseWithMetaData = (success) => S.Struct({ payload: success, metadata: S.Struct({ dataDependencies: DataDependencies.DataDependencySet }) });
 /**
  * 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).
@@ -165,4 +172,4 @@ export const makeStreamRpc = Rpc.custom(({ defect, error, success }) => ({
     error: StreamFailureChunk(error),
     defect
 }));
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect-app",
-  "version": "4.0.0-beta.281",
+  "version": "4.0.0-beta.283",
   "license": "MIT",
   "type": "module",
   "dependencies": {
@@ -21,7 +21,7 @@
     "vitest": "^4.1.7"
   },
   "peerDependencies": {
-    "effect": "^4.0.0-beta.86"
+    "effect": "^4.0.0-beta.88"
   },
   "typesVersions": {
     "*": {

package/src/DataDependencies.ts

@@ -0,0 +1,78 @@
+import * as Ref from "effect/Ref"
+import * as Context from "./Context.ts"
+import * as Effect from "./Effect.ts"
+import * as S from "./Schema.ts"
+
+export const DataDependency = S.Struct({
+  type: S.Literals(["repo", "signal"]),
+  name: S.String
+})
+export type DataDependency = S.Schema.Type<typeof DataDependency>
+
+export const DataDependencies = S.Array(DataDependency)
+export type DataDependencies = S.Schema.Type<typeof DataDependencies>
+
+export const DataDependencySet = S.Struct({
+  reads: DataDependencies,
+  writes: DataDependencies
+})
+export type DataDependencySet = S.Schema.Type<typeof DataDependencySet>
+
+export interface DataDependencyRecorderService {
+  readonly read: (dependency: DataDependency) => Effect.Effect<void>
+  readonly write: (dependency: DataDependency) => Effect.Effect<void>
+  readonly get: Effect.Effect<DataDependencySet>
+  readonly drain: Effect.Effect<DataDependencySet>
+  readonly drainWrites: Effect.Effect<DataDependencies>
+}
+
+const containsDependency = (dependencies: ReadonlyArray<DataDependency>, dependency: DataDependency) =>
+  dependencies.some((_) => _.type === dependency.type && _.name === dependency.name)
+
+const appendDependency = (dependency: DataDependency) => (dependencies: DataDependencies): DataDependencies =>
+  containsDependency(dependencies, dependency) ? dependencies : [...dependencies, dependency]
+
+export const DataDependencyRecorder = Context.Reference<DataDependencyRecorderService>(
+  "effect-app/DataDependencyRecorder",
+  {
+    defaultValue: () => ({
+      read: (_dependency) => Effect.void,
+      write: (_dependency) => Effect.void,
+      get: Effect.succeed({ reads: [], writes: [] }),
+      drain: Effect.succeed({ reads: [], writes: [] }),
+      drainWrites: Effect.succeed([])
+    })
+  }
+)
+export type DataDependencyRecorder = typeof DataDependencyRecorder
+
+export const makeDataDependencyRecorder = (
+  readsRef: Ref.Ref<DataDependencies>,
+  writesRef: Ref.Ref<DataDependencies>
+): DataDependencyRecorderService => ({
+  read: (dependency) => Ref.update(readsRef, appendDependency(dependency)),
+  write: (dependency) => Ref.update(writesRef, appendDependency(dependency)),
+  get: Effect.all({
+    reads: Ref.get(readsRef),
+    writes: Ref.get(writesRef)
+  }),
+  drain: Effect.all({
+    reads: Ref.getAndSet(readsRef, []),
+    writes: Ref.getAndSet(writesRef, [])
+  }),
+  drainWrites: Ref.getAndSet(writesRef, [])
+})
+
+export const repo = (name: string): DataDependency => ({ type: "repo", name })
+export const signal = (name: string): DataDependency => ({ type: "signal", name })
+
+export const QueryReadDependenciesMetaKey = "effect-app.query.readDependencies"
+
+export const read = (dependency: DataDependency) => DataDependencyRecorder.use((_) => _.read(dependency))
+
+export const write = (dependency: DataDependency) => DataDependencyRecorder.use((_) => _.write(dependency))
+
+export const intersects = (
+  a: ReadonlyArray<DataDependency>,
+  b: ReadonlyArray<DataDependency>
+) => a.some((dependency) => containsDependency(b, dependency))

package/src/Model/Repository/internal/internal.ts

@@ -7,7 +7,7 @@ import * as HashSet from "effect/HashSet"
 import * as Pipeable from "effect/Pipeable"
 import * as Ref from "effect/Ref"
 import * as Result from "effect/Result"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "../../../SchemaAST.ts"
 import type * as Scope from "effect/Scope"
 import * as Unify from "effect/Unify"
 import * as Array from "../../../Array.ts"
@@ -16,6 +16,7 @@ import { toNonEmptyArray } from "../../../Array.ts"
 import * as Chunk from "../../../Chunk.ts"
 import { NotFoundError } from "../../../client/errors.ts"
 import * as Context from "../../../Context.ts"
+import * as DataDependencies from "../../../DataDependencies.ts"
 import * as Effect from "../../../Effect.ts"
 import { flatMapOption } from "../../../Effect.ts"
 import * as Option from "../../../Option.ts"
@@ -100,6 +101,9 @@ export function makeRepoInternal<
           )
 
           const store = yield* mkStore(args.makeInitial, args.config)
+          const repoDependency = DataDependencies.repo(name)
+          const recordRead = DataDependencies.read(repoDependency)
+          const recordWrite = DataDependencies.write(repoDependency)
           const cms = Effect.map(getContextMap.pipe(Effect.orDie), (_) => ({
             get: (id: string) => _.get(`${name}.${id}`),
             set: (id: string, etag: string | undefined) => _.set(`${name}.${id}`, etag)
@@ -162,6 +166,7 @@ export function makeRepoInternal<
               (_) => decodeMany(_).pipe(Effect.orDie)
             )
             .pipe(
+              Effect.tap(() => recordRead),
               Effect.map((_) => _ as T[]),
               Effect.withSpan("Repository.all", {
                 kind: "client",
@@ -231,6 +236,7 @@ export function makeRepoInternal<
             kind: "client",
             attributes: { "app.entity": name }
           })(function*(id: T[IdKey]) {
+            yield* recordRead
             yield* Effect.annotateCurrentSpan({ "app.entity.id": id })
             return yield* flatMapOption(findE(id), (_) => Effect.orDie(decode(_)))
           })
@@ -258,6 +264,7 @@ export function makeRepoInternal<
 
           const saveAndPublish = Effect.fn("Repository.saveAndPublish", { attributes: { "app.entity": name } })(
             function*(items: Iterable<T>, events: Iterable<Evt> = []) {
+              yield* recordWrite
               const it = Chunk.fromIterable(items)
               const evts = [...events]
               yield* Effect.annotateCurrentSpan({
@@ -277,6 +284,7 @@ export function makeRepoInternal<
 
           const removeAndPublish = Effect.fn("Repository.removeAndPublish", { attributes: { "app.entity": name } })(
             function*(a: Iterable<T>, events: Iterable<Evt> = []) {
+              yield* recordWrite
               const { set } = yield* cms
               const it = [...a]
               const evts = [...events]
@@ -305,6 +313,7 @@ export function makeRepoInternal<
 
           const removeById = Effect.fn("Repository.removeById", { attributes: { "app.entity": name } })(
             function*(idOrIds: T[IdKey] | ReadonlyArray<T[IdKey]>) {
+              yield* recordWrite
               const ids = globalThis.Array.isArray(idOrIds)
                 ? idOrIds as readonly T[IdKey][]
                 : [idOrIds as T[IdKey]]
@@ -460,6 +469,7 @@ export function makeRepoInternal<
                   "db.response.returned_rows": Array.isArray(r) ? r.length : 1
                 })
               ),
+              Effect.tap(() => recordRead),
               Effect.withSpan("Repository.query", {
                 kind: "client",
                 attributes: { "app.entity": name }
@@ -552,6 +562,7 @@ export function makeRepoInternal<
               const dec = S.decodeEffectConcurrently(S.Array(schema))
               return store.queryRaw(q).pipe(
                 Effect.flatMap(dec),
+                Effect.tap(() => recordRead),
                 Effect.withSpan("Repository.queryRaw", {
                   kind: "client",
                   attributes: { "app.entity": name }
@@ -573,11 +584,13 @@ export function makeRepoInternal<
               return {
                 all: allE.pipe(
                   Effect.flatMap(decMany),
+                  Effect.tap(() => recordRead),
                   Effect.map((_) => _ as any[]),
                   Effect.withSpan("Repository.mapped.all", spanAttrs, { captureStackTrace: false })
                 ),
                 find: (id: T[IdKey]) =>
                   flatMapOption(findE(id), dec).pipe(
+                    Effect.tap(() => recordRead),
                     Effect.withSpan("Repository.mapped.find", {
                       ...spanAttrs,
                       attributes: { ...spanAttrs.attributes, "app.entity.id": id }
@@ -601,6 +614,7 @@ export function makeRepoInternal<
                 // },
                 save: (...xes: any[]) =>
                   Effect.flatMap(encMany(xes), (_) => saveAllE(_)).pipe(
+                    Effect.tap(() => recordWrite),
                     Effect.withSpan("Repository.mapped.save", spanAttrs, { captureStackTrace: false })
                   )
               }

package/src/Model/query/new-kid-interpreter.ts

@@ -2,7 +2,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 import { identity, pipe } from "effect/Function"
 import * as Match from "effect/Match"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "../../SchemaAST.ts"
 import * as Array from "../../Array.ts"
 import { toNonEmptyArray } from "../../Array.ts"
 import * as Option from "../../Option.ts"

package/src/QueueMaker.ts

@@ -1,19 +1,11 @@
-import type * as Scope from "effect/Scope"
-import type { NonEmptyReadonlyArray } from "./Array.ts"
-import type * as Effect from "./Effect.ts"
 import { RequestContext } from "./RequestContext.ts"
 
-export interface QueueBase<Evt, DrainEvt> {
-  drain: <DrainE, DrainR>(
-    makeHandleEvent: (ks: DrainEvt) => Effect.Effect<void, DrainE, DrainR>,
-    sessionId?: string
-  ) => Effect.Effect<never, never, Scope.Scope | DrainR>
-  publish: (
-    ...messages: NonEmptyReadonlyArray<Evt>
-  ) => Effect.Effect<void>
-}
-
-export interface QueueMakerOps {}
-export const QueueMaker: QueueMakerOps = {}
-
+/**
+ * Per-message context envelope (tenant/store id, request metadata) carried
+ * alongside message-schema payloads. Alias of {@link RequestContext}.
+ *
+ * All that remains of the former queue machinery (SB/SQLite/mem `QueueMaker`
+ * implementations and the `QueueBase` interface) after the move to cluster
+ * entities — the message schemas that embed it still reference this envelope.
+ */
 export const QueueMeta = RequestContext

package/src/Schema/Class.ts

@@ -3,7 +3,7 @@ import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaGetter from "effect/SchemaGetter"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"

package/src/Schema/ext.ts

@@ -37,7 +37,7 @@ import * as Function from "effect/Function"
 import * as Option from "effect/Option"
 import * as S from "effect/Schema"
 import { isDateValid } from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import * as SchemaIssue from "effect/SchemaIssue"
 import * as SchemaTransformation from "effect/SchemaTransformation"
 import { type NonEmptyReadonlyArray } from "../Array.ts"

package/src/Schema/moreStrings.ts

@@ -14,7 +14,7 @@ import type * as B from "effect/Brand"
 import * as Effect from "effect/Effect"
 import { pipe } from "effect/Function"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { customRandom, nanoid, urlAlphabet } from "nanoid"
 import validator from "validator"

package/src/Schema/numbers.ts

@@ -11,7 +11,7 @@
 import { extendM } from "effect-app/utils"
 import * as Effect from "effect/Effect"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"

package/src/Schema/schema.ts

@@ -1,5 +1,5 @@
 import * as B from "effect/Brand"
-import * as AST from "effect/SchemaAST"
+import * as AST from "../SchemaAST.ts"
 import * as P from "effect/SchemaParser"
 
 export { AST, B, P }

package/src/Schema/strings.ts

@@ -1,6 +1,6 @@
 import type * as B from "effect/Brand"
 import * as S from "effect/Schema"
-import type * as SchemaAST from "effect/SchemaAST"
+import type * as SchemaAST from "../SchemaAST.ts"
 import type { Simplify } from "effect/Types"
 import { type BrandedSchema, fromBrand, nominal } from "./brand.ts"
 import { withDefaultMake } from "./ext.ts"

package/src/Schema.ts

@@ -1,5 +1,5 @@
 import * as S from "effect/Schema"
-import * as SchemaAST from "effect/SchemaAST"
+import * as SchemaAST from "./SchemaAST.ts"
 import { type Simplify } from "effect/Struct"
 import type * as Tracer from "effect/Tracer"
 import type { RequiredKeys } from "effect/Types"
@@ -137,6 +137,19 @@ export * as SchemaParser from "./Schema/SchemaParser.ts"
 
 export { Void as Void_ } from "effect/Schema"
 
+/**
+ * Schema for a TypeScript `void` return value — the single canonical `Void`
+ * used across the app, including RPC success schemas.
+ *
+ * Built from our overridden {@link SchemaAST.Void} AST node: accepts **any
+ * present value** at runtime and discards it to `undefined`, while keeping the
+ * decoded/encoded type as `void` (effect-smol PR #2475). Use {@link Void_}
+ * (effect's original) or `S.Undefined` when the input must be exactly
+ * `undefined`.
+ */
+export interface Void extends S.Void {}
+export const Void: Void = S.make<S.Void>(new SchemaAST.Void())
+
 // ---------------------------------------------------------------------------
 // Struct / NonEmptyArray / Record
 // ---------------------------------------------------------------------------

package/src/SchemaAST.ts

@@ -0,0 +1,29 @@
+import * as Effect from "effect/Effect"
+import type * as Option from "effect/Option"
+import { Void as BaseVoid } from "effect/SchemaAST"
+
+export * from "effect/SchemaAST"
+
+/**
+ * AST node for a TypeScript `void` return value — overrides effect's
+ * `SchemaAST.Void` parser with TypeScript `void` semantics (the effect-smol
+ * PR #2475 / `b7d46ab` implementation).
+ *
+ * Runtime parsing accepts **any present value** and discards it, producing
+ * `undefined` — matching a `void` return whose result callers never observe.
+ * The decoded/encoded TypeScript representation stays `void`.
+ *
+ * @see {@link void_} for the singleton instance.
+ */
+export class Void extends BaseVoid {
+  /** @internal — mirrors the PR's `fromAnyToConst(undefined)`. */
+  getParser() {
+    const succeed = Effect.succeedSome(undefined)
+    return (oinput: Option.Option<unknown>) => oinput._tag === "None" ? Effect.succeedNone : succeed
+  }
+}
+
+const voidNode: Void = new Void()
+
+/** Singleton {@link Void} AST node — overrides effect's `void` singleton. */
+export { voidNode as void }

package/src/client/apiClientFactory.ts

@@ -10,6 +10,7 @@ import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
 import * as Config from "../Config.ts"
 import * as Context from "../Context.ts"
+import * as DataDependencies from "../DataDependencies.ts"
 import * as Effect from "../Effect.ts"
 import { HttpClient, HttpClientRequest } from "../http.ts"
 import { Invalidation } from "../rpc.ts"
@@ -142,7 +143,12 @@ export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, con
               stream: true as const
             })
             : Invalidation.makeCommandRpc(r._tag, { payload: r, success: r.success, error: r.error })
-          : Rpc.make(r._tag, { payload: r, success: r.success, error: r.error, stream: isStream })) as any
+          : Rpc.make(r._tag, {
+            payload: r,
+            success: isStream ? r.success : Invalidation.QueryResponseWithMetaData(r.success),
+            error: r.error,
+            stream: isStream
+          })) as any
       })
     )
     .prefix(`${moduleName}.`)
@@ -211,6 +217,20 @@ const makeApiClientFactory = Effect
       // `InvalidationKeysFromServer` and yield the raw payload / re-fail with the raw
       // error. Middleware-thrown failures arrive raw on the Cause already (no wrap to
       // strip) — the `else` branch passes them through.
+      const forwardDependencies = (
+        dependencies: DataDependencies.DataDependencySet | undefined,
+        options?: { readonly reads?: boolean }
+      ) =>
+        dependencies === undefined
+          ? Effect.void
+          : Effect.gen(function*() {
+            const dependencyRecorder = yield* DataDependencies.DataDependencyRecorder
+            if (options?.reads) {
+              yield* Effect.forEach(dependencies.reads, dependencyRecorder.read, { discard: true })
+            }
+            yield* Effect.forEach(dependencies.writes, dependencyRecorder.write, { discard: true })
+          })
+
       const unwrapCommand = (eff: Effect.Effect<any, any, any>): Effect.Effect<any, any, any> =>
         eff.pipe(
           Effect.flatMap((result: any) =>
@@ -218,6 +238,7 @@ const makeApiClientFactory = Effect
               const keys: ReadonlyArray<Invalidation.InvalidationKey> = result?.metadata?.invalidateQueries ?? []
               const invalidationKeys = yield* InvalidationKeysFromServer
               yield* Effect.forEach(keys, (key) => invalidationKeys.add(key), { discard: true })
+              yield* forwardDependencies(result?.metadata?.dataDependencies)
               return result.payload
             })
           ),
@@ -227,12 +248,23 @@ const makeApiClientFactory = Effect
                 const keys: ReadonlyArray<Invalidation.InvalidationKey> = result.metadata?.invalidateQueries ?? []
                 const invalidationKeys = yield* InvalidationKeysFromServer
                 yield* Effect.forEach(keys, (key) => invalidationKeys.add(key), { discard: true })
+                yield* forwardDependencies(result.metadata?.dataDependencies)
                 return yield* Effect.fail(result.error)
               })
               : Effect.fail(result)
           )
         )
 
+      const unwrapQuery = (eff: Effect.Effect<any, any, any>): Effect.Effect<any, any, any> =>
+        eff.pipe(
+          Effect.flatMap((result: any) =>
+            Effect.gen(function*() {
+              yield* forwardDependencies(result?.metadata?.dataDependencies, { reads: true })
+              return result.payload
+            })
+          )
+        )
+
       return {
         mr,
         client: typedKeysOf(filtered)
@@ -275,7 +307,7 @@ const makeApiClientFactory = Effect
                       Effect.provide(layers, { local: true }),
                       Effect.provide(svcs)
                     )
-                  return isCommand ? unwrapCommand(rpcEffect) : rpcEffect
+                  return isCommand ? unwrapCommand(rpcEffect) : isStream ? rpcEffect : unwrapQuery(rpcEffect)
                 })
               )
 
@@ -292,13 +324,24 @@ const makeApiClientFactory = Effect
                           // Collect server invalidation keys from the "done" chunk, then discard it.
                           Stream.tap((item: any) =>
                             item._tag === "done" || item._tag === "metadata"
-                              ? InvalidationKeysFromServer.use((svc) =>
-                                Effect.forEach(
-                                  (item.metadata as Invalidation.CommandMetaData).invalidateQueries,
-                                  svc.add,
+                              ? Effect.gen(function*() {
+                                const metadata = item.metadata as Invalidation.CommandMetaData
+                                const invalidationKeys = yield* InvalidationKeysFromServer
+                                yield* Effect.forEach(metadata.invalidateQueries, invalidationKeys.add, {
+                                  discard: true
+                                })
+                                const dependencyRecorder = yield* DataDependencies.DataDependencyRecorder
+                                yield* Effect.forEach(
+                                  metadata.dataDependencies.reads,
+                                  dependencyRecorder.read,
                                   { discard: true }
                                 )
-                              )
+                                yield* Effect.forEach(
+                                  metadata.dataDependencies.writes,
+                                  dependencyRecorder.write,
+                                  { discard: true }
+                                )
+                              })
                               : Effect.void
                           ),
                           Stream.filter((item: any) => item._tag === "value"),
@@ -309,15 +352,20 @@ const makeApiClientFactory = Effect
                           Stream.catch((err: any) =>
                             err?._tag === "error" && err?.metadata
                               ? Stream.fromEffect(
-                                InvalidationKeysFromServer.use((svc) =>
-                                  Effect
-                                    .forEach(
-                                      (err.metadata as Invalidation.CommandMetaData).invalidateQueries,
-                                      svc.add,
-                                      { discard: true }
-                                    )
-                                    .pipe(Effect.flatMap(() => Effect.fail(err.error)))
-                                )
+                                Effect.gen(function*() {
+                                  const metadata = err.metadata as Invalidation.CommandMetaData
+                                  const invalidationKeys = yield* InvalidationKeysFromServer
+                                  yield* Effect.forEach(metadata.invalidateQueries, invalidationKeys.add, {
+                                    discard: true
+                                  })
+                                  const dependencyRecorder = yield* DataDependencies.DataDependencyRecorder
+                                  yield* Effect.forEach(
+                                    metadata.dataDependencies.writes,
+                                    dependencyRecorder.write,
+                                    { discard: true }
+                                  )
+                                  return yield* Effect.fail(err.error)
+                                })
                               )
                               : Stream.fail(err)
                           ),