@effect/cluster 0.28.4 → 0.29.1

package/src/Broadcaster.ts

@@ -1,48 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Effect from "effect/Effect"
-import type * as Either from "effect/Either"
-import type * as HashMap from "effect/HashMap"
-import type * as Message from "./Message.js"
-import type * as PodAddress from "./PodAddress.js"
-import type * as ShardingException from "./ShardingException.js"
-
-/**
- * An interface to communicate with a remote broadcast receiver
- *
- * @since 1.0.0
- * @category models
- */
-export interface Broadcaster<Msg extends Message.Message.Any> {
-  /**
-   * Broadcast a message without waiting for a response (fire and forget)
-   *
-   * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely.
-   * @since 1.0.0
-   */
-  readonly broadcastDiscard: (
-    topicId: string
-  ) => (message: Msg) => Effect.Effect<void, ShardingException.ShardingException>
-
-  /**
-   * Broadcast a message and wait for a response from each consumer
-   *
-   * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely
-   * @since 1.0.0
-   */
-  readonly broadcast: (
-    topicId: string
-  ) => <A extends Msg>(
-    message: A
-  ) => Effect.Effect<
-    HashMap.HashMap<
-      PodAddress.PodAddress,
-      Either.Either<
-        ShardingException.ShardingException | Message.Message.Error<A>,
-        Message.Message.Success<A>
-      >
-    >,
-    ShardingException.ShardingException
-  >
-}

package/src/ManagerConfig.ts

@@ -1,67 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as ConfigError from "effect/ConfigError"
-import type * as Context from "effect/Context"
-import type * as Duration from "effect/Duration"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/managerConfig.js"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const ManagerConfigTypeId: unique symbol = internal.ManagerConfigTypeId
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type ManagerConfigTypeId = typeof ManagerConfigTypeId
-
-/**
- * This is the Shard Manager configuration.
- *
- * @param numberOfShards number of shards (see documentation on how to choose this), should be same on all nodes
- * @param apiPort port to expose the GraphQL API
- * @param rebalanceInterval interval for regular rebalancing of shards
- * @param rebalanceRetryInterval retry interval for rebalancing when some shards failed to be rebalanced
- * @param pingTimeout time to wait for a pod to respond to a ping request
- * @param persistRetryInterval retry interval for persistence of pods and shard assignments
- * @param persistRetryCount max retry count for persistence of pods and shard assignments
- * @param rebalanceRate max ratio of shards to rebalance at once
- * @since 1.0.0
- * @category models
- */
-export interface ManagerConfig {
-  readonly numberOfShards: number
-  readonly apiPort: number
-  readonly rebalanceInterval: Duration.Duration
-  readonly rebalanceRetryInterval: Duration.Duration
-  readonly pingTimeout: Duration.Duration
-  readonly persistRetryInterval: Duration.Duration
-  readonly persistRetryCount: number
-  readonly rebalanceRate: number
-}
-
-/**
- * @since 1.0.0
- * @category context
- */
-export const ManagerConfig: Context.Tag<ManagerConfig, ManagerConfig> = internal.managerConfigTag
-
-/**
- * Uses the default as ManagerConfig.
- *
- * @since 1.0.0
- * @category utils
- */
-export const defaults: Layer.Layer<ManagerConfig> = internal.defaults
-
-/**
- * Reads the ManagerConfig from the provided Config.
- *
- * @since 1.0.0
- * @category constructors
- */
-export const fromConfig: Layer.Layer<ManagerConfig, ConfigError.ConfigError, never> = internal.fromConfig

package/src/MessageState.ts

@@ -1,126 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Effect from "effect/Effect"
-import type * as Schema from "effect/Schema"
-import * as internal from "./internal/messageState.js"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const MessageStateTypeId: unique symbol = internal.MessageStateTypeId
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type MessageStateTypeId = typeof MessageStateTypeId
-
-/**
- * A message state given to just acknowledged messages.
- * This state tells the sender that the receiver has received the message and will eventually process it later.
- *
- * @since 1.0.0
- * @category models
- */
-export interface MessageStateAcknowledged {
-  readonly [MessageStateTypeId]: MessageStateTypeId
-  readonly _tag: "@effect/cluster/MessageState/Acknowledged"
-}
-
-/**
- * A message state given to processed messages.
- * This state tells the sender that the receiver has already received and processed the message.
- * This will also tell the sender the result for this message.
- *
- * @since 1.0.0
- * @category models
- */
-export interface MessageStateProcessed<A> {
-  readonly [MessageStateTypeId]: MessageStateTypeId
-  readonly _tag: "@effect/cluster/MessageState/Processed"
-  readonly result: A
-}
-
-/**
- * Once a Message is sent to an entity to be processed,
- * the state of that message over that entity is either Acknoledged (not yet processed) or Processed.
- *
- * @since 1.0.0
- * @category models
- */
-export type MessageState<A> = MessageStateAcknowledged | MessageStateProcessed<A>
-
-/**
- * @since 1.0.0
- * @category models
- */
-export namespace MessageState {
-  /**
-   * @since 1.0.0
-   * @category models
-   */
-  export type Encoded<I> = {
-    readonly "@effect/cluster/MessageState": "@effect/cluster/MessageState"
-    readonly _tag: "@effect/cluster/MessageState/Acknowledged"
-  } | {
-    readonly result: I
-    readonly "@effect/cluster/MessageState": "@effect/cluster/MessageState"
-    readonly _tag: "@effect/cluster/MessageState/Processed"
-  }
-}
-
-/**
- * Ensures that the given value is a MessageState
- *
- * @since 1.0.0
- * @category utils
- */
-export const isMessageState = internal.isMessageState
-
-/**
- * Match over the possible states of a MessageState
- *
- * @since 1.0.0
- * @category utils
- */
-export const match = internal.match
-
-/**
- * Constructs an AcknowledgedMessageState.
- *
- * @since 1.0.0
- * @category constructors
- */
-export const Acknowledged: MessageStateAcknowledged = internal.Acknowledged
-
-/**
- * Constructs a ProcessedMessageState from the result of the message being processed.
- *
- * @since 1.0.0
- * @category constructors
- */
-export const Processed: <A>(result: A) => MessageStateProcessed<A> = internal.Processed
-
-/**
- * Effectfully transform the <A> type of the MessageState<A>.
- *
- * @since 1.0.0
- * @category utils
- */
-export const mapEffect: <A, B, R, E>(
-  value: MessageState<A>,
-  fn: (value: A) => Effect.Effect<B, E, R>
-) => Effect.Effect<MessageState<B>, E, R> = internal.mapEffect
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schema: <A, I>(
-  result: Schema.Schema<A, I>
-) => Schema.Schema<
-  MessageState<A>,
-  MessageState.Encoded<I>
-> = internal.schema

package/src/Messenger.ts

@@ -1,40 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Effect from "effect/Effect"
-import type * as Message from "./Message.js"
-import type * as ShardingException from "./ShardingException.js"
-
-/**
- * An interface to communicate with a remote entity.
- *
- * @tparam Msg the type of message that can be sent to this entity type
- * @since 1.0.0
- * @category models
- */
-export interface Messenger<Msg extends Message.Message.Any> {
-  /**
-   * Send a message without waiting for a response (fire and forget)
-   *
-   * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely
-   *
-   * @since 1.0.0
-   */
-  sendDiscard(entityId: string): (message: Msg) => Effect.Effect<void, ShardingException.ShardingException>
-
-  /**
-   * Send a message and wait for a response.
-   *
-   * You can use Effect timeout to get send timeouts. The default behaviour is to send the message indifinetely
-   *
-   * @since 1.0.0
-   */
-  send(
-    entityId: string
-  ): <A extends Msg>(
-    message: A
-  ) => Effect.Effect<
-    Message.Message.Success<A>,
-    ShardingException.ShardingException | Message.Message.Error<A>
-  >
-}

package/src/Pod.ts

@@ -1,95 +0,0 @@
-/**
- * @since 1.0.0
- */
-import * as Schema from "effect/Schema"
-import { TypeIdSchema } from "./internal/utils.js"
-import * as PodAddress from "./PodAddress.js"
-
-/** @internal */
-const PodSymbolKey = "@effect/cluster/Pod"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const PodTypeId: unique symbol = Symbol.for(PodSymbolKey)
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type PodTypeId = typeof PodTypeId
-
-/** @internal */
-const PodTypeIdSchema = TypeIdSchema(PodSymbolKey, PodTypeId)
-
-/**
- * A pod is an application server that is able to run entities. A pod can run multiple entities,
- * but a single entity will live on a given pod at a time.
- * Since this is an application server, it needs to have an unique identifier where it's addressed (PodAddress),
- * and has a version of the application that's running on it.
- * Version is used during the rebalance phase to give priority to newer application servers and slowly kill older ones.
- *
- * @since 1.0.0
- * @category models
- */
-export class Pod extends Schema.Class<Pod>(PodSymbolKey)({
-  [PodTypeId]: Schema.propertySignature(PodTypeIdSchema).pipe(Schema.fromKey(PodSymbolKey)),
-  address: PodAddress.schema,
-  version: Schema.String
-}) {
-  /**
-   * @since 1.0.0
-   */
-  toString() {
-    return `Pod(${this.address}, ${this.version})`
-  }
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export namespace Pod {
-  /**
-   * This is the shape that a Pod is represented over the wire.
-   *
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Encoded extends Schema.Schema.Encoded<typeof Pod> {}
-}
-
-/**
- * Given a value, ensures that it's a valid Pod.
- *
- * @since 1.0.0
- * @category utils
- */
-export function isPod(value: unknown): value is Pod {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    PodTypeId in value &&
-    value[PodTypeId] === PodTypeId
-  )
-}
-
-/**
- * Constructs a Pod from it's identifing PodAddress and application server version.
- *
- * @since 1.0.0
- * @category constructors
- */
-export function make(address: PodAddress.PodAddress, version: string): Pod {
-  return new Pod({ [PodTypeId]: PodTypeId, address, version })
-}
-
-/**
- * @since 1.0.0
- * @category schema
- */
-export const schema: Schema.Schema<
-  Pod,
-  Pod.Encoded
-> = Schema.asSchema(Pod)

package/src/PodAddress.ts

@@ -1,94 +0,0 @@
-/**
- * @since 1.0.0
- */
-import * as Schema from "effect/Schema"
-import { TypeIdSchema } from "./internal/utils.js"
-
-/** @internal */
-const PodAddressSymbolKey = "@effect/cluster/PodAddress"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const PodAddressTypeId: unique symbol = Symbol.for(PodAddressSymbolKey)
-
-/** @internal */
-export const PodAddressTypeIdSchema = TypeIdSchema(PodAddressSymbolKey, PodAddressTypeId)
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type PodAddressTypeId = typeof PodAddressTypeId
-
-/**
- * A PodAddress is a unique identifier of a Pod (application server).
- * It is conventially built by using an address and a port, so that messaging implementations may use directly the
- * PodAddress to know how to connect to the specific Pod.
- *
- * @since 1.0.0
- * @category models
- */
-export class PodAddress extends Schema.Class<PodAddress>(PodAddressSymbolKey)({
-  [PodAddressTypeId]: Schema.propertySignature(PodAddressTypeIdSchema).pipe(Schema.fromKey(PodAddressSymbolKey)),
-  host: Schema.String,
-  port: Schema.Number
-}) {
-  /**
-   * @since 1.0.0
-   */
-  toString() {
-    return `PodAddress(${this.host}:${this.port})`
-  }
-}
-
-/**
- * @since 1.0.0
- * @category models
- */
-export namespace PodAddress {
-  /**
-   * This is the shape one PodAddress has over the wire.
-   *
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Encoded extends Schema.Schema.Encoded<typeof PodAddress> {}
-}
-
-/**
- * Constructs a PodAddress from an host and a port.
- *
- * @since 1.0.0
- * @category constructors
- */
-export function make(host: string, port: number): PodAddress {
-  return new PodAddress({ [PodAddressTypeId]: PodAddressTypeId, host, port })
-}
-
-/**
- * Ensures that the given value is a valid PodAddress.
- *
- * @since 1.0.0
- * @category utils
- */
-export function isPodAddress(value: unknown): value is PodAddress {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    PodAddressTypeId in value &&
-    value[PodAddressTypeId] === PodAddressTypeId
-  )
-}
-
-/**
- * This is the schema for a PodAddress.
- *
- * @since 1.0.0
- * @category schema
- */
-export const schema: Schema.Schema<
-  PodAddress,
-  PodAddress.Encoded
-> = Schema.asSchema(PodAddress)

package/src/Pods.ts

@@ -1,100 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Context from "effect/Context"
-import type * as Effect from "effect/Effect"
-import type * as HashSet from "effect/HashSet"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/pods.js"
-import type * as MessageState from "./MessageState.js"
-import type * as PodAddress from "./PodAddress.js"
-import type * as SerializedEnvelope from "./SerializedEnvelope.js"
-import type * as SerializedMessage from "./SerializedMessage.js"
-import type * as ShardId from "./ShardId.js"
-import type * as ShardingException from "./ShardingException.js"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const PodsTypeId: unique symbol = internal.PodsTypeId
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type PodsTypeId = typeof PodsTypeId
-
-/**
- * An interface to communicate with remote pods.
- * This is used by the Shard Manager for assigning and unassigning shards.
- * This is also used by pods for internal communication (forward messages to each other).
- *
- * @since 1.0.0
- * @category models
- */
-export interface Pods {
-  /**
-   * @since 1.0.0
-   */
-  readonly [PodsTypeId]: PodsTypeId
-
-  /**
-   * Notify a pod that it was assigned a list of shards
-   * @since 1.0.0
-   */
-  readonly assignShards: (
-    pod: PodAddress.PodAddress,
-    shards: HashSet.HashSet<ShardId.ShardId>
-  ) => Effect.Effect<void, ShardingException.PodUnavailableException>
-
-  /**
-   * Notify a pod that it was unassigned a list of shards
-   * @since 1.0.0
-   */
-  readonly unassignShards: (
-    pod: PodAddress.PodAddress,
-    shards: HashSet.HashSet<ShardId.ShardId>
-  ) => Effect.Effect<void, ShardingException.PodUnavailableException>
-
-  /**
-   * Check that a pod is responsive
-   * @since 1.0.0
-   */
-  readonly ping: (pod: PodAddress.PodAddress) => Effect.Effect<void, ShardingException.PodUnavailableException>
-
-  /**
-   * Send a message to a pod and receive its message state
-   * @since 1.0.0
-   */
-  readonly sendAndGetState: (
-    pod: PodAddress.PodAddress,
-    envelope: SerializedEnvelope.SerializedEnvelope
-  ) => Effect.Effect<
-    MessageState.MessageState<SerializedMessage.SerializedMessage>,
-    ShardingException.ShardingException
-  >
-}
-
-/**
- * @since 1.0.0
- * @category context
- */
-export const Pods: Context.Tag<Pods, Pods> = internal.podsTag
-
-/**
- * Constructs a Pods service from its implementation
- *
- * @since 1.0.0
- * @category context
- */
-export const make: (args: Omit<Pods, typeof PodsTypeId>) => Pods = internal.make
-
-/**
- * A layer that creates a service that does nothing when called.
- * Useful for testing ShardManager or when using Sharding.local.
- *
- * @since 1.0.0
- * @category layers
- */
-export const noop: Layer.Layer<Pods> = internal.noop

package/src/PodsHealth.ts

@@ -1,74 +0,0 @@
-/**
- * @since 1.0.0
- */
-import type * as Context from "effect/Context"
-import type * as Effect from "effect/Effect"
-import type * as Layer from "effect/Layer"
-import * as internal from "./internal/podsHealth.js"
-import type * as PodAddress from "./PodAddress.js"
-import type * as Pods from "./Pods.js"
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export const PodsHealthTypeId: unique symbol = internal.PodsHealthTypeId
-
-/**
- * @since 1.0.0
- * @category symbols
- */
-export type PodsHealthTypeId = typeof PodsHealthTypeId
-
-/**
- * An interface to check a pod's health.
- * This is used when a pod is unresponsive, to check if it should be unassigned all its shards or not.
- * If the pod is alive, shards will not be unassigned because the pods might still be processing messages and might be responsive again.
- * If the pod is not alive, shards can be safely reassigned somewhere else.
- * A typical implementation for this is using k8s to check if the pod still exists.
- *
- * @since 1.0.0
- * @category models
- */
-export interface PodsHealth {
-  /**
-   * @since 1.0.0
-   */
-  readonly [PodsHealthTypeId]: PodsHealthTypeId
-
-  /**
-   * Check if a pod is still alive.
-   * @since 1.0.0
-   */
-  readonly isAlive: (podAddress: PodAddress.PodAddress) => Effect.Effect<boolean>
-}
-
-/**
- * Constructs a PodsHealth from its implementation
- *
- * @since 1.0.0
- * @category constructors
- */
-export const make: (args: Omit<PodsHealth, typeof PodsHealthTypeId>) => PodsHealth = internal.make
-
-/**
- * @since 1.0.0
- * @category context
- */
-export const PodsHealth: Context.Tag<PodsHealth, PodsHealth> = internal.podsHealthTag
-
-/**
- * A layer that considers pods as always alive.
- * This is useful for testing only.
- * @since 1.0.0
- * @category layers
- */
-export const noop: Layer.Layer<PodsHealth> = internal.noop
-
-/**
- * A layer that pings the pod directly to check if it's alive.
- * This is useful for developing and testing but not reliable in production.
- * @since 1.0.0
- * @category layers
- */
-export const local: Layer.Layer<PodsHealth, never, Pods.Pods> = internal.local