effect 4.0.0-beta.4 → 4.0.0-beta.41

package/src/unstable/cluster/Runner.ts

@@ -93,4 +93,4 @@ export const make = (props: {
   readonly address: RunnerAddress
   readonly groups: ReadonlyArray<string>
   readonly weight: number
-}): Runner => new Runner(props, { disableValidation: true })
+}): Runner => new Runner(props, { disableChecks: true })

package/src/unstable/cluster/RunnerAddress.ts

@@ -63,4 +63,4 @@ export class RunnerAddress extends Schema.Class<RunnerAddress>(TypeId)({
  * @category constructors
  */
 export const make = (host: string, port: number): RunnerAddress =>
-  new RunnerAddress({ host, port }, { disableValidation: true })
+  new RunnerAddress({ host, port }, { disableChecks: true })

package/src/unstable/cluster/RunnerServer.ts

@@ -6,6 +6,7 @@ import type * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
 import { constant } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RpcServer from "../rpc/RpcServer.ts"
 import type * as ClusterError from "./ClusterError.ts"
@@ -36,23 +37,19 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
           ? new Message.IncomingRequest({
             envelope,
             respond: constVoid,
-            lastSentReply: undefined
+            lastSentReply: Option.none()
           })
           : new Message.IncomingEnvelope({ envelope })
       ),
     Effect: ({ persisted, request }) => {
-      let replyEncoded:
-        | Effect.Effect<
-          Reply.Encoded,
-          ClusterError.EntityNotAssignedToRunner
-        >
-        | undefined = undefined
+      let replyEncoded: Option.Option<Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>> = Option
+        .none()
       let resume = (reply: Effect.Effect<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>) => {
-        replyEncoded = reply
+        replyEncoded = Option.some(reply)
       }
       const message = new Message.IncomingRequest({
         envelope: request,
-        lastSentReply: undefined,
+        lastSentReply: Option.none(),
         respond(reply) {
           resume(Effect.orDie(Reply.serialize(reply)))
           return Effect.void
@@ -89,8 +86,8 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
       return Effect.andThen(
         sharding.send(message),
         Effect.callback<Reply.Encoded, ClusterError.EntityNotAssignedToRunner>((resume_) => {
-          if (replyEncoded) {
-            resume_(replyEncoded)
+          if (Option.isSome(replyEncoded)) {
+            resume_(replyEncoded.value)
           } else {
             resume = resume_
           }
@@ -103,7 +100,7 @@ export const layerHandlers = Runners.Rpcs.toLayer(Effect.gen(function*() {
         (queue) => {
           const message = new Message.IncomingRequest({
             envelope: request,
-            lastSentReply: undefined,
+            lastSentReply: Option.none(),
             respond(reply) {
               return Effect.flatMap(Reply.serialize(reply), (reply) => {
                 Queue.offerUnsafe(queue, reply)
@@ -191,6 +188,6 @@ export const layerClientOnly: Layer.Layer<
   Layer.provide(RunnerHealth.layerNoop),
   Layer.updateService(ShardingConfig, (config) => ({
     ...config,
-    runnerAddress: undefined
+    runnerAddress: Option.none()
   }))
 )

package/src/unstable/cluster/Runners.ts

@@ -3,7 +3,9 @@
  */
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
+import * as Option from "../../Option.ts"
 import * as Queue from "../../Queue.ts"
 import * as RcMap from "../../RcMap.ts"
 import * as Schema from "../../Schema.ts"
@@ -79,7 +81,7 @@ export class Runners extends ServiceMap.Service<Runners, {
    */
   readonly notify: <R extends Rpc.Any>(
     options: {
-      readonly address: RunnerAddress | undefined
+      readonly address: Option.Option<RunnerAddress>
       readonly message: Message.Outgoing<R>
       readonly discard: boolean
     }
@@ -165,8 +167,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
         Duplicate: ({ lastReceivedReply, originalId }) => {
           // If the last received reply is an exit, we can just return it
           // as the response.
-          if (lastReceivedReply && lastReceivedReply._tag === "WithExit") {
-            return message.respond(lastReceivedReply.withRequestId(message.envelope.requestId))
+          if (Option.isSome(lastReceivedReply) && lastReceivedReply.value._tag === "WithExit") {
+            return message.respond(lastReceivedReply.value.withRequestId(message.envelope.requestId))
           }
           requestIdRewrites.set(message.envelope.requestId, originalId)
           return afterPersist(
@@ -192,8 +194,8 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
   }
 
   type StorageRequestEntry = {
-    readonly latch: Effect.Latch
-    doneLatch: Effect.Latch | undefined
+    readonly latch: Latch.Latch
+    doneLatch: Latch.Latch | undefined
     readonly messages: Set<Message.OutgoingRequest<any>>
     replies: Array<Reply.Reply<any>>
   }
@@ -204,11 +206,11 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       let entry = storageRequests.get(message.envelope.requestId)
       if (entry) {
         entry.messages.add(message)
-        entry.doneLatch ??= Effect.makeLatchUnsafe(false)
+        entry.doneLatch ??= Latch.makeUnsafe(false)
         return yield* entry.doneLatch.await
       } else {
         entry = {
-          latch: Effect.makeLatchUnsafe(false),
+          latch: Latch.makeUnsafe(false),
           doneLatch: undefined,
           replies: [],
           messages: new Set([message])
@@ -260,7 +262,7 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       )
   )
 
-  const storageLatch = Effect.makeLatchUnsafe(false)
+  const storageLatch = Latch.makeUnsafe(false)
   if (storage !== MessageStorage.noop) {
     yield* Effect.gen(function*() {
       const foundRequests = new Set<StorageRequestEntry>()
@@ -340,10 +342,10 @@ export const make: (options: Omit<Runners["Service"], "sendLocal" | "notifyLocal
       return notifyWith(message, (message, duplicate) => {
         if (discard || message._tag === "OutgoingEnvelope") {
           return options.notify(options_)
-        } else if (!duplicate && options_.address) {
+        } else if (!duplicate && Option.isSome(options_.address)) {
           return Effect.catch(
             options.send({
-              address: options_.address,
+              address: options_.address.value,
               message
             }),
             (_) => replyFromStorage(message)
@@ -583,11 +585,11 @@ export const makeRpc: Effect.Effect<
       })
     },
     notify({ address, message }) {
-      if (!address) {
+      if (Option.isNone(address)) {
         return Effect.void
       }
       const envelope = message.envelope
-      return RcMap.get(clients, address).pipe(
+      return RcMap.get(clients, address.value).pipe(
         Effect.flatMap((client) => client.Notify({ envelope })),
         Effect.scoped,
         Effect.ignore

package/src/unstable/cluster/ShardId.ts

@@ -8,7 +8,7 @@ import * as S from "../../Schema.ts"
 
 const TypeId = "~effect/cluster/ShardId"
 
-const constDisableValidation = { disableValidation: true }
+const constDisableChecks = { disableChecks: true }
 
 /**
  * @since 4.0.0
@@ -18,7 +18,7 @@ export const make = (group: string, id: number): ShardId => {
   const key = `${group}:${id}`
   let shardId = shardIdCache.get(key)
   if (!shardId) {
-    shardId = new ShardId({ group, id }, constDisableValidation)
+    shardId = new ShardId({ group, id }, constDisableChecks)
     shardIdCache.set(key, shardId)
   }
   return shardId

package/src/unstable/cluster/Sharding.ts

@@ -4,7 +4,7 @@
 import * as Arr from "../../Array.ts"
 import * as Cause from "../../Cause.ts"
 import { Clock } from "../../Clock.ts"
-import type { DurationInput } from "../../Duration.ts"
+import type { Input } from "../../Duration.ts"
 import * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
 import * as Equal from "../../Equal.ts"
@@ -13,6 +13,7 @@ import * as Fiber from "../../Fiber.ts"
 import * as FiberMap from "../../FiberMap.ts"
 import { constant, flow } from "../../Function.ts"
 import * as HashRing from "../../HashRing.ts"
+import * as Latch from "../../Latch.ts"
 import * as Layer from "../../Layer.ts"
 import * as MutableHashMap from "../../MutableHashMap.ts"
 import * as MutableHashSet from "../../MutableHashSet.ts"
@@ -23,6 +24,7 @@ import { CurrentLogAnnotations } from "../../References.ts"
 import * as Result from "../../Result.ts"
 import * as Schedule from "../../Schedule.ts"
 import * as Scope from "../../Scope.ts"
+import * as Semaphore from "../../Semaphore.ts"
 import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Rpc from "../rpc/Rpc.ts"
@@ -113,7 +115,7 @@ export class Sharding extends ServiceMap.Service<Sharding, {
     entity: Entity<Type, Rpcs>,
     handlers: Effect.Effect<Handlers, never, RX>,
     options?: {
-      readonly maxIdleTime?: DurationInput | undefined
+      readonly maxIdleTime?: Input | undefined
       readonly concurrency?: number | "unbounded" | undefined
       readonly mailboxCapacity?: number | "unbounded" | undefined
       readonly disableFatalDefects?: boolean | undefined
@@ -197,6 +199,7 @@ interface EntityManagerState {
 
 const make = Effect.gen(function*() {
   const config = yield* ShardingConfig
+  const getRunnerAddress = () => Option.getOrUndefined(config.runnerAddress)
   const clock = yield* Clock
 
   const runnersService = yield* Runners
@@ -221,12 +224,15 @@ const make = Effect.gen(function*() {
 
   // the active shards are the ones that we have acquired the lock for
   const acquiredShards = MutableHashSet.empty<ShardId>()
-  const activeShardsLatch = yield* Effect.makeLatch(false)
+  const activeShardsLatch = yield* Latch.make(false)
 
   const events = yield* PubSub.unbounded<ShardingRegistrationEvent>()
   const getRegistrationEvents: Stream.Stream<ShardingRegistrationEvent> = Stream.fromPubSub(events)
 
-  const isLocalRunner = (address: RunnerAddress) => Equal.equals(address, config.runnerAddress)
+  const isLocalRunner = (address: RunnerAddress) => {
+    const runnerAddress = getRunnerAddress()
+    return runnerAddress !== undefined && Equal.equals(address, runnerAddress)
+  }
 
   function getShardId(entityId: EntityId, group: string): ShardId {
     const id = Math.abs(hashString(entityId) % config.shardsPerGroup) + 1
@@ -252,8 +258,9 @@ const make = Effect.gen(function*() {
   // allow them to move to another runner.
 
   const releasingShards = MutableHashSet.empty<ShardId>()
-  if (config.runnerAddress) {
-    const selfAddress = config.runnerAddress
+  const initialRunnerAddress = getRunnerAddress()
+  if (initialRunnerAddress) {
+    const selfAddress = initialRunnerAddress
     yield* Scope.addFinalizerExit(shardingScope, () => {
       // the locks expire over time, so if this fails we ignore it
       return Effect.ignore(runnerStorage.releaseAll(selfAddress))
@@ -429,16 +436,16 @@ const make = Effect.gen(function*() {
   // It should also be shutdown after the entity managers, to ensure interrupt
   // & ack envelopes can still be processed.
 
-  const storageReadLatch = yield* Effect.makeLatch(true)
+  const storageReadLatch = yield* Latch.make(true)
   const openStorageReadLatch = constant(Effect.asVoid(storageReadLatch.open))
 
-  const storageReadLock = Effect.makeSemaphoreUnsafe(1)
+  const storageReadLock = Semaphore.makeUnsafe(1)
   const withStorageReadLock = storageReadLock.withPermits(1)
 
-  if (storageEnabled && config.runnerAddress) {
-    const selfAddress = config.runnerAddress
+  if (storageEnabled && initialRunnerAddress) {
+    const selfAddress = initialRunnerAddress
     const entityRegistrationTimeoutMillis = Duration.toMillis(
-      Duration.fromDurationInputUnsafe(config.entityRegistrationTimeout)
+      Duration.fromInputUnsafe(config.entityRegistrationTimeout)
     )
     const storageStartMillis = clock.currentTimeMillisUnsafe()
 
@@ -810,10 +817,13 @@ const make = Effect.gen(function*() {
     void,
     MailboxFull | AlreadyProcessingMessage | PersistenceError
   > {
-    return Effect.catchIf(
+    return Effect.catchFilter(
       Effect.suspend(() => {
         const address = message.envelope.address
-        const isPersisted = ServiceMap.get(message.rpc.annotations, Persisted)
+        const isPersisted = ServiceMap.get(
+          message._tag === "OutgoingRequest" ? message.annotations : message.rpc.annotations,
+          Persisted
+        )
         if (isPersisted && !storageEnabled) {
           return Effect.die("Sharding.sendOutgoing: Persisted messages require MessageStorage")
         }
@@ -822,7 +832,7 @@ const make = Effect.gen(function*() {
         if (isPersisted) {
           return runnerIsLocal
             ? notifyLocal(message, discard)
-            : runnersService.notify({ address: Option.getOrUndefined(maybeRunner), message, discard })
+            : runnersService.notify({ address: maybeRunner, message, discard })
         } else if (Option.isNone(maybeRunner)) {
           return Effect.fail(new EntityNotAssignedToRunner({ address }))
         }
@@ -858,9 +868,9 @@ const make = Effect.gen(function*() {
   // shard assignments for outgoing messages (they could still be in use by
   // entities that are shutting down).
 
-  const selfRunner = config.runnerAddress ?
+  const selfRunner = initialRunnerAddress ?
     new Runner({
-      address: config.runnerAddress,
+      address: initialRunnerAddress,
       groups: config.shardGroups,
       weight: config.runnerShardWeight
     }) :
@@ -983,7 +993,7 @@ const make = Effect.gen(function*() {
     Effect.annotateLogs({
       module: "effect/cluster/Sharding",
       fiber: "RunnerStorage sync",
-      runner: config.runnerAddress
+      runner: initialRunnerAddress
     }),
     Effect.forkIn(shardingScope)
   )
@@ -993,6 +1003,7 @@ const make = Effect.gen(function*() {
   type ClientRequestEntry = {
     readonly rpc: Rpc.AnyWithProps
     readonly services: ServiceMap.ServiceMap<never>
+    readonly message: Message.OutgoingRequest<any>
     lastChunkId?: Snowflake.Snowflake
   }
   const clientRequests = new Map<Snowflake.Snowflake, ClientRequestEntry>()
@@ -1022,35 +1033,39 @@ const make = Effect.gen(function*() {
             const id = Snowflake.Snowflake(options.message.id)
             const rpc = entity.protocol.requests.get(options.message.tag)!
             let respond: (reply: Reply.Reply<any>) => Effect.Effect<void>
+            const envelope = Envelope.makeRequest<any>({
+              requestId: id,
+              address,
+              tag: options.message.tag,
+              payload: options.message.payload,
+              headers: options.message.headers,
+              traceId: options.message.traceId,
+              spanId: options.message.spanId,
+              sampled: options.message.sampled
+            })
+            const message = new Message.OutgoingRequest({
+              envelope,
+              lastReceivedReply: Option.none(),
+              rpc,
+              services: fiber.services as ServiceMap.ServiceMap<any>,
+              respond: (reply) => respond(reply),
+              annotations: ServiceMap.get(rpc.annotations, ClusterSchema.Dynamic)(
+                rpc.annotations,
+                envelope as any
+              )
+            })
             if (!options.discard) {
               const entry: ClientRequestEntry = {
                 rpc: rpc as any,
-                services: fiber.currentContext
+                services: fiber.currentContext,
+                message
               }
               clientRequests.set(id, entry)
               respond = makeClientRespond(entry, client.write)
             } else {
               respond = clientRespondDiscard
             }
-            return sendOutgoing(
-              new Message.OutgoingRequest({
-                envelope: Envelope.makeRequest({
-                  requestId: id,
-                  address,
-                  tag: options.message.tag,
-                  payload: options.message.payload,
-                  headers: options.message.headers,
-                  traceId: options.message.traceId,
-                  spanId: options.message.spanId,
-                  sampled: options.message.sampled
-                }),
-                lastReceivedReply: undefined,
-                rpc,
-                services: fiber.services as ServiceMap.ServiceMap<any>,
-                respond
-              }),
-              options.discard
-            )
+            return sendOutgoing(message, options.discard)
           }
           case "Ack": {
             const requestId = Snowflake.Snowflake(options.message.requestId)
@@ -1074,14 +1089,14 @@ const make = Effect.gen(function*() {
             const entry = clientRequests.get(requestId)!
             if (!entry) return Effect.void
             clientRequests.delete(requestId)
-            if (ClusterSchema.isUninterruptibleForClient(entry.rpc.annotations)) {
+            if (ClusterSchema.isUninterruptibleForClient(entry.message.annotations)) {
               return Effect.void
             }
             // for durable messages, we ignore interrupts on shutdown or as a
             // result of a shard being resassigned
             const isTransientInterrupt = MutableRef.get(isShutdown) ||
               options.message.interruptors.some((id) => internalInterruptors.has(id))
-            if (isTransientInterrupt && ServiceMap.get(entry.rpc.annotations, Persisted)) {
+            if (isTransientInterrupt && ServiceMap.get(entry.message.annotations, Persisted)) {
               return Effect.void
             }
             return Effect.ignore(sendOutgoing(
@@ -1182,7 +1197,7 @@ const make = Effect.gen(function*() {
 
   const singletons = new Map<ShardId, MutableHashMap.MutableHashMap<SingletonAddress, Effect.Effect<void>>>()
   const singletonFibers = yield* FiberMap.make<SingletonAddress>()
-  const withSingletonLock = Effect.makeSemaphoreUnsafe(1).withPermits(1)
+  const withSingletonLock = Semaphore.makeUnsafe(1).withPermits(1)
 
   const registerSingleton: Sharding["Service"]["registerSingleton"] = Effect.fnUntraced(
     function*(name, run, options) {
@@ -1253,11 +1268,12 @@ const make = Effect.gen(function*() {
   // --- Entities ---
 
   const reaper = yield* EntityReaper
-  const entityManagerLatches = new Map<string, Effect.Latch>()
+  const entityManagerLatches = new Map<string, Latch.Latch>()
 
   const registerEntity: Sharding["Service"]["registerEntity"] = Effect.fnUntraced(
     function*(entity, build, options) {
-      if (!config.runnerAddress || entityManagers.has(entity.type)) return
+      const runnerAddress = getRunnerAddress()
+      if (!runnerAddress || entityManagers.has(entity.type)) return
       const scope = yield* Effect.scope
       yield* Scope.addFinalizer(
         scope,
@@ -1268,14 +1284,15 @@ const make = Effect.gen(function*() {
       const manager = yield* EntityManager.make(entity, build, {
         ...options,
         storage,
-        runnerAddress: config.runnerAddress,
+        runnerAddress,
         sharding
       }).pipe(
-        Effect.provideServices(services.pipe(
-          ServiceMap.add(EntityReaper, reaper),
-          ServiceMap.add(Scope.Scope, scope),
-          ServiceMap.add(Snowflake.Generator, snowflakeGen)
-        ))
+        Effect.provideServices(ServiceMap.mutate(services, (services) =>
+          services.pipe(
+            ServiceMap.add(EntityReaper, reaper),
+            ServiceMap.add(Scope.Scope, scope),
+            ServiceMap.add(Snowflake.Generator, snowflakeGen)
+          )))
       ) as Effect.Effect<EntityManager.EntityManager>
       const state: EntityManagerState = {
         entity,
@@ -1310,7 +1327,7 @@ const make = Effect.gen(function*() {
   const waitForEntityManager = (entityType: string) => {
     let latch = entityManagerLatches.get(entityType)
     if (!latch) {
-      latch = Effect.makeLatchUnsafe()
+      latch = Latch.makeUnsafe()
       entityManagerLatches.set(entityType, latch)
     }
     return latch.await