@effect/cluster 0.0.0-snapshot-d33d8b050b8e3c87dcde9587083e6c1cf733f72b

package/src/ShardingRegistrationEvent.ts

@@ -0,0 +1,62 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Message from "./Message.js"
+import type * as RecipientType from "./RecipientType.js"
+
+interface EntityRegistered<Msg extends Message.Message.Any> {
+  _tag: "EntityRegistered"
+  entityType: RecipientType.EntityType<Msg>
+}
+
+/**
+ * Constructs and event that occurs when a new EntityType gets registered.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function EntityRegistered<Msg extends Message.Message.Any>(
+  entityType: RecipientType.EntityType<Msg>
+): ShardingRegistrationEvent {
+  return ({ _tag: "EntityRegistered", entityType })
+}
+
+interface SingletonRegistered {
+  _tag: "SingletonRegistered"
+  name: string
+}
+
+/**
+ * Constructs a new event that occurs when a new Singleton is registered.
+ *
+ * @since 1.0.0
+ * @category constructors
+ */
+export function SingletonRegistered(name: string): ShardingRegistrationEvent {
+  return ({ _tag: "SingletonRegistered", name })
+}
+
+interface TopicRegistered<Msg extends Message.Message.Any> {
+  _tag: "TopicRegistered"
+  topicType: RecipientType.TopicType<Msg>
+}
+
+/**
+ * Constructs a new event that occurs when a topic is Registered.
+ * @since 1.0.0
+ * @category constructors
+ */
+export function TopicRegistered<Msg extends Message.Message.Any>(
+  topicType: RecipientType.TopicType<Msg>
+): ShardingRegistrationEvent {
+  return ({ _tag: "TopicRegistered", topicType })
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type ShardingRegistrationEvent =
+  | EntityRegistered<any>
+  | SingletonRegistered
+  | TopicRegistered<any>

package/src/Storage.ts

@@ -0,0 +1,92 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Context from "effect/Context"
+import type * as Effect from "effect/Effect"
+import type * as HashMap from "effect/HashMap"
+import type * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
+import type * as Stream from "effect/Stream"
+import * as internal from "./internal/storage.js"
+import type * as Pod from "./Pod.js"
+import type * as PodAddress from "./PodAddress.js"
+import type * as ShardId from "./ShardId.js"
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export const StorageTypeId: unique symbol = internal.StorageTypeId
+
+/**
+ * @since 1.0.0
+ * @category symbols
+ */
+export type StorageTypeId = typeof StorageTypeId
+
+/**
+ * The storage Service is responsible of persisting assignments and registered pods.
+ * The storage is expected to be shared among all pods, so it works also as communication of assignments between Pods.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Storage {
+  readonly [StorageTypeId]: StorageTypeId
+
+  /**
+   * Get the current state of shard assignments to pods
+   */
+  readonly getAssignments: Effect.Effect<HashMap.HashMap<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>>
+
+  /**
+   * Save the current state of shard assignments to pods
+   */
+  readonly saveAssignments: (
+    assignments: HashMap.HashMap<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>
+  ) => Effect.Effect<void>
+
+  /**
+   * A stream that will emit the state of shard assignments whenever it changes
+   */
+  readonly assignmentsStream: Stream.Stream<HashMap.HashMap<ShardId.ShardId, Option.Option<PodAddress.PodAddress>>>
+
+  /**
+   * Get the list of existing pods
+   */
+  readonly getPods: Effect.Effect<HashMap.HashMap<PodAddress.PodAddress, Pod.Pod>>
+
+  /**
+   * Save the list of existing pods
+   */
+  readonly savePods: (pods: HashMap.HashMap<PodAddress.PodAddress, Pod.Pod>) => Effect.Effect<void>
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: (args: Omit<Storage, typeof StorageTypeId>) => Storage = internal.make
+
+/**
+ * @since 1.0.0
+ * @category context
+ */
+export const Storage: Context.Tag<Storage, Storage> = internal.storageTag
+
+/**
+ * A layer that stores data in-memory.
+ * This is useful for testing with a single pod only.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const memory: Layer.Layer<Storage> = internal.memory
+
+/**
+ * A layer that does nothing, useful for testing.
+ *
+ * @since 1.0.0
+ * @category layers
+ */
+export const noop: Layer.Layer<Storage> = internal.noop

package/src/index.ts

@@ -0,0 +1,139 @@
+/**
+ * @since 1.0.0
+ */
+export * as AtLeastOnce from "./AtLeastOnce.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as AtLeastOnceStorage from "./AtLeastOnceStorage.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Broadcaster from "./Broadcaster.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ManagerConfig from "./ManagerConfig.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Message from "./Message.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as MessageState from "./MessageState.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Messenger from "./Messenger.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Pod from "./Pod.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as PodAddress from "./PodAddress.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Pods from "./Pods.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as PodsHealth from "./PodsHealth.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as PoisonPill from "./PoisonPill.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as RecipientAddress from "./RecipientAddress.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as RecipientBehaviour from "./RecipientBehaviour.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as RecipientBehaviourContext from "./RecipientBehaviourContext.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as RecipientType from "./RecipientType.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Serialization from "./Serialization.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as SerializedEnvelope from "./SerializedEnvelope.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as SerializedMessage from "./SerializedMessage.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardId from "./ShardId.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardManager from "./ShardManager.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardManagerClient from "./ShardManagerClient.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Sharding from "./Sharding.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardingConfig from "./ShardingConfig.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardingEvent from "./ShardingEvent.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardingException from "./ShardingException.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as ShardingRegistrationEvent from "./ShardingRegistrationEvent.js"
+
+/**
+ * @since 1.0.0
+ */
+export * as Storage from "./Storage.js"

package/src/internal/atLeastOnce.ts

@@ -0,0 +1,59 @@
+import type * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
+import * as AtLeastOnceStorage from "../AtLeastOnceStorage.js"
+import type * as Message from "../Message.js"
+import * as MessageState from "../MessageState.js"
+import type * as RecipientBehaviour from "../RecipientBehaviour.js"
+import * as RecipientBehaviourContext from "../RecipientBehaviourContext.js"
+import * as Sharding from "../Sharding.js"
+
+/** @internal */
+export function runPendingMessageSweeperScoped(
+  interval: Duration.Duration
+): Effect.Effect<void, never, AtLeastOnceStorage.AtLeastOnceStorage | Sharding.Sharding | Scope.Scope> {
+  return Effect.flatMap(AtLeastOnceStorage.AtLeastOnceStorage, (storage) =>
+    pipe(
+      Sharding.getAssignedShardIds,
+      Effect.flatMap((shardIds) =>
+        pipe(
+          storage.sweepPending(shardIds),
+          Stream.mapEffect((envelope) => Sharding.sendMessageToLocalEntityManagerWithoutRetries(envelope)),
+          Stream.runDrain
+        )
+      ),
+      Effect.delay(interval),
+      Effect.catchAllCause(Effect.logError),
+      Effect.forever,
+      Effect.forkScoped,
+      Effect.asVoid
+    ))
+}
+
+/** @internal */
+export function atLeastOnceRecipientBehaviour<Msg extends Message.Message.Any, R>(
+  fa: RecipientBehaviour.RecipientBehaviour<Msg, R>
+): RecipientBehaviour.RecipientBehaviour<Msg, R | AtLeastOnceStorage.AtLeastOnceStorage> {
+  return Effect.gen(function*(_) {
+    const storage = yield* _(AtLeastOnceStorage.AtLeastOnceStorage)
+    const entityId = yield* _(RecipientBehaviourContext.entityId)
+    const shardId = yield* _(RecipientBehaviourContext.shardId)
+    const recipientType = yield* _(RecipientBehaviourContext.recipientType)
+    const offer = yield* _(fa)
+    return <A extends Msg>(message: A) =>
+      pipe(
+        storage.upsert(recipientType, shardId, entityId, message),
+        Effect.zipRight(
+          pipe(
+            offer(message),
+            Effect.tap(MessageState.match({
+              onAcknowledged: () => Effect.void,
+              onProcessed: () => storage.markAsProcessed(recipientType, shardId, entityId, message)
+            }))
+          )
+        )
+      )
+  })
+}

package/src/internal/atLeastOnceStorage.ts

@@ -0,0 +1,218 @@
+import * as Schema from "@effect/schema/Schema"
+import * as SqlClient from "@effect/sql/SqlClient"
+import type * as SqlError from "@effect/sql/SqlError"
+import * as SqlResolver from "@effect/sql/SqlResolver"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as PrimaryKey from "effect/PrimaryKey"
+import * as Stream from "effect/Stream"
+import type * as AtLeastOnceStorage from "../AtLeastOnceStorage.js"
+import * as RecipientAddress from "../RecipientAddress.js"
+import type * as Serialization from "../Serialization.js"
+import * as SerializedEnvelope from "../SerializedEnvelope.js"
+import * as SerializedMessage from "../SerializedMessage.js"
+import * as InternalSerialization from "./serialization.js"
+
+/** @internal */
+const SymbolKey = "@effect/cluster/AtLeastOnceStorage"
+
+/** @internal */
+export const TypeId: AtLeastOnceStorage.TypeId = Symbol.for(
+  SymbolKey
+) as AtLeastOnceStorage.TypeId
+
+/** @internal */
+export const atLeastOnceStorageTag: Context.Tag<
+  AtLeastOnceStorage.AtLeastOnceStorage,
+  AtLeastOnceStorage.AtLeastOnceStorage
+> = Context.GenericTag<AtLeastOnceStorage.AtLeastOnceStorage>(SymbolKey)
+
+const make = ({ table }: AtLeastOnceStorage.AtLeastOnceStorage.MakeOptions): Effect.Effect<
+  AtLeastOnceStorage.AtLeastOnceStorage,
+  SqlError.SqlError,
+  SqlClient.SqlClient | Serialization.Serialization
+> =>
+  Effect.gen(function*() {
+    const sql = yield* SqlClient.SqlClient
+    const serialization = yield* InternalSerialization.serializationTag
+
+    yield* sql.onDialect({
+      mssql: () =>
+        sql`
+          IF OBJECT_ID(N'${sql.literal(table)}', N'U') IS NULL
+          CREATE TABLE ${sql(table)} (
+            recipient_name VARCHAR(255) NOT NULL,
+            shard_id INT NOT NULL DEFAULT 0,
+            entity_id VARCHAR(255) NOT NULL,
+            message_id VARCHAR(255) NOT NULL,
+            message_body TEXT NOT NULL,
+            processed BIT NOT NULL DEFAULT 0,
+            CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
+              WITH (IGNORE_DUP_KEY = ON)
+          )
+        `,
+      mysql: () =>
+        sql`
+          CREATE TABLE IF NOT EXISTS ${sql(table)} (
+            recipient_name VARCHAR(255) NOT NULL,
+            shard_id INT NOT NULL DEFAULT 0,
+            entity_id VARCHAR(255) NOT NULL,
+            message_id VARCHAR(255) NOT NULL,
+            message_body TEXT NOT NULL,
+            processed BOOLEAN NOT NULL DEFAULT FALSE,
+            CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
+          )
+        `,
+      pg: () =>
+        Effect.catchAll(sql`SELECT ${table}::regclass`, () =>
+          sql`
+            CREATE TABLE ${sql(table)} (
+              recipient_name VARCHAR(255) NOT NULL,
+              shard_id INT NOT NULL DEFAULT 0,
+              entity_id VARCHAR(255) NOT NULL,
+              message_id VARCHAR(255) NOT NULL,
+              message_body TEXT NOT NULL,
+              processed BOOLEAN NOT NULL DEFAULT FALSE,
+              CONSTRAINT ${sql(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
+            )
+          `),
+      sqlite: () =>
+        sql`
+          CREATE TABLE IF NOT EXISTS ${sql.literal(table)} (
+            recipient_name VARCHAR(255) NOT NULL,
+            shard_id INT NOT NULL DEFAULT (0),
+            entity_id VARCHAR(255) NOT NULL,
+            message_id VARCHAR(255) NOT NULL,
+            message_body CLOB NOT NULL,
+            processed BOOLEAN NOT NULL DEFAULT (0),
+            CONSTRAINT ${sql.literal(table)}_pkey PRIMARY KEY (recipient_name, entity_id, message_id)
+          )
+        `
+    })
+
+    const UpsertEntryResolver = yield* SqlResolver.void("UpsertEntry", {
+      Request: Schema.Struct({
+        recipient_name: Schema.String,
+        shard_id: Schema.Number,
+        entity_id: Schema.String,
+        message_id: Schema.String,
+        message_body: Schema.String
+      }),
+      execute: (requests) =>
+        sql.onDialect({
+          mssql: () =>
+            sql`
+              INSERT INTO ${sql(table)}
+              ${sql.insert(requests)}
+            `,
+          mysql: () =>
+            sql`
+              INSERT INTO ${sql(table)}
+              ${sql.insert(requests)}
+              ON DUPLICATE KEY UPDATE
+                recipient_name = recipient_name,
+                entity_id = entity_id,
+                message_id = message_id
+            `,
+          pg: () =>
+            sql`
+              INSERT INTO ${sql(table)}
+              ${sql.insert(requests)}
+              ON CONFLICT ON CONSTRAINT ${sql(table)}_pkey DO NOTHING
+            `,
+          sqlite: () =>
+            sql`
+              INSERT INTO ${sql(table)}
+              ${sql.insert(requests)}
+              ON CONFLICT (recipient_name, entity_id, message_id) DO NOTHING
+            `
+        })
+    })
+
+    const SweepPendingResolver = yield* SqlResolver.ordered("SweepPending", {
+      Request: Schema.Number,
+      Result: Schema.Struct({
+        shard_id: Schema.Number,
+        entity_id: Schema.String,
+        message_id: Schema.String,
+        recipient_name: Schema.String,
+        message_body: Schema.String
+      }),
+      execute: (shard_ids) =>
+        sql`
+          SELECT
+            shard_id,
+            entity_id,
+            message_id,
+            recipient_name,
+            message_body
+          FROM ${sql(table)}
+          WHERE ${
+          sql.and([
+            sql`processed = ${false}`,
+            sql.in("shard_id", shard_ids)
+          ])
+        }
+        `
+    })
+
+    return {
+      [TypeId]: TypeId,
+      upsert: (recipientType, shardId, entityId, message) =>
+        serialization.encode(recipientType.schema, message).pipe(
+          Effect.flatMap(
+            (message_body) =>
+              UpsertEntryResolver.execute({
+                recipient_name: recipientType.name,
+                shard_id: shardId.value,
+                entity_id: entityId,
+                message_id: PrimaryKey.value(message),
+                message_body: message_body.value
+              })
+          ),
+          Effect.catchAllCause(Effect.logError)
+        ),
+      markAsProcessed: (recipientType, _shardId, entityId, message) => {
+        return sql`
+          UPDATE ${sql(table)}
+          SET ${
+          sql.onDialectOrElse({
+            pg: () => sql.update({ processed: "TRUE" }),
+            orElse: () => sql.update({ processed: 1 })
+          })
+        }
+          WHERE ${
+          sql.and([
+            sql`recipient_name = ${recipientType.name}`,
+            sql`entity_id = ${entityId}`,
+            sql`message_id = ${PrimaryKey.value(message)}`
+          ])
+        }`.pipe(Effect.catchAllCause(Effect.logError))
+      },
+      sweepPending: (shardIds) =>
+        Effect.forEach(shardIds, (id) =>
+          Effect.withRequestCaching(true)(
+            SweepPendingResolver.execute(id.value)
+          ), {
+          batching: true
+        }).pipe(
+          Effect.orDie,
+          Stream.fromIterableEffect,
+          Stream.map((entry) =>
+            SerializedEnvelope.make(
+              RecipientAddress.makeRecipientAddress(entry.recipient_name, entry.entity_id),
+              entry.message_id,
+              SerializedMessage.make(entry.message_body)
+            )
+          )
+        )
+    }
+  })
+
+/** @internal */
+export const layer = (options: AtLeastOnceStorage.AtLeastOnceStorage.MakeOptions): Layer.Layer<
+  AtLeastOnceStorage.AtLeastOnceStorage,
+  SqlError.SqlError,
+  SqlClient.SqlClient | Serialization.Serialization
+> => Layer.effect(atLeastOnceStorageTag, make(options))