effect-app 4.0.0-beta.15 → 4.0.0-beta.151

package/src/client/makeClient.ts

@@ -1,3 +1,4 @@
+import { SchemaTransformation } from "effect"
 import { type GetContextConfig, type GetEffectError, type RequestContextMapTagAny } from "../rpc/RpcContextMap.js"
 import * as S from "../Schema.js"
 import { AST } from "../Schema.js"
@@ -8,33 +9,46 @@ 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 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"
 > =
-  & 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
   }
 
 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 +61,143 @@ 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 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>(): {
+      <Tag extends string, Payload extends S.Struct.Fields, C extends ServiceMap>(
+        tag: Tag,
+        fields: Payload,
+        config: RequestConfig & C
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<C["success"]>,
+        ErrorResult<C>,
+        Omit<C, "success" | "error">,
+        ModuleName,
+        Type
+      >
+      <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "success">>(
+        tag: Tag,
+        fields: Payload,
+        config: RequestConfig & C
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        SchemaOrFields<C["success"]>,
+        ErrorResult<C>,
+        Omit<C, "success" | "error">,
+        ModuleName,
+        Type
+      >
+      <Tag extends string, Payload extends S.Struct.Fields, C extends Pick<ServiceMap, "error">>(
+        tag: Tag,
+        fields: Payload,
+        config: RequestConfig & C
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C>,
+        Omit<C, "success" | "error">,
+        ModuleName,
+        Type
+      >
+      <Tag extends string, Payload extends S.Struct.Fields, C extends Record<string, any>>(
+        tag: Tag,
+        fields: Payload,
+        config: C & RequestConfig
+      ): TaggedRequestForResult<
+        Self,
+        Tag,
+        Payload,
+        typeof ForceVoid,
+        ErrorResult<C>,
+        Omit<C, "success" | "error">,
+        ModuleName,
+        Type
+      >
+      <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
+      ) => {
+        const cls = makeRequestClass(tag, fields, config)
+        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,

package/src/rpc/MiddlewareMaker.ts

@@ -1,11 +1,10 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Effect, Layer, type Schema, Schema as S, type Scope, ServiceMap } from "effect"
+import { Effect, Layer, type Schema, Schema as S, type Scope } from "effect"
 import { type NonEmptyArray, type NonEmptyReadonlyArray } from "effect/Array"
 import { type Simplify } from "effect/Types"
 import { Rpc, type RpcGroup, type RpcSchema } from "effect/unstable/rpc"
 import { type HandlersFrom } from "effect/unstable/rpc/RpcGroup"
-import { type RequestId } from "effect/unstable/rpc/RpcMessage"
-import { type HttpHeaders } from "../http.js"
+import * as Context from "../Context.js"
 import { PreludeLogger } from "../logger.js"
 import { type TypeTestId } from "../TypeTest.js"
 import { typedValuesOf } from "../utils.js"
@@ -61,13 +60,13 @@ export interface MiddlewareMaker<
     }
   >
 {
-  readonly layer: Layer.Layer<Self, never, ServiceMap.Service.Identifier<MiddlewareProviders[number]>>
+  readonly layer: Layer.Layer<Self, never, Context.Service.Identifier<MiddlewareProviders[number]>>
   readonly requestContext: RequestContextTag<RequestContextMap>
   readonly requestContextMap: RequestContextMap
 }
 
 export interface RequestContextTag<RequestContextMap extends Record<string, RpcContextMap.Any>>
-  extends ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>
+  extends Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>
 {}
 
 export namespace MiddlewareMaker {
@@ -258,10 +257,10 @@ export type MiddlewaresBuilder<
     : { new(_: never): {} }
     : { new(_: never): {} })
 
-const middlewareMaker = <
+const middlewareMaker = Effect.fnUntraced(function*<
   MiddlewareProviders extends ReadonlyArray<MiddlewareMaker.Any>
->(middlewares: MiddlewareProviders): Effect.Effect<
-  RpcMiddlewareV4<
+>(middlewares: MiddlewareProviders) {
+  type Middleware = RpcMiddlewareV4<
     MiddlewareMaker.ManyProvided<MiddlewareProviders>,
     MiddlewareMaker.ManyErrors<MiddlewareProviders>,
     Exclude<
@@ -270,42 +269,32 @@ const middlewareMaker = <
     > extends never ? never
       : Exclude<MiddlewareMaker.ManyRequired<MiddlewareProviders>, MiddlewareMaker.ManyProvided<MiddlewareProviders>>
   >
-> => {
+  type Next = Parameters<Middleware>[0]
+  type Options = Parameters<Middleware>[1]
+
   // we want to run them in reverse order because latter middlewares will provide context to former ones
-  middlewares = middlewares.toReversed() as any
-
-  return Effect.gen(function*() {
-    const context = yield* Effect.services()
-
-    // returns a Effect/RpcMiddlewareV4 with Scope.Scope in requirements
-    // v4: wrap middleware takes (effect, options) as two params instead of a single options bag
-    return (
-      next: Effect.Effect<any, any, any>,
-      options: {
-        readonly clientId: number
-        readonly requestId: RequestId
-        readonly rpc: Rpc.AnyWithProps
-        readonly payload: unknown
-        readonly headers: HttpHeaders.Headers
-      }
-    ) => {
-      // we start with the actual handler
-      let handler = next
-
-      // inspired from Effect/RpcMiddleware
-      for (const tag of middlewares) {
-        // use the tag to get the middleware from context
-        const middleware = ServiceMap.getUnsafe(context, tag)
-
-        // wrap the current handler, allowing the middleware to run before and after it
-        handler = PreludeLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
-          Effect.andThen(middleware(handler, options))
-        ) as any
-      }
-      return handler
+  const reversed = middlewares.toReversed()
+  const context = yield* Effect.context()
+
+  // returns a Effect/RpcMiddlewareV4 with Scope.Scope in requirements
+  // v4: wrap middleware takes (effect, options) as two params instead of a single options bag
+  return (next: Next, options: Options) => {
+    // we start with the actual handler
+    let handler = next
+
+    // inspired from Effect/RpcMiddleware
+    for (const tag of reversed) {
+      // use the tag to get the middleware from context
+      const middleware = Context.getUnsafe(context, tag)
+
+      // wrap the current handler, allowing the middleware to run before and after it
+      handler = PreludeLogger.logDebug("Applying middleware wrap " + tag.key).pipe(
+        Effect.andThen(middleware(handler, options))
+      ) as any
     }
-  }) as any
-}
+    return handler
+  }
+})
 
 const makeMiddlewareBasic = <Self>() =>
 // by setting RequestContextMap beforehand, execute contextual typing does not fuck up itself to anys
@@ -321,7 +310,7 @@ const makeMiddlewareBasic = <Self>() =>
   // reverse middlewares and wrap one after the other
   const middleware = middlewareMaker(make)
 
-  const failures = make.map((_) => _.error).filter(Boolean)
+  const failures = make.flatMap((_) => _.error ? [_.error] : [])
   const provides = make.flatMap((_) => !_.provides ? [] : Array.isArray(_.provides) ? _.provides : [_.provides])
   const requires = make
     .flatMap((_) => !_.requires ? [] : Array.isArray(_.requires) ? _.requires : [_.requires])
@@ -367,7 +356,7 @@ const makeMiddlewareBasic = <Self>() =>
   return Object.assign(MiddlewareMaker, {
     layer,
     // tag to be used to retrieve the RequestContextConfig from Rpc annotations
-    requestContext: ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
+    requestContext: Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap>>(
       "RequestContextConfig"
     ),
     requestContextMap: rcm
@@ -379,8 +368,8 @@ export const Tag = <Self>() =>
   const Id extends string,
   RequestContextMap extends RequestContextMapTagAny
 >(id: Id, rcm: RequestContextMap): MiddlewaresBuilder<Self, Id, RequestContextMap["config"]> => {
-  let allMiddleware: MiddlewareMaker.Any[] = []
-  const requestContext = ServiceMap.Service<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
+  const allMiddleware: MiddlewareMaker.Any[] = []
+  const requestContext = Context.Service<"RequestContextConfig", GetContextConfig<RequestContextMap["config"]>>(
     "RequestContextConfig"
   )
   const it = {
@@ -437,7 +426,7 @@ export const Tag = <Self>() =>
     middleware: (...middlewares: any[]) => {
       for (const mw of middlewares) {
         // recall that we run middlewares in reverse order
-        allMiddleware = [mw, ...allMiddleware]
+        allMiddleware.unshift(mw)
       }
       return allMiddleware.filter((m) => !!m.dynamic).length !== Object.keys(rcm.config).length
         // for sure, until all the dynamic middlewares are provided it's non sensical to call makeMiddlewareBasic

package/src/rpc/RpcContextMap.ts

@@ -2,14 +2,15 @@
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
-import { type Schema as S, ServiceMap } from "effect"
+import { type Schema as S } from "effect"
 import { type AnyWithProps } from "effect/unstable/rpc/Rpc"
+import * as Context from "../Context.js"
 import { type RpcDynamic } from "./RpcMiddleware.js"
 
 type Values<T extends Record<any, any>> = T[keyof T]
 
 /**
- * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect ServiceMap.
+ * Middleware is inactivate by default, the Key is optional in route context, and the service is optionally provided as Effect Context.
  * Unless explicitly configured as `true`.
  */
 export type RpcContextMap<Service, E> = {
@@ -22,7 +23,7 @@ export type RpcContextMap<Service, E> = {
 
 export declare namespace RpcContextMap {
   /**
-   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect ServiceMap.
+   * Middleware is active by default, and provides the Service at Key in route context, and the Service is provided as Effect Context.
    * Unless explicitly omitted.
    */
   export type Inverted<Service, E> = {
@@ -97,7 +98,7 @@ export type GetEffectError<RequestContextMap extends Record<string, RpcContextMa
   }
 >
 
-const tag = ServiceMap.Service("RequestContextConfig")
+const tag = Context.Service("RequestContextConfig")
 
 export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(config: Config) => {
   const cls = class {
@@ -109,7 +110,7 @@ export const makeMap = <const Config extends Record<string, RpcContextMap.Any>>(
   return Object.assign(cls, {
     config, /** Retrieves RequestContextConfig out of the Rpc annotations */
     getConfig: (rpc: AnyWithProps): GetContextConfig<Config> => {
-      return ServiceMap.getOrElse(rpc.annotations, tag as any, () => ({}))
+      return Context.getOrElse(rpc.annotations, tag as any, () => ({}))
     },
     /** Adapter used when setting the dynamic prop on a middleware implementation */
     get: <

package/src/rpc/RpcMiddleware.ts

@@ -1,10 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { type Effect, type Schema, type Schema as S, type Scope, type ServiceMap, type Stream } from "effect"
+import { type Effect, type Schema, type Schema as S, type Scope, type Stream } from "effect"
 import { type NonEmptyReadonlyArray } from "effect/Array"
 import { type Rpc, RpcMiddleware } from "effect/unstable/rpc"
 import { type TypeId } from "effect/unstable/rpc/RpcMiddleware"
+import type * as Context from "../Context.js"
 import { type GetEffectContext, type RpcContextMap } from "./RpcContextMap.js"
 
 export type RpcMiddlewareV4<Provides, E, Requires> = RpcMiddleware.RpcMiddleware<Provides, E, Requires>
@@ -102,8 +103,8 @@ export declare namespace TagClass {
       requires?: any
       provides?: any
     }
-  > extends ServiceMap.Service<Self, Service> {
-    new(_: never): ServiceMap.ServiceClass.Shape<Name, Service>
+  > extends Context.Service<Self, Service> {
+    new(_: never): Context.ServiceClass.Shape<Name, Service>
     readonly [TypeId]: TypeId
     readonly optional: Optional<Options>
     readonly error: FailureSchema<Options>
@@ -226,7 +227,7 @@ export type ExtractProvides<R extends Rpc.Any, Tag extends string> = R extends
   Rpc.Rpc<Tag, infer _Payload, infer _Success, infer _Error, infer _Middleware, infer _Requires> ? _Middleware extends {
     readonly provides: infer _P
   } ? [_P] extends [never] ? never
-    : _P /*_P extends ServiceMap.Service<infer _I, infer _S> ? _I
+    : _P /*_P extends Context.Service<infer _I, infer _S> ? _I
     : never */
   : never
   : never

package/src/rpc.ts

@@ -1,4 +1,3 @@
-export * as RpcX from "./rpc.js"
 export * as MiddlewareMaker from "./rpc/MiddlewareMaker.js"
 export * as RpcContextMap from "./rpc/RpcContextMap.js"
 export * as RpcMiddleware from "./rpc/RpcMiddleware.js"

package/src/transform.ts

@@ -51,8 +51,8 @@ const encodeOptsAsNullable_ = (value: any, cacheMap: Map<any, any>): any => {
 
   if (
     value instanceof Date
-    || value instanceof Function
-    || value instanceof Promise
+    || typeof value === "function"
+    || (typeof value === "object" && value !== null && "then" in value && typeof value.then === "function")
   ) {
     return value
   }

package/src/utils/gen.ts

@@ -15,7 +15,7 @@ export namespace EffectGenUtils {
     : EG extends (..._: infer _3) => Generator<Yieldable<any, infer _, infer E, infer _R>, infer _A, infer _2> ? E
     : never
 
-  export type ServiceMap<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
+  export type Context<EG> = EG extends Effect<infer _A, infer _E, infer R> ? R
     // there could be a case where the generator function does not yield anything, so we need to handle that
     : EG extends (..._: infer _3) => Generator<never, infer _A, infer _2> ? never
     // v4: generators can yield Yieldable (Effect, Service, etc.), all have asEffect()

package/src/utils/logger.ts

@@ -2,11 +2,11 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 import { Effect, type LogLevel } from "effect"
-import * as ServiceMap from "../ServiceMap.js"
+import * as Context from "../Context.js"
 
 type Levels = "info" | "debug" | "warn" | "error"
 
-export class LogLevels extends ServiceMap.Reference("LogLevels", {
+export class LogLevels extends Context.Reference("LogLevels", {
   defaultValue: () => new Map<string, Levels>()
 }) {}