effect-app 4.0.0-beta.3 → 4.0.0-beta.300

package/src/client/apiClientFactory.ts

@@ -1,19 +1,23 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import * as Config from "effect/Config"
-import { flow } from "effect/Function"
+import { constant, flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as ManagedRuntime from "effect/ManagedRuntime"
+import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Schema from "effect/Schema"
+import * as Stream from "effect/Stream"
 import * as Struct from "effect/Struct"
 import { Rpc, RpcClient, RpcGroup, RpcSerialization } from "effect/unstable/rpc"
-import * as Effect from "../Effect.js"
-import { HttpClient, HttpClientRequest } from "../http.js"
-import * as Option from "../Option.js"
-import type * as S from "../Schema.js"
-import * as ServiceMap from "../ServiceMap.js"
-import { typedKeysOf, typedValuesOf } from "../utils.js"
-import type { Client, ClientForOptions, Requests, RequestsAny } from "./clientFor.js"
+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"
+import type * as S from "../Schema.ts"
+import { typedKeysOf, typedValuesOf } from "../utils.ts"
+import type { Client, ClientForOptions, ExtractModuleName, RequestsAny } from "./clientFor.ts"
+import { InvalidationKeysFromServer } from "./InvalidationKeys.ts"
 
 export interface ApiConfig {
   url: string
@@ -31,16 +35,22 @@ export const DefaultApiConfig = Config.all({
 })
 
 export type Req = S.Top & {
-  new(...args: any[]): any
+  readonly make: (...args: any[]) => any
   _tag: string
   fields: S.Struct.Fields
   success: S.Top
   error: S.Top
+  /** Optional final-value schema for stream requests. When set, the execute effect resolves with the last stream value decoded to this type. */
+  final?: S.Top
   config?: Record<string, any>
-  readonly "~decodingServices"?: unknown
+  readonly id: string
+  readonly moduleName: string
+  readonly type: "command" | "query"
+  readonly stream: boolean
+  readonly middleware?: unknown
 }
 
-class RequestName extends ServiceMap.Reference("RequestName", {
+class RequestName extends Context.Reference("RequestName", {
   defaultValue: () => ({ requestName: "Unspecified", moduleName: "Error" })
 }) {}
 
@@ -50,17 +60,17 @@ export const HttpClientLayer = (config: ApiConfig) =>
     Effect
       .gen(function*() {
         const baseClient = yield* HttpClient.HttpClient
-        const ctx = yield* RequestName
         const client = baseClient.pipe(
           HttpClient.mapRequest(HttpClientRequest.prependUrl(config.url + "/rpc")),
           HttpClient.mapRequest(
             HttpClientRequest.setHeaders(config.headers.pipe(Option.getOrElse(() => ({}))))
           ),
-          HttpClient.mapRequest((req) =>
-            flow(
-              HttpClientRequest.appendUrlParam("action", ctx.requestName),
-              HttpClientRequest.appendUrl("/" + ctx.moduleName)
-            )(req)
+          HttpClient.mapRequestEffect((req) =>
+            Effect.map(RequestName, (ctx) =>
+              flow(
+                HttpClientRequest.appendUrlParam("action", ctx.requestName),
+                HttpClientRequest.appendUrl("/" + ctx.moduleName)
+              )(req))
           )
         )
         return client
@@ -76,7 +86,7 @@ export const HttpClientFromConfigLayer = Layer.unwrap(
 
 export const RpcSerializationLayer = (config: ApiConfig) =>
   Layer.mergeAll(
-    RpcSerialization.layerJson,
+    RpcSerialization.layerNdjson,
     HttpClientLayer(config)
   )
 
@@ -84,14 +94,14 @@ type RpcHandlers<M extends RequestsAny> = {
   [K in keyof M]: Rpc.Rpc<M[K]["_tag"], M[K], M[K]["success"], M[K]["error"]>
 }
 
-const getFiltered = <M extends Requests>(resource: M) => {
+const getFiltered = <M extends RequestsAny>(resource: M) => {
   type Filtered = {
     [K in keyof M as M[K] extends Req ? K : never]: M[K] extends Req ? M[K] : never
   }
   // TODO: Record.filter
   const filtered = typedKeysOf(resource).reduce((acc, cur) => {
     if (
-      Predicate.isObject(resource[cur])
+      Predicate.isObjectKeyword(resource[cur])
       && (resource[cur].success)
     ) {
       acc[cur as keyof Filtered] = resource[cur] as any
@@ -102,179 +112,331 @@ const getFiltered = <M extends Requests>(resource: M) => {
   return filtered as unknown as Filtered
 }
 
-export const getMeta = <M extends Requests>(resource: M) => {
-  const meta = (resource as any).meta as { moduleName: string }
-  if (!meta) throw new Error("No meta defined in Resource!")
-  return meta as M["meta"]
+export const getMeta = <M extends RequestsAny>(
+  resource: M
+): { moduleName: ExtractModuleName<M>; middleware?: unknown } => {
+  const first = typedValuesOf(getFiltered(resource))[0]
+  if (first && "moduleName" in first) return { moduleName: first.moduleName, middleware: (first as any).middleware }
+  throw new Error("No moduleName on requests!")
 }
 
-export const makeRpcGroupFromRequestsAndModuleName = <M extends Requests, const ModuleName extends string>(
+export const makeRpcGroupFromRequestsAndModuleName = <M extends RequestsAny, const ModuleName extends string>(
   resource: M,
-  moduleName: ModuleName
+  moduleName: ModuleName,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  middleware?: any
 ) => {
   const filtered = getFiltered(resource)
   type newM = typeof filtered
-  const rpcs = RpcGroup
+  const baseRpcs = RpcGroup
     .make(
       ...typedValuesOf(filtered).map((_) => {
-        return Rpc.make((_ as any)._tag, { payload: _ as any, success: (_ as any).success, error: (_ as any).error })
+        const r = _ as any
+        const isStream = r.stream
+        const isCommand = r.type === "command"
+        return (isCommand
+          ? isStream
+            ? Invalidation.makeStreamRpc(r._tag, {
+              payload: r,
+              success: r.success,
+              error: r.error,
+              stream: true as const
+            })
+            : Invalidation.makeCommandRpc(r._tag, { payload: r, success: r.success, error: r.error })
+          : Rpc.make(r._tag, {
+            payload: r,
+            success: isStream ? r.success : Invalidation.QueryResponseWithMetaData(r.success),
+            error: r.error,
+            stream: isStream
+          })) as any
       })
     )
-    .prefix(`${moduleName}.`) as unknown as RpcGroup.RpcGroup<
-      Rpc.Prefixed<RpcHandlers<newM>[keyof newM], `${ModuleName}.`>
-    >
+    .prefix(`${moduleName}.`)
+  // Attach the middleware tag (schema-only on the client — no Live invoked)
+  // so its declared `error` joins the rpc failure union via
+  // `Rpc.exitSchema`'s `rpc.middlewares[*].error` walk. Required for stream
+  // rpcs whose top-level `errorSchema` is forced to `Never` by effect-rpc;
+  // without it, middleware-thrown errors fail client decode.
+  const rpcs = (middleware ? baseRpcs.middleware(middleware) : baseRpcs) as unknown as RpcGroup.RpcGroup<
+    Rpc.Prefixed<RpcHandlers<newM>[keyof newM], `${ModuleName}.`>
+  >
   return rpcs
 }
 
-export const makeRpcGroup = <
-  M extends Requests,
-  const ModuleName extends string
->(
-  resource: M & { meta: { moduleName: ModuleName } }
-) => makeRpcGroupFromRequestsAndModuleName(resource, resource.meta.moduleName)
-
-const makeRpcTag = <M extends Requests>(resource: M) => {
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const makeRpcTag = <M extends RequestsAny>(resource: M, middleware?: any) => {
   const meta = getMeta(resource)
-  const rpcs = makeRpcGroupFromRequestsAndModuleName(resource, meta.moduleName)
+  const rpcs = makeRpcGroupFromRequestsAndModuleName(resource, meta.moduleName, middleware)
 
   // Use Object.assign instead of class extension to avoid TS2509 with complex generic return types.
   // The first type arg is `any` because this is a dynamically created tag — its identity is the string key.
-  const TheClient = ServiceMap.Opaque<
+  const TheClient = Context.Opaque<
     any,
     RpcClient.RpcClient<RpcGroup.Rpcs<typeof rpcs>>
   >()(`RpcClient.${meta.moduleName}`)
   // Use Layer.effect directly (not TheClient.toLayer) so TypeScript properly excludes Scope
   const layer = Layer.effect(
     TheClient,
-    Effect.map(
-      RpcClient.make(rpcs, { spanPrefix: "RpcClient." + meta.moduleName }),
-      (cl) => (cl as any)[meta.moduleName]
-    )
+    RpcClient.make(rpcs)
   )
   return Object.assign(TheClient, { layer })
 }
 
 const makeApiClientFactory = Effect
   .gen(function*() {
-    const ctx = yield* Effect.services<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
-    const makeClientFor = <M extends Requests>(
+    const ctx = yield* Effect.context<RpcSerialization.RpcSerialization | HttpClient.HttpClient>()
+    const makeClientFor = Effect.fnUntraced(function*<M extends RequestsAny>(
       resource: M,
       requestLevelLayers = Layer.empty,
       options?: ClientForOptions
-    ) =>
-      Effect.gen(function*() {
-        const TheClient = makeRpcTag(resource)
-
-        const meta = getMeta(resource)
-
-        // TODO: somehow we need a protocol per REQUEST kind of it seems ...
-        // otherwise it locks up on the client, navigation remains empty...
-        const clientLayer = TheClient.layer.pipe(
-          // add ApiClientFactory for nested schemas
-          // eslint-disable-next-line @typescript-eslint/no-use-before-define
-          Layer.provide(Layer.succeed(ApiClientFactory, makeClientForCached as any)),
-          Layer.provide(
-            RpcClient
-              .layerProtocolHttp({
-                url: "" // why not here set meta.moduleName as root?
+    ) {
+      const meta = getMeta(resource)
+
+      const TheClient = makeRpcTag(resource, meta.middleware)
+
+      // TODO: somehow we need a protocol per REQUEST kind of it seems ...
+      // otherwise it locks up on the client, navigation remains empty...
+      const clientLayer = TheClient.layer.pipe(
+        // add ApiClientFactory for nested schemas
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        Layer.provide(Layer.succeed(ApiClientFactory, makeClientForCached as any)),
+        Layer.provide(
+          RpcClient
+            .layerProtocolHttp({ url: "" }) // why not here set meta.moduleName as root?
+            .pipe(
+              Layer.provideMerge(Layer.succeedContext(ctx))
+            )
+        )
+      )
+      const mr = ManagedRuntime.make(clientLayer)
+
+      const filtered = getFiltered(resource)
+
+      // Unwrap `CommandResponseWithMetaData` (success) and `CommandFailureWithMetaData`
+      // (handler-thrown failure): forward accumulated invalidation keys to
+      // `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.getDataDependencyRecorder
+            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) =>
+            Effect.gen(function*() {
+              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
+            })
+          ),
+          Effect.catch((result: any) =>
+            result?._tag === "CommandFailureWithMetaData"
+              ? Effect.gen(function*() {
+                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)
               })
-              .pipe(
-                Layer.provideMerge(Layer.succeedServices(ctx))
-              )
+              : Effect.fail(result)
           )
         )
-        const mr = ManagedRuntime.make(clientLayer)
 
-        const filtered = getFiltered(resource)
-        return {
-          mr,
-          client: (typedKeysOf(filtered)
-            .reduce((prev, cur) => {
-              const h = filtered[cur]!
+      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
+            })
+          )
+        )
 
-              const Request = h
+      return {
+        mr,
+        client: typedKeysOf(filtered)
+          .reduce((prev, cur) => {
+            const h = filtered[cur]!
+
+            const Request = h
+
+            const id = `${meta.moduleName}.${cur as string}`
+              .replaceAll(".js", "")
+
+            const requestMeta = {
+              Request,
+              id,
+              options,
+              disableQueryInvalidation: (h as { config?: { disableQueryInvalidation?: boolean } })
+                .config
+                ?.disableQueryInvalidation === true
+            }
+
+            const requestNameLayer = Layer.succeed(RequestName, {
+              requestName: cur as string,
+              moduleName: meta.moduleName
+            })
+
+            const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
+
+            const fields = Struct.omit(Request.fields, ["_tag"] as const)
+            const requestAttr = `${meta.moduleName}.${h._tag}`
+            const isCommand = h.type === "command"
+            const isStream = h.stream
+
+            const buildEffect = (input: any) =>
+              mr.contextEffect.pipe(
+                Effect.flatMap((svcs) => {
+                  const rpcEffect = TheClient
+                    .use((client) => (client as any)[requestAttr]!(Request.make(input)) as Effect.Effect<any, any>)
+                    .pipe(
+                      // local: true → isolate to this RPC call. `layers` is pure today
+                      // (RequestName + caller-supplied requestLevelLayers), but the
+                      // flag prevents a stateful caller-supplied layer from leaking
+                      // across RPC calls via the ambient fiber MemoMap.
+                      Effect.provide(layers, { local: true }),
+                      Effect.provide(svcs)
+                    )
+                  return isCommand ? unwrapCommand(rpcEffect) : isStream ? rpcEffect : unwrapQuery(rpcEffect)
+                }),
+                // Forwarding the server's dependency metadata needs a recorder in scope. A parent
+                // query/command (vue) provides one; a top-level call gets a fresh per-request one.
+                DataDependencies.ensureDataDependencyRecorder
+              )
 
-              const id = `${meta.moduleName}.${cur as string}`
-                .replaceAll(".js", "")
+            const buildStream = (input: any) => {
+              const stream = Stream.unwrap(
+                mr.contextEffect.pipe(
+                  Effect.flatMap((svcs) =>
+                    TheClient
+                      .useSync((client) => {
+                        const rpcStream = (client as any)[requestAttr]!(
+                          Request.make(input)
+                        ) as Stream.Stream<any, any, any>
+                        return rpcStream.pipe(
+                          // Collect server invalidation keys from the "done" chunk, then discard it.
+                          Stream.tap((item: any) =>
+                            item._tag === "done" || item._tag === "metadata"
+                              ? 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.getDataDependencyRecorder
+                                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"),
+                          Stream.map((item: any) => item.value),
+                          // V2: unwrap StreamFailureChunk — forward keys from failures too,
+                          // then re-fail with the original error so callers see the unmodified
+                          // error type.
+                          Stream.catch((err: any) =>
+                            err?._tag === "error" && err?.metadata
+                              ? Stream.fromEffect(
+                                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.getDataDependencyRecorder
+                                  yield* Effect.forEach(
+                                    metadata.dataDependencies.writes,
+                                    dependencyRecorder.write,
+                                    { discard: true }
+                                  )
+                                  return yield* Effect.fail(err.error)
+                                })
+                              )
+                              : Stream.fail(err)
+                          ),
+                          // local: true — see buildEffect above.
+                          Stream.provide(layers, { local: true }),
+                          Stream.provide(svcs)
+                        )
+                      })
+                      .pipe(Effect.provide(svcs))
+                  )
+                )
+              )
+              // Forwarding the server's dependency metadata needs a recorder in scope. A parent
+              // query/command (vue) provides one; a top-level stream call gets a fresh per-request one.
+              return Stream.unwrap(
+                Effect.map(
+                  DataDependencies.DataDependencyRecorder,
+                  (current) =>
+                    current === "root"
+                      ? Stream.provide(stream, DataDependencies.DataDependencyRecorder.layer)
+                      : stream
+                )
+              )
+            }
 
-              const requestMeta = {
-                Request,
-                id,
-                options
+            // @ts-expect-error doc
+            prev[cur] = Object.keys(fields).length === 0
+              ? {
+                handler: isStream ? constant(buildStream({})) : constant(buildEffect({})),
+                ...requestMeta
+              }
+              : {
+                handler: isStream
+                  ? (req: any) => buildStream(req)
+                  : (req: any) => buildEffect(req),
+                ...requestMeta
               }
 
-              const requestNameLayer = Layer.succeed(RequestName, {
-                requestName: cur as string,
-                moduleName: meta.moduleName
-              })
-
-              const layers = requestLevelLayers.pipe(Layer.provideMerge(requestNameLayer))
-
-              const fields = Struct.omit(Request.fields, ["_tag"] as const)
-              const requestAttr = h._tag
-              // @ts-expect-error doc
-              prev[cur] = Object.keys(fields).length === 0
-                ? {
-                  handler: mr.servicesEffect.pipe(
-                    Effect.flatMap((svcs) =>
-                      TheClient
-                        .use((client) => (client as any)[requestAttr]!(new Request()) as Effect.Effect<any, any, never>)
-                        .pipe(
-                          Effect.provide(layers),
-                          Effect.provide(svcs)
-                        )
-                    )
-                  ),
-                  ...requestMeta
-                }
-                : {
-                  handler: (req: any) =>
-                    mr.servicesEffect.pipe(
-                      Effect.flatMap((svcs) =>
-                        TheClient
-                          .use((client) =>
-                            (client as any)[requestAttr]!(new Request(req)) as Effect.Effect<any, any, never>
-                          )
-                          .pipe(
-                            Effect.provide(layers),
-                            Effect.provide(svcs)
-                          )
-                      )
-                    ),
-
-                  ...requestMeta
-                }
-
-              return prev
-            }, {} as Client<M, M["meta"]["moduleName"]>))
-        }
-      })
+            return prev
+          }, {} as Client<M, ExtractModuleName<M>>)
+      }
+    })
 
     const register: ManagedRuntime.ManagedRuntime<any, any>[] = []
     yield* Effect.addFinalizer(() => Effect.forEach(register, (mr) => mr.disposeEffect))
 
     const cacheL = new Map<any, Map<any, Client<any, any>>>()
 
-    function makeClientForCached(requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) {
+    function makeClientForCached(requestLevelLayers: Layer.Layer<never>, options?: ClientForOptions) {
       let cache = cacheL.get(requestLevelLayers)
       if (!cache) {
         cache = new Map<any, Client<any, any>>()
         cacheL.set(requestLevelLayers, cache)
       }
 
-      return <M extends Requests>(
-        models: M
-      ): Effect.Effect<Client<M, M["meta"]["moduleName"]>> =>
-        Effect.gen(function*() {
-          const found = cache.get(models)
-          if (found) {
-            return found
-          }
-          const m = yield* makeClientFor(models, requestLevelLayers, options)
-          cache.set(models, m.client)
-          register.push(m.mr)
-          return m.client
-        })
+      return Effect.fnUntraced(function*<M extends RequestsAny>(models: M) {
+        const found = cache.get(models) as Client<M, ExtractModuleName<M>> | undefined
+        if (found) {
+          return found
+        }
+        const m = yield* makeClientFor(models, requestLevelLayers, options)
+        cache.set(models, m.client)
+        register.push(m.mr)
+        return m.client
+      })
     }
 
     return makeClientForCached
@@ -284,7 +446,7 @@ const makeApiClientFactory = Effect
  * Used to create clients for resource modules.
  */
 export class ApiClientFactory
-  extends ServiceMap.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
+  extends Context.Opaque<ApiClientFactory, Effect.Success<typeof makeApiClientFactory>>()("ApiClientFactory")
 {
   static readonly layer = (config: ApiConfig) =>
     ApiClientFactory.toLayer(makeApiClientFactory).pipe(Layer.provide(RpcSerializationLayer(config)))
@@ -296,8 +458,8 @@ export class ApiClientFactory
   )
 
   static readonly makeFor =
-    (requestLevelLayers: Layer.Layer<never, never, never>, options?: ClientForOptions) =>
-    <M extends Requests>(
+    (requestLevelLayers: Layer.Layer<never>, options?: ClientForOptions) =>
+    <M extends RequestsAny>(
       resource: M
     ) =>
       ApiClientFactory.use((apiClientFactory) => {