effect-app 4.0.0-beta.17 → 4.0.0-beta.170

package/src/client/makeClient.ts

@@ -1,3 +1,5 @@
+import { SchemaTransformation } from "effect"
+import type * as Exit from "effect/Exit"
 import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
@@ -8,33 +10,105 @@ 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",
+  Resources = never
 > =
-  & S.TaggedStruct<Tag, Payload>
+  & S.EnhancedClass<Self, TaggedRequestSchema<Tag, Payload>, {}>
   & {
-    new(...args: any[]): any
     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 "~encodingServices": S.Codec.EncodingServices<Success> | S.Codec.EncodingServices<Error>
+    readonly id: `${ModuleName}.${Tag}`
+    readonly moduleName: ModuleName
+    readonly type: Type
+    readonly "~invalidationResources"?: Resources
   }
 
 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
@@ -47,64 +121,246 @@ export const makeRpcClient = <
     : [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<never>, 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
+  // TODO: filter errors based on config + take care of inversion
+  const errorSchemas = Object.values(rcs.config).map((_) => _.error)
+
+  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,
+      [...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
+  }
+
+  function makeTaggedRequestWithMeta<ModuleName extends string, Type extends "command" | "query">(
+    moduleName: ModuleName,
+    type: Type
+  ) {
+    function TaggedRequestWithMeta<Self, Resources extends InvalidationResources = never>(): {
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        Error extends S.Top | S.Struct.Fields,
+        C extends RequestConfig & Record<string, any>
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success; error: Error },
+        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"
+        >,
+        ModuleName,
+        Type,
+        Resources
+      >
+      <
+        Tag extends string,
+        Payload extends S.Struct.Fields,
+        Success extends S.Top | S.Struct.Fields,
+        C extends RequestConfig & Record<string, any> & { error?: never }
+      >(
+        tag: Tag,
+        fields: Payload,
+        config:
+          & Omit<C, "invalidatesQueries">
+          & { success: Success },
+        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"
+        >,
+        ModuleName,
+        Type,
+        Resources
+      >
+      <
+        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"
+        >,
+        ModuleName,
+        Type,
+        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"
+        >,
+        ModuleName,
+        Type,
+        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
+      >
+    } {
+      return (<Tag extends string, Fields extends S.Struct.Fields, C extends ServiceMap>(
+        tag: Tag,
+        fields: Fields,
+        config?: C,
+        invalidatesQueries?: InvalidationCallback<Resources, unknown, unknown, unknown>
+      ) => {
+        const requestConfig = invalidatesQueries === undefined ? config : { ...config, invalidatesQueries }
+        const cls = makeRequestClass(tag, fields, requestConfig)
+        Object.assign(cls, { id: `${moduleName}.${tag}`, moduleName, type })
+        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.
+       */
+      Query,
+      /**
+       * Create command request classes for this module.
+       * Commands mutate state and should avoid returning complex read models.
+       */
+      Command
+    } as const
   }
 
   return {
-    TaggedRequest
+    TaggedRequestFor
   }
 }

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>")
             })
           ))
     ))

package/src/ids.ts

@@ -1,3 +1,4 @@
+import { Effect } from "effect"
 import { brandedStringId, type Codec, NonEmptyString255, StringId, type StringIdBrand, withDefaultMake } from "effect-app/Schema"
 import type { B } from "effect-app/Schema/schema"
 import type { Simplify } from "effect/Types"
@@ -17,7 +18,7 @@ export const RequestId = extendM(
     const make = StringId.make as () => NonEmptyString255
     return ({
       make,
-      withDefault: s.pipe(S.withDefaultConstructor(make))
+      withDefault: S.withConstructorDefault(Effect.sync(make))(s as typeof s & S.WithoutConstructorDefault)
     })
   }
 )

package/src/index.ts

@@ -1,24 +1,18 @@
+// eslint-disable-next-line import/no-unassigned-import
 import "./builtin.js"
 
-import * as ServiceMap from "./ServiceMap.js"
-
 export * as Fnc from "./Function.js"
 export * as Utils from "./utils.js"
 
 export * as Array from "./Array.js"
+export * as Config from "./Config.js"
+export * as ConfigProvider from "./ConfigProvider.js"
+export * as Context from "./Context.js"
 export * as Effect from "./Effect.js"
 export * as Layer from "./Layer.js"
 export * as NonEmptySet from "./NonEmptySet.js"
-export * as ServiceMap from "./ServiceMap.js"
 export * as Set from "./Set.js"
 
-export {
-  /**
-   * @deprecated use ServiceMap directly instead
-   */
-  ServiceMap as Context
-}
-
 export { type NonEmptyArray, type NonEmptyReadonlyArray } from "./Array.js"
 
 export * from "effect"
@@ -26,5 +20,6 @@ export * from "effect"
 export type * as Types from "./Types.js"
 
 export * as SecretURL from "./Config/SecretURL.js"
+export * as RpcX from "./rpc.js"
 export * as S from "./Schema.js"
 export { copy } from "./utils.js"

package/src/middleware.ts

@@ -1,20 +1,18 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { ServiceMap } from "effect-app"
-import { RpcX } from "./rpc.js"
+import { Context } from "effect-app"
+import { RpcMiddleware } from "./rpc.js"
 
-export class DevMode extends ServiceMap.Reference("DevMode", { defaultValue: () => false }) {}
+export class DevMode extends Context.Reference("DevMode", { defaultValue: () => false }) {}
 
-export class RequestCacheMiddleware
-  extends RpcX.RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware")
-{}
+export class RequestCacheMiddleware extends RpcMiddleware.Tag<RequestCacheMiddleware>()("RequestCacheMiddleware") {}
 
 export class ConfigureInterruptibilityMiddleware
-  extends RpcX.RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware")
+  extends RpcMiddleware.Tag<ConfigureInterruptibilityMiddleware>()("ConfigureInterruptibilityMiddleware")
 {}
 
-export class LoggerMiddleware extends RpcX.RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware") {}
+export class LoggerMiddleware extends RpcMiddleware.Tag<LoggerMiddleware>()("LoggerMiddleware") {}
 
-export class DevModeMiddleware extends RpcX.RpcMiddleware.Tag<DevModeMiddleware>()("DevModeMiddleware") {}
+export class DevModeMiddleware extends RpcMiddleware.Tag<DevModeMiddleware>()("DevModeMiddleware") {}
 
 export const DefaultGenericMiddlewares = [
   RequestCacheMiddleware,