@effect/cluster 0.49.3 → 0.49.5

package/src/Entity.ts

@@ -7,13 +7,14 @@ 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 Cause from "effect/Cause"
 import * as Context from "effect/Context"
 import * as Data from "effect/Data"
 import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
 import * as Exit from "effect/Exit"
+import * as FiberId from "effect/FiberId"
 import { identity } from "effect/Function"
 import * as Hash from "effect/Hash"
 import * as Layer from "effect/Layer"
@@ -492,6 +493,18 @@ export class Request<Rpc extends Rpc.Any> extends Data.Class<
 
 const shardingTag = Context.GenericTag<Sharding, Sharding["Type"]>("@effect/cluster/Sharding")
 
+/**
+ * @since 1.0.0
+ * @category Interruption
+ */
+export const fiberIdIgnored = FiberId.make(-1, 0)
+
+/**
+ * @since 1.0.0
+ * @category Interruption
+ */
+export const interruptIgnored = Effect.failCause(Cause.interrupt(fiberIdIgnored))
+
 /**
  * @since 1.0.0
  * @category Testing

package/src/SqlMessageStorage.ts

@@ -379,14 +379,15 @@ export const make = Effect.fnUntraced(function*(options?: {
               return SaveResultEncoded.Success()
             }
             const row = rows[0]
+            const replyKindNum = typeof row.reply_kind === "bigint" ? Number(row.reply_kind) : row.reply_kind
             return SaveResultEncoded.Duplicate({
               originalId: Snowflake.Snowflake(row.id as any),
               lastReceivedReply: row.reply_id ?
                 Option.some({
                   id: String(row.reply_id),
                   requestId: String(row.id),
-                  _tag: row.reply_kind === replyKind.WithExit ? "WithExit" : "Chunk",
-                  ...(row.reply_kind === replyKind.WithExit
+                  _tag: replyKindNum === replyKind.WithExit ? "WithExit" : "Chunk",
+                  ...(replyKindNum === replyKind.WithExit
                     ? { exit: JSON.parse(row.reply_payload as string) }
                     : {
                       sequence: Number(row.reply_sequence),

package/src/internal/entityManager.ts

@@ -9,9 +9,12 @@ import type { DurationInput } from "effect/Duration"
 import * as Effect from "effect/Effect"
 import * as Equal from "effect/Equal"
 import * as Exit from "effect/Exit"
+import * as FiberId from "effect/FiberId"
 import * as FiberRef from "effect/FiberRef"
 import { identity } from "effect/Function"
+import * as Function from "effect/Function"
 import * as HashMap from "effect/HashMap"
+import * as HashSet from "effect/HashSet"
 import * as Metric from "effect/Metric"
 import * as Option from "effect/Option"
 import * as Schedule from "effect/Schedule"
@@ -168,8 +171,10 @@ export const make = Effect.fnUntraced(function*<
                 if (
                   storageEnabled &&
                   Context.get(request.rpc.annotations, Persisted) &&
+                  Exit.isFailure(response.exit) &&
                   Exit.isInterrupted(response.exit) &&
-                  (isShuttingDown || Context.get(request.rpc.annotations, Uninterruptible))
+                  (isShuttingDown || Context.get(request.rpc.annotations, Uninterruptible) ||
+                    isInterruptIgnore(response.exit.cause))
                 ) {
                   return options.storage.unregisterReplyHandler(request.message.envelope.requestId)
                 }
@@ -543,3 +548,17 @@ const retryRespond = <A, E, R>(times: number, effect: Effect.Effect<A, E, R>): E
   times === 0 ?
     effect :
     Effect.catchAll(effect, () => Effect.delay(retryRespond(times - 1, effect), 200))
+
+const IsInterruptedIgnoreReducer: Cause.CauseReducer<unknown, unknown, boolean> = {
+  emptyCase: Function.constFalse,
+  failCase: Function.constFalse,
+  dieCase: Function.constFalse,
+  interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), -1),
+  sequentialCase: (_, left, right) => left || right,
+  parallelCase: (_, left, right) => left || right
+}
+
+const isInterruptIgnore: (self: Cause.Cause<unknown>) => boolean = Cause.reduceWithContext(
+  undefined,
+  IsInterruptedIgnoreReducer
+)