@effect/cluster 0.28.4 → 0.29.0

package/src/internal/recipientBehaviour.ts

@@ -1,133 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,63 +0,0 @@
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as ParseResult from "effect/ParseResult"
-import type * as Schema from "effect/Schema"
-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,
-    ParseResult.encode(schema),
-    Effect.mapError((issue) =>
-      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
-    ),
-    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(ParseResult.decode(schema)),
-    Effect.mapError((issue) =>
-      new ShardingException.SerializationException({ error: ParseResult.TreeFormatter.formatIssue(issue) })
-    )
-  )
-}
-
-/** @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)
-  })
-)

package/src/internal/shardManagerClient.ts

@@ -1,49 +0,0 @@
-import * as Context from "effect/Context"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as HashMap from "effect/HashMap"
-import * as Layer from "effect/Layer"
-import * as Option from "effect/Option"
-import * as PodAddress from "../PodAddress.js"
-import * as ShardId from "../ShardId.js"
-import * as ShardingConfig from "../ShardingConfig.js"
-import type * as ShardManagerClient from "../ShardManagerClient.js"
-
-/** @internal */
-const ShardManagerSymbolKey = "@effect/cluster/ShardManagerClient"
-
-/** @internal */
-export const ShardManagerClientTypeId: ShardManagerClient.ShardManagerClientTypeId = Symbol.for(
-  ShardManagerSymbolKey
-) as ShardManagerClient.ShardManagerClientTypeId
-
-/** @internal */
-export const shardManagerClientTag = Context.GenericTag<ShardManagerClient.ShardManagerClient>(ShardManagerSymbolKey)
-
-/** @internal */
-export function make(
-  args: Omit<ShardManagerClient.ShardManagerClient, ShardManagerClient.ShardManagerClientTypeId>
-): ShardManagerClient.ShardManagerClient {
-  return ({ [ShardManagerClientTypeId]: ShardManagerClientTypeId, ...args })
-}
-
-/** @internal */
-export const local = pipe(
-  Layer.effect(
-    shardManagerClientTag,
-    Effect.gen(function*() {
-      const config = yield* ShardingConfig.ShardingConfig
-      const pod = PodAddress.make(config.selfHost, config.shardingPort)
-      let shards = HashMap.empty<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>()
-      for (let i = 1; i <= config.numberOfShards; i++) {
-        shards = HashMap.set(shards, ShardId.make(i), Option.some(pod))
-      }
-      return make({
-        register: () => Effect.void,
-        unregister: () => Effect.void,
-        notifyUnhealthyPod: () => Effect.void,
-        getAssignments: Effect.succeed(shards)
-      })
-    })
-  )
-)

package/src/internal/shardManagerState.ts

@@ -1,80 +0,0 @@
-import { equals } from "effect/Equal"
-import { pipe } from "effect/Function"
-import * as HashMap from "effect/HashMap"
-import * as HashSet from "effect/HashSet"
-import * as List from "effect/List"
-import * as Option from "effect/Option"
-import type * as PodAddress from "../PodAddress.js"
-import * as ShardId from "../ShardId.js"
-import * as PodWithMetadata from "./podWithMetadata.js"
-
-/**
- * @since 1.0.0
- * @category models
- */
-export interface ShardManagerState {
-  readonly pods: HashMap.HashMap<PodAddress.PodAddress, PodWithMetadata.PodWithMetadata>
-  readonly shards: HashMap.HashMap<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>
-  readonly unassignedShards: HashSet.HashSet<ShardId.ShardId>
-  readonly averageShardsPerPod: ShardId.ShardId
-  readonly shardsPerPod: HashMap.HashMap<PodAddress.PodAddress, HashSet.HashSet<ShardId.ShardId>>
-  readonly maxVersion: Option.Option<List.List<number>>
-  readonly allPodsHaveMaxVersion: boolean
-}
-
-/**
- * @since 1.0.0
- * @category constructors
- */
-export function make(
-  pods: HashMap.HashMap<PodAddress.PodAddress, PodWithMetadata.PodWithMetadata>,
-  shards: HashMap.HashMap<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>
-): ShardManagerState {
-  const podVersions = pipe(
-    HashMap.values(pods),
-    List.fromIterable,
-    List.map(PodWithMetadata.extractVersion)
-  )
-  const maxVersion = pipe(
-    podVersions,
-    List.reduce(List.empty<number>(), (curr, a) => PodWithMetadata.compareVersion(curr, a) === -1 ? a : curr),
-    (result) => (List.size(result) === 0 ? Option.none() : Option.some(result))
-  )
-  const shardsPerPodPods = pipe(
-    HashMap.reduce(
-      shards,
-      HashMap.empty<PodAddress.PodAddress, HashSet.HashSet<ShardId.ShardId>>(),
-      (curr, optionPod, shardId) => {
-        if (Option.isNone(optionPod)) return curr
-        if (HashMap.has(curr, optionPod.value)) {
-          return HashMap.modify(curr, optionPod.value, HashSet.add(shardId))
-        } else {
-          return HashMap.set(curr, optionPod.value, HashSet.fromIterable([shardId]))
-        }
-      }
-    )
-  )
-  const shardsPerPod = pipe(
-    HashMap.map(pods, () => HashSet.empty<ShardId.ShardId>()),
-    HashMap.union(shardsPerPodPods)
-  )
-
-  const allPodsHaveMaxVersion = List.every(podVersions, (_) => equals(Option.some(_))(maxVersion))
-  return {
-    pods,
-    shards,
-    unassignedShards: pipe(
-      HashMap.filter(shards, (a, _) => Option.isNone(a)),
-      HashSet.fromIterable,
-      HashSet.map(([k, _]) => k)
-    ),
-    averageShardsPerPod: pipe(
-      HashMap.isEmpty(pods)
-        ? ShardId.make(0)
-        : ShardId.make(HashMap.size(shards) / HashMap.size(pods))
-    ),
-    shardsPerPod,
-    maxVersion,
-    allPodsHaveMaxVersion
-  }
-}