effect-app 4.0.0-beta.20 → 4.0.0-beta.201

package/src/client/makeClient.ts

@@ -1,4 +1,6 @@
-import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
+import { SchemaTransformation } from "effect"
+import type * as Exit from "effect/Exit"
+import { type GetContextConfig, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
 
@@ -8,103 +10,571 @@ const merge = (a: any, b: Array<any>) =>
 /**
  * Whatever the input, we will only decode or encode to void
  */
-const ForceVoid: S.Codec<void> = S.Void as any
+export const ForceVoid = S
+  .declare((_: unknown): _ is unknown => true)
+  .pipe(
+    S.decodeTo(S.Any, SchemaTransformation.transform<unknown, unknown>({ decode: () => void 0, encode: () => void 0 }))
+  )
 
 type SchemaOrFields<T> = T extends S.Top ? T : T extends S.Struct.Fields ? S.Struct<T> : S.Void
 
-type TaggedRequestResult<
+type TaggedRequestSchema<Tag extends string, Payload extends S.Struct.Fields> = S.Struct<
+  { readonly _tag: S.tag<Tag> } & Payload
+>
+
+type QueryOnlyRequests<Resource> = {
+  [K in keyof Resource as Resource[K] extends { readonly type: "query" } ? K : never]: Resource[K]
+}
+
+type QueryOnlyResources<Resources> = {
+  [K in keyof Resources]: QueryOnlyRequests<Resources[K]>
+}
+
+type InputFromPayload<Payload extends S.Struct.Fields> = keyof Payload extends never ? void
+  : S.Schema.Type<S.Struct<Payload>>
+
+type OutputFromSuccess<Success extends S.Top> = Success extends typeof ForceVoid ? void : S.Schema.Type<Success>
+
+type InvalidationResources = Record<string, Record<string, unknown>>
+
+export type InvalidateQueryInstruction = {
+  readonly filters?: Record<string, unknown>
+  readonly options?: Record<string, unknown>
+}
+
+export type InvalidationCallback<Resources, Input = unknown, Success = unknown, Failure = unknown> = (
+  queryKey: readonly string[],
+  resources: QueryOnlyResources<Resources>,
+  ...args: [Input] extends [void] ? [exit: Exit.Exit<Success, Failure>]
+    : [input: Input, exit: Exit.Exit<Success, Failure>]
+) => ReadonlyArray<InvalidateQueryInstruction>
+
+export type InvalidationConfig<Resources, Input = unknown, Success = unknown, Failure = unknown> = {
+  readonly invalidatesQueries: InvalidationCallback<Resources, Input, Success, Failure>
+  readonly invalidationResources?: Resources
+}
+
+type InvalidationConfigForCommand<
+  Resources,
+  Payload extends S.Struct.Fields,
+  Success extends S.Top,
+  Error extends S.Top
+> = InvalidationConfig<
+  Resources,
+  InputFromPayload<Payload>,
+  OutputFromSuccess<Success>,
+  S.Schema.Type<Error>
+>
+
+export const configureInvalidation = <Resources>() =>
+<Input, Success, Failure>(
+  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
+): InvalidationConfig<Resources, Input, Success, Failure> => ({ invalidatesQueries })
+
+export const configureInvalidationCallback = <Resources>() =>
+<Input, Success, Failure>(
+  invalidatesQueries: InvalidationCallback<Resources, NoInfer<Input>, NoInfer<Success>, NoInfer<Failure>>
+): InvalidationCallback<Resources, Input, Success, Failure> => invalidatesQueries
+
+export const configureInvalidationResources = <Resources>() =>
+  ({}) as Pick<InvalidationConfig<Resources>, "invalidationResources">
+
+type TaggedRequestForResult<
+  Self,
   Tag extends string,
   Payload extends S.Struct.Fields,
   Success extends S.Top,
   Error extends S.Top,
-  Config = Record<string, never>
+  Config,
+  ModuleName extends string,
+  Type extends "command" | "query",
+  Stream extends boolean,
+  Resources = never,
+  Final extends S.Top = never
 > =
-  & S.TaggedStruct<Tag, Payload>
+  & S.Opaque<Self, S.ExtendedSchemaNoEncoded, TaggedRequestSchema<Tag, Payload>, {}>
   & {
-    new(...args: any[]): any
+    readonly fields: TaggedRequestSchema<Tag, Payload>["fields"]
     readonly _tag: Tag
-    readonly fields: { readonly _tag: S.tag<Tag> } & Payload
     readonly success: Success
     readonly error: Error
     readonly config: Config
-    readonly "~decodingServices": S.Codec.DecodingServices<Success> | S.Codec.DecodingServices<Error>
+    readonly id: `${ModuleName}.${Tag}`
+    readonly moduleName: ModuleName
+    readonly type: Type
+    readonly stream: Stream
+    readonly "~invalidationResources"?: Resources
   }
+  & ([Final] extends [never] ? {} : { readonly final: Final })
 
 export const makeRpcClient = <
   RequestContextMap extends RequestContextMapTagAny,
   GeneralErrors extends S.Top = never
 >(rcs: RequestContextMap, generalErrors?: GeneralErrors) => {
-  // Long way around ServiceMap/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
+  // Long way around Context/C extends etc to support actual jsdoc from passed in RequestConfig etc... (??)
   type ServiceMap = {
     success: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
     error: S.Top | S.Struct.Fields // SchemaOrFields will make a Schema type out of Struct.Fields
+    final?: S.Top | S.Struct.Fields // optional final-value schema for stream requests
+    stream?: boolean // request metadata — stripped from stored config
   }
 
   type RequestConfig = GetContextConfig<RequestContextMap["config"]>
 
+  // Errors raised by RPC middleware (e.g. `NotLoggedInError` from auth) used to
+  // be merged into `resource.error` here so they would surface in the wire
+  // failure schema. That merging is gone — the canonical source for middleware
+  // errors is now the middleware tag attached to the rpc on both server and
+  // client (see `ApiClientFactory.makeFor({ middleware })`). `Rpc.exitSchema`
+  // unions in `rpc.middlewares[*].error` automatically.
   type MergeError<E> = [GeneralErrors] extends [never] ? SchemaOrFields<E> : S.Union<[SchemaOrFields<E>, GeneralErrors]>
   type ErrorResult<C> = C extends { error: infer E } ? MergeError<E>
-    : [GeneralErrors] extends [never] ? GetEffectError<RequestContextMap["config"], C>
-    : MergeError<GetEffectError<RequestContextMap["config"], C>>
-
-  function TaggedRequest<_Self>(): {
-    <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "success">>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, SchemaOrFields<C["success"]>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "error">>(
-      tag: Tag,
-      fields: Payload,
-      config: RequestConfig & C
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields, C extends Record<string, any>>(
-      tag: Tag,
-      fields: Payload,
-      config: C & RequestConfig
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<C>, Omit<C, "success" | "error">>
-    <Tag extends string, Payload extends S.Struct.Fields>(
-      tag: Tag,
-      fields: Payload
-    ): TaggedRequestResult<Tag, Payload, S.Codec<void>, ErrorResult<{}>, Record<string, never>>
-  } {
-    // TODO: filter errors based on config + take care of inversion
-    const errorSchemas = Object.values(rcs.config).map((_) => _.error)
-    return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
-      tag: Tag,
-      fields: Fields,
-      config?: C
-    ) => {
-      // TODO: S.TaggedRequest removed in v4 — needs rework to use Rpc.make or Request.TaggedClass
-      // For now, creating a simple tagged struct class with success/failure properties
-      const failureSchema = merge(
-        config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
-        [...errorSchemas, generalErrors].filter(Boolean)
-      )
-      const successSchema = config?.success
-        ? S.isSchema(config.success)
-          ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
-          : S.Struct(config.success)
-        : ForceVoid
-
-      const RequestClass = S.TaggedClass<any>()(tag, fields)
-      Object.assign(RequestClass, {
-        _tag: tag,
-        success: successSchema,
-        error: failureSchema,
-        config
-      })
-
-      return RequestClass
-    }) as any
+    : [GeneralErrors] extends [never] ? typeof S.Never
+    : GeneralErrors
+
+  // Suppress unused-warning for the rcm parameter — it's still load-bearing for
+  // the type-side `RequestConfig` definition above.
+  void rcs
+
+  function makeRequestClass<Tag extends string, Fields extends S.Struct.Fields, C extends Partial<ServiceMap>>(
+    tag: Tag,
+    fields: Fields,
+    config?: C
+  ) {
+    const failureSchema = merge(
+      config?.error ? S.isSchema(config.error) ? config.error : S.Struct(config.error) : undefined,
+      [generalErrors].filter(Boolean)
+    )
+    const successSchema = config?.success
+      ? S.isSchema(config.success)
+        ? AST.isVoid(config.success.ast) ? ForceVoid : config.success
+        : S.Struct(config.success)
+      : ForceVoid
+
+    const finalConfig = (config as any)?.final
+    const finalSchema = finalConfig && S.isSchema(finalConfig) ? finalConfig : undefined
+
+    // Strip stream from the stored config — it's request metadata, not handler config
+    const { stream: _stream, ...restConfig } = config ?? ({} as C)
+
+    const RequestClass = S.Opaque()(S.TaggedStruct(tag, fields))
+    Object.assign(RequestClass, {
+      _tag: tag,
+      success: successSchema,
+      error: failureSchema,
+      ...(finalSchema !== undefined ? { final: finalSchema } : {}),
+      config: restConfig
+    })
+
+    return RequestClass
+  }
+
+  function makeTaggedRequestWithMeta<
+    ModuleName extends string,
+    Type extends "command" | "query"
+  >(
+    moduleName: ModuleName,
+    type: Type
+  ) {
+    function TaggedRequestWithMeta<Self, Resources extends InvalidationResources = never>(): {
+      // ─── stream: true overloads (must come before non-stream so TypeScript picks them) ───────────
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true; success: Success; error: Error; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success; error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success; error: Error }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> & { error?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & { error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true; success: Success; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & { success: Success }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      // ─── stream: true without `success` overloads ────────────────────────────────────────────────
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & { success?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true; error: Error },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C & { error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C & { error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & { error: Error }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              typeof ForceVoid,
+              ErrorResult<C & { error: Error }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never; error?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & { success?: never; error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { stream: true },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        true,
+        Resources
+      >
+      // ─── non-stream overloads ────────────────────────────────────────────────────────────────────
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> = RequestConfig & Record<string, any>
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success; error: Error; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success; error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success; error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success; error: Error }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        false,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Final extends S.Top | S.Struct.Fields = never,
+        C extends RequestConfig & Record<string, any> & { error?: never } =
+          & RequestConfig
+          & Record<string, any>
+          & {
+            error?: never
+          }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success; final?: Final },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          OutputFromSuccess<SchemaOrFields<Success>>,
+          S.Schema.Type<ErrorResult<C & { success: Success }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<Success>,
+        ErrorResult<C & { success: Success }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            success: Success
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              SchemaOrFields<Success>,
+              ErrorResult<C & { success: Success }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        false,
+        Resources,
+        [Final] extends [never] ? never : SchemaOrFields<Final>
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { error: Error },
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C & { error: Error }>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C & { error: Error }>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & {
+            error: Error
+          }
+          & Partial<
+            InvalidationConfigForCommand<
+              Resources,
+              Payload,
+              typeof ForceVoid,
+              ErrorResult<C & { error: Error }>
+            >
+          >,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        false,
+        Resources
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { success?: never; error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config: Omit<C, "invalidatesQueries">,
+        invalidatesQueries?: InvalidationCallback<
+          Resources,
+          InputFromPayload<Payload>,
+          void,
+          S.Schema.Type<ErrorResult<C>>
+        >
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C>,
+        Omit<
+          & Omit<C, "invalidatesQueries">
+          & Partial<InvalidationConfigForCommand<Resources, Payload, typeof ForceVoid, ErrorResult<C>>>,
+          "success" | "error" | "stream"
+        >,
+        ModuleName,
+        Type,
+        false,
+        Resources
+      >
+      <Tag extends string, Payload extends S.Struct.Fields>(
+        tag: Tag,
+        fields: Payload
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<{}>,
+        Record<string, never>,
+        ModuleName,
+        Type,
+        false
+      >
+    } {
+      return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
+        tag: Tag,
+        fields: Fields,
+        config?: C,
+        invalidatesQueries?: InvalidationCallback<Resources>
+      ) => {
+        const isStream = (config as any)?.stream === true
+        const requestConfig = invalidatesQueries === undefined ? config : { ...config, invalidatesQueries }
+        const cls = makeRequestClass(tag, fields, requestConfig)
+        Object.assign(cls, { id: `${moduleName}.${tag}`, moduleName, type, stream: isStream })
+        return cls
+      }) as any
+    }
+    return Object.assign(TaggedRequestWithMeta, { moduleName, type } as const)
+  }
+
+  function TaggedRequestFor<ModuleName extends string>(moduleName: ModuleName) {
+    const Query = makeTaggedRequestWithMeta(moduleName, "query")
+    const Command = makeTaggedRequestWithMeta(moduleName, "command")
+
+    return {
+      moduleName,
+      /**
+       * Create query request classes for this module.
+       * Queries read state and should not mutate server state.
+       * Pass `stream: true` in the config to produce a Stream of `success` values (QueryStream behaviour).
+       */
+      Query,
+      /**
+       * Create command request classes for this module.
+       * Commands mutate state and should avoid returning complex read models.
+       * Pass `stream: true` in the config to produce a Stream of `success` values (CommandStream behaviour).
+       */
+      Command
+    } as const
   }
 
   return {
-    TaggedRequest
+    TaggedRequestFor
   }
 }

package/src/client.ts

@@ -2,5 +2,6 @@
 export * from "./client/apiClientFactory.js"
 export * from "./client/clientFor.js"
 export * from "./client/errors.js"
+export * from "./client/InvalidationKeys.js"
 export * from "./client/makeClient.js"
 // codegen:end

package/src/http/Request.ts

@@ -1,3 +1,4 @@
+import { Option } from "effect"
 import type { HttpClientResponse } from "effect/unstable/http/HttpClientResponse"
 import * as Effect from "../Effect.js"
 import { HttpClient, HttpClientError, HttpClientRequest, HttpHeaders } from "./internal/lib.js"
@@ -24,16 +25,18 @@ export const demandJson = (client: HttpClient.HttpClient) =>
     .mapRequest(client, (_) => HttpClientRequest.acceptJson(_))
     .pipe(HttpClient.transform((r, request) =>
       Effect.tap(r, (response) =>
-        HttpHeaders
-            .get(response.headers, "Content-Type")
-            ?.startsWith("application/json")
+        Option
+            .exists(
+              HttpHeaders.get(response.headers, "Content-Type"),
+              (_) => _.startsWith("application/json")
+            )
           ? Effect.void
           : Effect.fail(
             new HttpClientError.DecodeError({
               request,
               response,
               description: "not json response: "
-                + HttpHeaders.get(response.headers, "Content-Type")
+                + Option.getOrElse(HttpHeaders.get(response.headers, "Content-Type"), () => "<missing>")
             })
           ))
     ))