@effect/cluster 0.40.0 → 0.41.1

package/src/Entity.ts

@@ -6,6 +6,7 @@ import * as RpcClient from "@effect/rpc/RpcClient"
 import * as RpcGroup from "@effect/rpc/RpcGroup"
 import * as RpcServer from "@effect/rpc/RpcServer"
 import * as Arr from "effect/Array"
+import type { Brand } from "effect/Brand"
 import type * as Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Data from "effect/Data"
@@ -58,12 +59,15 @@ export type TypeId = typeof TypeId
  * @since 1.0.0
  * @category models
  */
-export interface Entity<in out Rpcs extends Rpc.Any> extends Equal.Equal {
+export interface Entity<
+  in out Type extends string,
+  in out Rpcs extends Rpc.Any
+> extends Equal.Equal {
   readonly [TypeId]: TypeId
   /**
    * The name of the entity type.
    */
-  readonly type: EntityType
+  readonly type: Type & Brand<"EntityType">
 
   /**
    * A RpcGroup definition for messages which represents the messaging protocol
@@ -84,22 +88,22 @@ export interface Entity<in out Rpcs extends Rpc.Any> extends Equal.Equal {
   /**
    * Annotate the entity with a value.
    */
-  annotate<I, S>(tag: Context.Tag<I, S>, value: S): Entity<Rpcs>
+  annotate<I, S>(tag: Context.Tag<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a value.
    */
-  annotateRpcs<I, S>(tag: Context.Tag<I, S>, value: S): Entity<Rpcs>
+  annotateRpcs<I, S>(tag: Context.Tag<I, S>, value: S): Entity<Type, Rpcs>
 
   /**
    * Annotate the entity with a context object.
    */
-  annotateContext<S>(context: Context.Context<S>): Entity<Rpcs>
+  annotateContext<S>(context: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Annotate the Rpc's above this point with a context object.
    */
-  annotateRpcsContext<S>(context: Context.Context<S>): Entity<Rpcs>
+  annotateRpcsContext<S>(context: Context.Context<S>): Entity<Type, Rpcs>
 
   /**
    * Create a client for this entity.
@@ -188,7 +192,7 @@ export interface Entity<in out Rpcs extends Rpc.Any> extends Equal.Equal {
  * @since 1.0.0
  * @category models
  */
-export type Any = Entity<Rpc.Any>
+export type Any = Entity<string, Rpc.Any>
 
 /**
  * @since 1.0.0
@@ -208,25 +212,25 @@ export const isEntity = (u: unknown): u is Any => Predicate.hasProperty(u, TypeI
 
 const Proto = {
   [TypeId]: TypeId,
-  [Hash.symbol](this: Entity<any>): number {
+  [Hash.symbol](this: Entity<string, any>): number {
     return Hash.structure({ type: this.type })
   },
-  [Equal.symbol](this: Entity<any>, that: Equal.Equal): boolean {
+  [Equal.symbol](this: Entity<string, any>, that: Equal.Equal): boolean {
     return isEntity(that) && this.type === that.type
   },
-  annotate<I, S>(this: Entity<any>, tag: Context.Tag<I, S>, value: S) {
+  annotate<I, S>(this: Entity<string, any>, tag: Context.Tag<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotate(tag, value))
   },
-  annotateRpcs<I, S>(this: Entity<any>, tag: Context.Tag<I, S>, value: S) {
+  annotateRpcs<I, S>(this: Entity<string, any>, tag: Context.Tag<I, S>, value: S) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcs(tag, value))
   },
-  annotateContext<S>(this: Entity<any>, context: Context.Context<S>) {
+  annotateContext<S>(this: Entity<string, any>, context: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateContext(context))
   },
-  annotateRpcsContext<S>(this: Entity<any>, context: Context.Context<S>) {
+  annotateRpcsContext<S>(this: Entity<string, any>, context: Context.Context<S>) {
     return fromRpcGroup(this.type, this.protocol.annotateRpcsContext(context))
   },
-  getShardId(this: Entity<any>, entityId: EntityId) {
+  getShardId(this: Entity<string, any>, entityId: EntityId) {
     return Effect.map(shardingTag, (sharding) => sharding.getShardId(entityId, this.getShardGroup(entityId)))
   },
   get client() {
@@ -239,7 +243,7 @@ const Proto = {
     Handlers extends HandlersFrom<Rpcs>,
     RX = never
   >(
-    this: Entity<Rpcs>,
+    this: Entity<string, Rpcs>,
     build: Handlers | Effect.Effect<Handlers, never, RX>,
     options?: {
       readonly maxIdleTime?: DurationInput | undefined
@@ -275,7 +279,7 @@ const Proto = {
     R,
     RX = never
   >(
-    this: Entity<Rpcs>,
+    this: Entity<string, Rpcs>,
     build:
       | ((
         mailbox: Mailbox.ReadonlyMailbox<Envelope.Request<Rpcs>>,
@@ -360,17 +364,17 @@ const Proto = {
  * @since 1.0.0
  * @category constructors
  */
-export const fromRpcGroup = <Rpcs extends Rpc.Any>(
+export const fromRpcGroup = <const Type extends string, Rpcs extends Rpc.Any>(
   /**
    * The entity type name.
    */
-  type: string,
+  type: Type,
   /**
    * The schema definition for messages that the entity is capable of
    * processing.
    */
   protocol: RpcGroup.RpcGroup<Rpcs>
-): Entity<Rpcs> => {
+): Entity<Type, Rpcs> => {
   const self = Object.create(Proto)
   self.type = EntityType.make(type)
   self.protocol = protocol
@@ -385,17 +389,17 @@ export const fromRpcGroup = <Rpcs extends Rpc.Any>(
  * @since 1.0.0
  * @category constructors
  */
-export const make = <Rpcs extends ReadonlyArray<Rpc.Any>>(
+export const make = <const Type extends string, Rpcs extends ReadonlyArray<Rpc.Any>>(
   /**
    * The entity type name.
    */
-  type: string,
+  type: Type,
   /**
    * The schema definition for messages that the entity is capable of
    * processing.
    */
   protocol: Rpcs
-): Entity<Rpcs[number]> => fromRpcGroup(type, RpcGroup.make(...protocol))
+): Entity<Type, Rpcs[number]> => fromRpcGroup(type, RpcGroup.make(...protocol))
 
 /**
  * A Context.Tag to access the current entity address.
@@ -492,15 +496,15 @@ const shardingTag = Context.GenericTag<Sharding, Sharding["Type"]>("@effect/clus
  * @since 1.0.0
  * @category Testing
  */
-export const makeTestClient: <Rpcs extends Rpc.Any, LA, LE, LR>(
-  entity: Entity<Rpcs>,
+export const makeTestClient: <Type extends string, Rpcs extends Rpc.Any, LA, LE, LR>(
+  entity: Entity<Type, Rpcs>,
   layer: Layer.Layer<LA, LE, LR>
 ) => Effect.Effect<
   (entityId: string) => Effect.Effect<RpcClient.RpcClient<Rpcs>>,
   LE,
   Scope | ShardingConfig | Exclude<LR, Sharding> | Rpc.MiddlewareClient<Rpcs>
-> = Effect.fnUntraced(function*<Rpcs extends Rpc.Any, LA, LE, LR>(
-  entity: Entity<Rpcs>,
+> = Effect.fnUntraced(function*<Type extends string, Rpcs extends Rpc.Any, LA, LE, LR>(
+  entity: Entity<Type, Rpcs>,
   layer: Layer.Layer<LA, LE, LR>
 ) {
   const config = yield* ShardingConfig

package/src/EntityProxy.ts

@@ -45,13 +45,9 @@ const clientErrors = [
  * @since 1.0.0
  * @category Constructors
  */
-export const toRpcGroup = <Rpcs extends Rpc.Any, const Prefix extends string = "">(
-  entity: Entity.Entity<Rpcs>,
-  options?: {
-    readonly prefix?: Prefix | undefined
-  }
-): RpcGroup.RpcGroup<ConvertRpcs<Rpcs, Prefix>> => {
-  const prefix = options?.prefix ?? ""
+export const toRpcGroup = <Type extends string, Rpcs extends Rpc.Any>(
+  entity: Entity.Entity<Type, Rpcs>
+): RpcGroup.RpcGroup<ConvertRpcs<Rpcs, Type>> => {
   const rpcs: Array<Rpc.Any> = []
   for (const parentRpc_ of entity.protocol.requests.values()) {
     const parentRpc = parentRpc_ as any as Rpc.AnyWithProps
@@ -66,14 +62,14 @@ export const toRpcGroup = <Rpcs extends Rpc.Any, const Prefix extends string = "
         payload: parentRpc.payloadSchema.make ? parentRpc.payloadSchema.make(input.payload, options) : input.payload
       }, options)
     }
-    const rpc = Rpc.make(`${prefix}${parentRpc._tag}`, {
+    const rpc = Rpc.make(`${entity.type}.${parentRpc._tag}`, {
       payload: payloadSchema,
       error: Schema.Union(parentRpc.errorSchema, ...clientErrors),
       success: parentRpc.successSchema
     }).annotateContext(parentRpc.annotations)
     rpcs.push(rpc)
   }
-  return RpcGroup.make(...rpcs) as any as RpcGroup.RpcGroup<ConvertRpcs<Rpcs, Prefix>>
+  return RpcGroup.make(...rpcs) as any as RpcGroup.RpcGroup<ConvertRpcs<Rpcs, Type>>
 }
 
 /**
@@ -86,7 +82,7 @@ export type ConvertRpcs<Rpcs extends Rpc.Any, Prefix extends string> = Rpcs exte
   infer _Error,
   infer _Middleware
 > ? Rpc.Rpc<
-    `${Prefix}${_Tag}`,
+    `${Prefix}.${_Tag}`,
     Schema.Struct<{
       entityId: typeof Schema.String
       payload: _Payload
@@ -144,9 +140,9 @@ const entityIdPath = Schema.Struct({
  * @since 1.0.0
  * @category Constructors
  */
-export const toHttpApiGroup = <const Name extends string, Rpcs extends Rpc.Any>(
+export const toHttpApiGroup = <const Name extends string, Type extends string, Rpcs extends Rpc.Any>(
   name: Name,
-  entity: Entity.Entity<Rpcs>
+  entity: Entity.Entity<Type, Rpcs>
 ): HttpApiGroup.HttpApiGroup<Name, ConvertHttpApi<Rpcs>> => {
   let group = HttpApiGroup.make(name)
   for (const parentRpc_ of entity.protocol.requests.values()) {

package/src/EntityProxyServer.ts

@@ -21,11 +21,12 @@ export const layerHttpApi = <
   ApiE,
   ApiR,
   Name extends HttpApiGroup.Name<Groups>,
+  Type extends string,
   Rpcs extends Rpc.Any
 >(
   api: HttpApi.HttpApi<ApiId, Groups, ApiE, ApiR>,
   name: Name,
-  entity: Entity.Entity<Rpcs>
+  entity: Entity.Entity<Type, Rpcs>
 ): Layer.Layer<ApiGroup<ApiId, Name>, never, Sharding | Rpc.Context<Rpcs>> =>
   HttpApiBuilder.group(
     api,
@@ -50,19 +51,16 @@ export const layerHttpApi = <
  * @category Layers
  */
 export const layerRpcHandlers = <
-  Rpcs extends Rpc.Any,
-  const Prefix extends string = ""
->(entity: Entity.Entity<Rpcs>, options?: {
-  readonly prefix?: Prefix
-}): Layer.Layer<RpcHandlers<Rpcs, Prefix>, never, Sharding | Rpc.Context<Rpcs>> =>
+  const Type extends string,
+  Rpcs extends Rpc.Any
+>(entity: Entity.Entity<Type, Rpcs>): Layer.Layer<RpcHandlers<Rpcs, Type>, never, Sharding | Rpc.Context<Rpcs>> =>
   Layer.effectContext(Effect.gen(function*() {
     const context = yield* Effect.context<never>()
-    const prefix = options?.prefix ?? ""
     const client = yield* entity.client
     const handlers = new Map<string, Rpc.Handler<string>>()
     for (const parentRpc_ of entity.protocol.requests.values()) {
       const parentRpc = parentRpc_ as any as Rpc.AnyWithProps
-      const tag = `${prefix}${parentRpc._tag}` as const
+      const tag = `${entity.type}.${parentRpc._tag}` as const
       const key = `@effect/rpc/Rpc/${tag}`
       handlers.set(key, {
         context,
@@ -82,5 +80,5 @@ export type RpcHandlers<Rpcs extends Rpc.Any, Prefix extends string> = Rpcs exte
   infer _Success,
   infer _Error,
   infer _Middleware
-> ? Rpc.Handler<`${Prefix}${_Tag}`>
+> ? Rpc.Handler<`${Prefix}.${_Tag}`>
   : never

package/src/Sharding.ts

@@ -40,7 +40,6 @@ import { Persisted, Uninterruptible } from "./ClusterSchema.js"
 import type { CurrentAddress, CurrentRunnerAddress, Entity, HandlersFrom } from "./Entity.js"
 import { EntityAddress } from "./EntityAddress.js"
 import { EntityId } from "./EntityId.js"
-import type { EntityType } from "./EntityType.js"
 import * as Envelope from "./Envelope.js"
 import * as EntityManager from "./internal/entityManager.js"
 import { EntityReaper } from "./internal/entityReaper.js"
@@ -86,8 +85,8 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
    * Constructs a `RpcClient` which can be used to send messages to the
    * specified `Entity`.
    */
-  readonly makeClient: <Rpcs extends Rpc.Any>(
-    entity: Entity<Rpcs>
+  readonly makeClient: <Type extends string, Rpcs extends Rpc.Any>(
+    entity: Entity<Type, Rpcs>
   ) => Effect.Effect<
     (
       entityId: string
@@ -97,8 +96,8 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
   /**
    * Registers a new entity with the runner.
    */
-  readonly registerEntity: <Rpcs extends Rpc.Any, Handlers extends HandlersFrom<Rpcs>, RX>(
-    entity: Entity<Rpcs>,
+  readonly registerEntity: <Type extends string, Rpcs extends Rpc.Any, Handlers extends HandlersFrom<Rpcs>, RX>(
+    entity: Entity<Type, Rpcs>,
     handlers: Effect.Effect<Handlers, never, RX>,
     options?: {
       readonly maxIdleTime?: DurationInput | undefined
@@ -173,7 +172,7 @@ export class Sharding extends Context.Tag("@effect/cluster/Sharding")<Sharding,
 // -----------------------------------------------------------------------------
 
 interface EntityManagerState {
-  readonly entity: Entity<any>
+  readonly entity: Entity<any, any>
   readonly scope: Scope.CloseableScope
   readonly manager: EntityManager.EntityManager
 }
@@ -191,7 +190,7 @@ const make = Effect.gen(function*() {
   const storageEnabled = storage !== MessageStorage.noop
   const shardStorage = yield* ShardStorage
 
-  const entityManagers = new Map<EntityType, EntityManagerState>()
+  const entityManagers = new Map<string, EntityManagerState>()
 
   const shardAssignments = MutableHashMap.empty<ShardId, RunnerAddress>()
   const selfShards = MutableHashSet.empty<ShardId>()
@@ -939,13 +938,13 @@ const make = Effect.gen(function*() {
   const clientRequests = new Map<Snowflake.Snowflake, ClientRequestEntry>()
 
   const clients: ResourceMap<
-    Entity<any>,
+    Entity<any, any>,
     (entityId: string) => RpcClient.RpcClient<
       any,
       MailboxFull | AlreadyProcessingMessage | EntityNotManagedByRunner
     >,
     never
-  > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<any>) {
+  > = yield* ResourceMap.make(Effect.fnUntraced(function*(entity: Entity<string, any>) {
     const client = yield* RpcClient.makeNoSerialization(entity.protocol, {
       spanPrefix: `${entity.type}.client`,
       supportsAck: true,
@@ -1041,20 +1040,29 @@ const make = Effect.gen(function*() {
       }
     })
 
-    const wrappedClient: any = {}
-    for (const method of Object.keys(client.client)) {
-      wrappedClient[method] = function(this: any, payload: any, options?: {
-        readonly context?: Context.Context<never>
-      }) {
-        return (client as any).client[method](payload, {
-          ...options,
-          context: options?.context
-            ? Context.merge(options.context, this[currentClientAddress])
-            : this[currentClientAddress]
-        })
+    function patchClient(client: any): any {
+      const wrappedClient: any = {}
+      for (const method of Object.keys(client.client)) {
+        if (typeof client.client[method] === "object") {
+          wrappedClient[method] = patchClient(client.client[method])
+          continue
+        }
+        wrappedClient[method] = function(this: any, payload: any, options?: {
+          readonly context?: Context.Context<never>
+        }) {
+          return (client as any).client[method](payload, {
+            ...options,
+            context: options?.context
+              ? Context.merge(options.context, this[currentClientAddress])
+              : this[currentClientAddress]
+          })
+        }
       }
+      return wrappedClient
     }
 
+    const wrappedClient = patchClient(client)
+
     yield* Scope.addFinalizer(
       yield* Effect.scope,
       Effect.withFiberRuntime((fiber) => {
@@ -1076,9 +1084,9 @@ const make = Effect.gen(function*() {
     }
   }))
 
-  const makeClient = <Rpcs extends Rpc.Any>(entity: Entity<Rpcs>): Effect.Effect<
+  const makeClient = <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>): Effect.Effect<
     (entityId: string) => RpcClient.RpcClient<Rpcs, MailboxFull | AlreadyProcessingMessage | EntityNotManagedByRunner>
-  > => clients.get(entity)
+  > => clients.get(entity) as any
 
   const clientRespondDiscard = (_reply: Reply.Reply<any>) => Effect.void
 

package/src/ShardingRegistrationEvent.ts

@@ -23,7 +23,7 @@ export type ShardingRegistrationEvent =
  */
 export interface EntityRegistered {
   readonly _tag: "EntityRegistered"
-  readonly entity: Entity<any>
+  readonly entity: Entity<any, any>
 }
 
 /**

package/src/internal/entityManager.ts

@@ -75,11 +75,12 @@ export type EntityState = {
 
 /** @internal */
 export const make = Effect.fnUntraced(function*<
+  Type extends string,
   Rpcs extends Rpc.Any,
   Handlers extends HandlersFrom<Rpcs>,
   RX
 >(
-  entity: Entity<Rpcs>,
+  entity: Entity<Type, Rpcs>,
   buildHandlers: Effect.Effect<Handlers, never, RX>,
   options: {
     readonly sharding: Sharding["Type"]
@@ -501,7 +502,7 @@ const defaultRetryPolicy = Schedule.exponential(500, 1.5).pipe(
   Schedule.union(Schedule.spaced("10 seconds"))
 )
 
-const makeMessageSchema = <Rpcs extends Rpc.Any>(entity: Entity<Rpcs>): Schema.Schema<
+const makeMessageSchema = <Type extends string, Rpcs extends Rpc.Any>(entity: Entity<Type, Rpcs>): Schema.Schema<
   {
     readonly _tag: "IncomingRequest"
     readonly envelope: Envelope.Request.Any