@effect/cluster 0.0.0-snapshot-d33d8b050b8e3c87dcde9587083e6c1cf733f72b

package/src/internal/messageState.ts

@@ -0,0 +1,98 @@
+import * as Schema from "@effect/schema/Schema"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import type * as MessageState from "../MessageState.js"
+
+/** @internal */
+const MessageStateSymbolKey = "@effect/cluster/MessageState"
+
+/** @internal */
+export const MessageStateTypeId: MessageState.MessageStateTypeId = Symbol.for(
+  MessageStateSymbolKey
+) as MessageState.MessageStateTypeId
+
+/** @internal */
+export function isMessageState(value: unknown): value is MessageState.MessageState<unknown> {
+  return typeof value === "object" && value !== null && MessageStateTypeId in value
+}
+
+/** @internal */
+export const Acknowledged: MessageState.MessageStateAcknowledged = {
+  [MessageStateTypeId]: MessageStateTypeId,
+  _tag: "@effect/cluster/MessageState/Acknowledged"
+}
+
+/** @internal */
+export function Processed<A>(result: A): MessageState.MessageStateProcessed<A> {
+  return ({
+    [MessageStateTypeId]: MessageStateTypeId,
+    _tag: "@effect/cluster/MessageState/Processed",
+    result
+  })
+}
+
+/** @internal */
+export function match<A, B, C = B>(
+  cases: {
+    onAcknowledged: (value: MessageState.MessageStateAcknowledged) => B
+    onProcessed: (exit: MessageState.MessageStateProcessed<A>) => C
+  }
+) {
+  return (value: MessageState.MessageState<A>) => {
+    switch (value._tag) {
+      case "@effect/cluster/MessageState/Acknowledged":
+        return cases.onAcknowledged(value)
+      case "@effect/cluster/MessageState/Processed":
+        return cases.onProcessed(value)
+    }
+  }
+}
+
+/** @internal */
+export function mapEffect<A, B, R, E>(
+  value: MessageState.MessageState<A>,
+  fn: (value: A) => Effect.Effect<B, E, R>
+): Effect.Effect<MessageState.MessageState<B>, E, R> {
+  return pipe(
+    value,
+    match({
+      onAcknowledged: Effect.succeed,
+      onProcessed: (_) =>
+        Effect.map(fn(_.result), (_) => Processed(_)) as Effect.Effect<MessageState.MessageState<B>, E, R>
+    })
+  )
+}
+
+/** @internal */
+export function schema<A, I>(
+  result: Schema.Schema<A, I>
+): Schema.Schema<
+  MessageState.MessageState<A>,
+  MessageState.MessageState.Encoded<I>
+> {
+  return Schema.Union(
+    Schema.rename(
+      Schema.Struct({
+        [MessageStateSymbolKey]: Schema.compose(
+          Schema.compose(Schema.Literal(MessageStateSymbolKey), Schema.Symbol, { strict: false }),
+          Schema.UniqueSymbolFromSelf(MessageStateTypeId),
+          { strict: false }
+        ),
+        _tag: Schema.Literal("@effect/cluster/MessageState/Acknowledged")
+      }),
+      { [MessageStateSymbolKey]: MessageStateTypeId }
+    ),
+    Schema.rename(
+      Schema.Struct({
+        [MessageStateSymbolKey]: Schema.compose(
+          Schema.compose(Schema.Literal(MessageStateSymbolKey), Schema.Symbol, { strict: false }),
+          Schema.UniqueSymbolFromSelf(MessageStateTypeId),
+          { strict: false }
+        ),
+        _tag: Schema.Literal("@effect/cluster/MessageState/Processed"),
+        result
+      }),
+      { [MessageStateSymbolKey]: MessageStateTypeId }
+    )
+  )
+}

package/src/internal/podWithMetadata.ts

@@ -0,0 +1,72 @@
+import * as Data from "effect/Data"
+import { pipe } from "effect/Function"
+import * as List from "effect/List"
+import * as Option from "effect/Option"
+import type * as Pod from "../Pod.js"
+
+/** @internal */
+const PodWithMetadataSymbolKey = "@effect/cluster/PodWithMetadata"
+
+/** @internal */
+export const PodWithMetadataTypeId = Symbol.for(PodWithMetadataSymbolKey)
+
+/** @internal */
+export type PodWithMetadataTypeId = typeof PodWithMetadataTypeId
+
+/** @internal */
+export class PodWithMetadata extends Data.Class<{
+  [PodWithMetadataTypeId]: PodWithMetadataTypeId
+  pod: Pod.Pod
+  registered: number
+}> {}
+
+/** @internal */
+export function make(pod: Pod.Pod, registered: number): PodWithMetadata {
+  return new PodWithMetadata({ [PodWithMetadataTypeId]: PodWithMetadataTypeId, pod, registered })
+}
+
+/** @internal */
+export function isPodWithMetadata(value: unknown): value is PodWithMetadata {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    PodWithMetadataTypeId in value &&
+    value[PodWithMetadataTypeId] === PodWithMetadataTypeId
+  )
+}
+
+/** @internal */
+export function extractVersion(pod: PodWithMetadata): List.List<number> {
+  return pipe(
+    List.fromIterable(pod.pod.version.split(".")),
+    List.map((_) => parseInt(_, 10))
+  )
+}
+
+/** @internal */
+export function compareVersion(a: List.List<number>, b: List.List<number>): 0 | 1 | -1 {
+  let restA = a
+  let restB = b
+  while (List.size(restA) > 0 || List.size(restB) > 0) {
+    const numA = pipe(
+      List.head(restA),
+      Option.getOrElse(() => 0)
+    )
+    const numB = pipe(
+      List.head(restB),
+      Option.getOrElse(() => 0)
+    )
+
+    if (numA < numB) return -1
+    if (numB > numA) return 1
+    restA = pipe(
+      List.tail(restA),
+      Option.getOrElse(() => List.empty())
+    )
+    restB = pipe(
+      List.tail(restB),
+      Option.getOrElse(() => List.empty())
+    )
+  }
+  return 0
+}

package/src/internal/pods.ts

@@ -0,0 +1,29 @@
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type * as Pods from "../Pods.js"
+
+/** @internal */
+const PodsSymbolKey = "@effect/cluster/Pods"
+
+/** @internal */
+export const PodsTypeId: Pods.PodsTypeId = Symbol.for(PodsSymbolKey) as Pods.PodsTypeId
+
+/** @internal */
+export const podsTag = Context.GenericTag<Pods.Pods>(PodsSymbolKey)
+
+/** @internal */
+export function make(
+  args: Omit<Pods.Pods, Pods.PodsTypeId>
+): Pods.Pods {
+  return { [PodsTypeId]: PodsTypeId, ...args }
+}
+
+/** @internal */
+export const noop = Layer.succeed(podsTag, {
+  [PodsTypeId]: PodsTypeId,
+  assignShards: () => Effect.void,
+  unassignShards: () => Effect.void,
+  ping: () => Effect.void,
+  sendAndGetState: () => Effect.never
+})

package/src/internal/podsHealth.ts

@@ -0,0 +1,39 @@
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import * as Pods from "../Pods.js"
+import type * as PodsHealth from "../PodsHealth.js"
+
+/** @internal */
+const PodsHealthSymbolKey = "@effect/cluster/PodsHealth"
+
+/** @internal */
+export const PodsHealthTypeId: PodsHealth.PodsHealthTypeId = Symbol.for(
+  PodsHealthSymbolKey
+) as PodsHealth.PodsHealthTypeId
+
+/** @internal */
+export const podsHealthTag = Context.GenericTag<PodsHealth.PodsHealth>(PodsHealthSymbolKey)
+
+/** @internal */
+export function make(args: Omit<PodsHealth.PodsHealth, PodsHealth.PodsHealthTypeId>): PodsHealth.PodsHealth {
+  return Data.struct({ [PodsHealthTypeId]: PodsHealthTypeId, ...args })
+}
+
+/** @internal */
+export const noop = Layer.succeed(podsHealthTag, {
+  [PodsHealthTypeId]: PodsHealthTypeId,
+  isAlive: () => Effect.succeed(true)
+})
+
+/** @internal */
+export const local = Layer.effect(
+  podsHealthTag,
+  Effect.map(Pods.Pods, (podApi) =>
+    make({
+      isAlive: (address) => pipe(podApi.ping(address), Effect.option, Effect.map(Option.isSome))
+    }))
+)

package/src/internal/recipientBehaviour.ts

@@ -0,0 +1,133 @@
+import * as Deferred from "effect/Deferred"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as HashMap from "effect/HashMap"
+import * as Option from "effect/Option"
+import * as PrimaryKey from "effect/PrimaryKey"
+import * as Queue from "effect/Queue"
+import * as Ref from "effect/Ref"
+import type * as Message from "../Message.js"
+import * as MessageState from "../MessageState.js"
+import * as PoisonPill from "../PoisonPill.js"
+import type * as RecipientBehaviour from "../RecipientBehaviour.js"
+import * as RecipientBehaviourContext from "../RecipientBehaviourContext.js"
+
+/** @internal  */
+export function fromFunctionEffect<Msg extends Message.Message.Any, R>(
+  handler: (
+    entityId: string,
+    message: Msg
+  ) => Effect.Effect<MessageState.MessageState<Message.Message.Exit<Msg>>, never, R>
+): RecipientBehaviour.RecipientBehaviour<Msg, R> {
+  return Effect.flatMap(RecipientBehaviourContext.entityId, (entityId) =>
+    pipe(
+      Effect.context<R>(),
+      Effect.map((context) => (message: Msg) =>
+        pipe(
+          handler(entityId, message),
+          Effect.provide(context)
+        )
+      )
+    ))
+}
+
+/** @internal  */
+export function fromFunctionEffectStateful<S, R, Msg extends Message.Message.Any, R2>(
+  initialState: (entityId: string) => Effect.Effect<S, never, R>,
+  handler: (
+    entityId: string,
+    message: Msg,
+    stateRef: Ref.Ref<S>
+  ) => Effect.Effect<MessageState.MessageState<Message.Message.Exit<Msg>>, never, R2>
+): RecipientBehaviour.RecipientBehaviour<Msg, R | R2> {
+  return Effect.flatMap(RecipientBehaviourContext.entityId, (entityId) =>
+    pipe(
+      initialState(entityId),
+      Effect.flatMap(Ref.make),
+      Effect.flatMap((stateRef) =>
+        pipe(
+          Effect.context<R2>(),
+          Effect.map((context) => (message: Msg) =>
+            pipe(
+              handler(entityId, message, stateRef),
+              Effect.provide(context)
+            )
+          )
+        )
+      )
+    ))
+}
+
+/** @internal */
+export function fromInMemoryQueue<Msg extends Message.Message.Any, R>(
+  handler: (
+    entityId: string,
+    dequeue: Queue.Dequeue<Msg | PoisonPill.PoisonPill>,
+    processed: <A extends Msg>(
+      message: A,
+      value: Option.Option<Message.Message.Exit<A>>
+    ) => Effect.Effect<void>
+  ) => Effect.Effect<void, never, R>
+): RecipientBehaviour.RecipientBehaviour<Msg, R> {
+  return Effect.gen(function*(_) {
+    const entityId = yield* _(RecipientBehaviourContext.entityId)
+    const messageStates = yield* _(Ref.make(HashMap.empty<string, MessageState.MessageState<any>>()))
+
+    function updateMessageState(message: Msg, state: MessageState.MessageState<any>) {
+      return pipe(Ref.update(messageStates, HashMap.set(PrimaryKey.value(message), state)), Effect.as(state))
+    }
+
+    function getMessageState(message: Msg) {
+      return pipe(
+        Ref.get(messageStates),
+        Effect.map(HashMap.get(PrimaryKey.value(message)))
+      )
+    }
+
+    function reply<A extends Msg>(message: A, reply: Option.Option<Message.Message.Exit<A>>) {
+      return updateMessageState(message, MessageState.Processed(reply))
+    }
+
+    return yield* _(pipe(
+      Deferred.make<boolean>(),
+      Effect.flatMap((shutdownCompleted) =>
+        pipe(
+          Effect.acquireRelease(
+            Queue.unbounded<Msg | PoisonPill.PoisonPill>(),
+            (queue) =>
+              pipe(
+                PoisonPill.make,
+                Effect.flatMap((msg) => Queue.offer(queue, msg)),
+                Effect.zipLeft(Deferred.await(shutdownCompleted)),
+                Effect.uninterruptible
+              )
+          ),
+          Effect.tap((queue) =>
+            pipe(
+              Effect.logDebug("Behaviour started."),
+              Effect.zipRight(handler(entityId, queue, reply)),
+              Effect.ensuring(Deferred.succeed(shutdownCompleted, true)),
+              Effect.zipRight(Effect.logDebug("Behaviour exited.")),
+              Effect.annotateLogs("entityId", entityId),
+              Effect.forkDaemon
+            )
+          ),
+          Effect.map((queue) => (message: Msg) => {
+            return pipe(
+              getMessageState(message),
+              Effect.flatMap(Option.match({
+                onNone: () =>
+                  pipe(
+                    Queue.offer(queue, message),
+                    Effect.zipRight(updateMessageState(message, MessageState.Acknowledged))
+                  ),
+                onSome: (state) => Effect.succeed(state)
+              }))
+            )
+          }),
+          Effect.annotateLogs("entityId", entityId)
+        )
+      )
+    ))
+  })
+}

package/src/internal/recipientBehaviourContext.ts

@@ -0,0 +1,70 @@
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import type * as Message from "../Message.js"
+import type * as RecipientAddress from "../RecipientAddress.js"
+import type * as RecipientBehaviourContext from "../RecipientBehaviourContext.js"
+import type * as RecipientType from "../RecipientType.js"
+import type * as ShardId from "../ShardId.js"
+
+/** @internal */
+const RecipientBehaviourContextSymbolKey = "@effect/cluster/RecipientBehaviourContext"
+
+/** @internal */
+export const RecipientBehaviourContextTypeId: RecipientBehaviourContext.RecipientBehaviourContextTypeId = Symbol.for(
+  RecipientBehaviourContextSymbolKey
+) as RecipientBehaviourContext.RecipientBehaviourContextTypeId
+
+/** @internal */
+export const recipientBehaviourContextTag = Context.GenericTag<RecipientBehaviourContext.RecipientBehaviourContext>(
+  RecipientBehaviourContextSymbolKey
+)
+
+/** @internal */
+export function make(
+  args: Omit<
+    RecipientBehaviourContext.RecipientBehaviourContext,
+    RecipientBehaviourContext.RecipientBehaviourContextTypeId
+  >
+): RecipientBehaviourContext.RecipientBehaviourContext {
+  return ({ [RecipientBehaviourContextTypeId]: RecipientBehaviourContextTypeId, ...args })
+}
+
+/** @internal */
+export const recipientAddress: Effect.Effect<
+  RecipientAddress.RecipientAddress,
+  never,
+  RecipientBehaviourContext.RecipientBehaviourContext
+> = Effect.map(
+  recipientBehaviourContextTag,
+  (_) => _.recipientAddress
+)
+
+/** @internal */
+export const entityId: Effect.Effect<string, never, RecipientBehaviourContext.RecipientBehaviourContext> = Effect.map(
+  recipientAddress,
+  (_) => _.entityId
+)
+
+/** @internal */
+export const shardId: Effect.Effect<ShardId.ShardId, never, RecipientBehaviourContext.RecipientBehaviourContext> =
+  Effect.map(
+    recipientBehaviourContextTag,
+    (_) => _.shardId
+  )
+
+/** @internal */
+export const recipientType: Effect.Effect<
+  RecipientType.RecipientType<Message.Message.Any>,
+  never,
+  RecipientBehaviourContext.RecipientBehaviourContext
+> = Effect.map(
+  recipientBehaviourContextTag,
+  (_) => _.recipientType
+)
+
+/** @internal */
+export const forkShutdown: Effect.Effect<void, never, RecipientBehaviourContext.RecipientBehaviourContext> = Effect
+  .flatMap(
+    recipientBehaviourContextTag,
+    (_) => _.forkShutdown
+  )

package/src/internal/serialization.ts

@@ -0,0 +1,59 @@
+import * as Schema from "@effect/schema/Schema"
+import * as TreeFormatter from "@effect/schema/TreeFormatter"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import type * as Serialization from "../Serialization.js"
+import * as SerializedMessage from "../SerializedMessage.js"
+import * as ShardingException from "../ShardingException.js"
+
+/** @internal */
+const SerializationSymbolKey = "@effect/cluster/Serialization"
+
+/** @internal */
+export const SerializationTypeId: Serialization.SerializationTypeId = Symbol.for(
+  SerializationSymbolKey
+) as Serialization.SerializationTypeId
+
+/** @internal */
+export const serializationTag = Context.GenericTag<Serialization.Serialization>(SerializationSymbolKey)
+
+/** @internal */
+function jsonStringify<A, I>(value: A, schema: Schema.Schema<A, I>) {
+  return pipe(
+    value,
+    Schema.encode(schema),
+    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) })),
+    Effect.map((_) => JSON.stringify(_))
+  )
+}
+
+/** @internal */
+function jsonParse<A, I>(value: string, schema: Schema.Schema<A, I>) {
+  return pipe(
+    Effect.sync(() => JSON.parse(value)),
+    Effect.flatMap(Schema.decode(schema)),
+    Effect.mapError((e) => new ShardingException.SerializationException({ error: TreeFormatter.formatError(e) }))
+  )
+}
+
+/** @internal */
+export function make(
+  args: Omit<Serialization.Serialization, Serialization.SerializationTypeId>
+): Serialization.Serialization {
+  return ({ ...args, [SerializationTypeId]: SerializationTypeId })
+}
+
+/** @internal */
+export const json: Layer.Layer<Serialization.Serialization> = Layer.succeed(
+  serializationTag,
+  make({
+    encode: (schema, message) =>
+      pipe(
+        jsonStringify(message, schema),
+        Effect.map(SerializedMessage.make)
+      ),
+    decode: (schema, body) => jsonParse(body.value, schema)
+  })
+)