@effect/cluster 0.28.3 → 0.29.0

package/src/Envelope.ts

@@ -0,0 +1,352 @@
+/**
+ * @since 1.0.0
+ */
+import * as Headers from "@effect/platform/Headers"
+import type * as Rpc from "@effect/rpc/Rpc"
+import * as Predicate from "effect/Predicate"
+import * as PrimaryKey from "effect/PrimaryKey"
+import type { ReadonlyRecord } from "effect/Record"
+import * as Schema from "effect/Schema"
+import { EntityAddress, EntityAddressFromSelf } from "./EntityAddress.js"
+import { type Snowflake, SnowflakeFromString } from "./Snowflake.js"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = Symbol.for("@effect/cluster/Envelope")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export type Envelope<R extends Rpc.Any> = Request<R> | AckChunk | Interrupt
+
+/**
+ * @since 1.0.0
+ */
+export declare namespace Envelope {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Any = Envelope<any>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Encoded = Request.Encoded | typeof AckChunk.Encoded | typeof Interrupt.Encoded
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type PartialEncoded = Request.PartialEncoded | AckChunk | Interrupt
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Request<in out Rpc extends Rpc.Any> {
+  readonly [TypeId]: TypeId
+  readonly _tag: "Request"
+  readonly requestId: Snowflake
+  readonly address: EntityAddress
+  readonly tag: Rpc.Tag<Rpc>
+  readonly payload: Rpc.Payload<Rpc>
+  readonly headers: Headers.Headers
+  readonly traceId: string
+  readonly spanId: string
+  readonly sampled: boolean
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class AckChunk extends Schema.TaggedClass<AckChunk>("@effect/cluster/Envelope/AckChunk")("AckChunk", {
+  id: SnowflakeFromString,
+  address: EntityAddress,
+  requestId: SnowflakeFromString,
+  replyId: SnowflakeFromString
+}) {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: TypeId = TypeId
+
+  /**
+   * @since 1.0.0
+   */
+  withRequestId(requestId: Snowflake): AckChunk {
+    return new AckChunk({
+      ...this,
+      requestId
+    })
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export class Interrupt extends Schema.TaggedClass<Interrupt>("@effect/cluster/Envelope/Interrupt")("Interrupt", {
+  id: SnowflakeFromString,
+  address: EntityAddress,
+  requestId: SnowflakeFromString
+}) {
+  /**
+   * @since 1.0.0
+   */
+  readonly [TypeId]: TypeId = TypeId
+
+  /**
+   * @since 1.0.0
+   */
+  withRequestId(requestId: Snowflake): Interrupt {
+    return new Interrupt({
+      ...this,
+      requestId
+    })
+  }
+}
+
+/**
+ * @since 1.0.0
+ */
+export declare namespace Request {
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Any = Request<any>
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface Encoded {
+    readonly _tag: "Request"
+    readonly requestId: string
+    readonly address: typeof EntityAddress.Encoded
+    readonly tag: string
+    readonly payload: unknown
+    readonly headers: ReadonlyRecord<string, string>
+    readonly traceId: string
+    readonly spanId: string
+    readonly sampled: boolean
+  }
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export interface PartialEncoded {
+    readonly _tag: "Request"
+    readonly requestId: Snowflake
+    readonly address: EntityAddress
+    readonly tag: string
+    readonly payload: unknown
+    readonly headers: Headers.Headers
+    readonly traceId: string
+    readonly spanId: string
+    readonly sampled: boolean
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category refinements
+ */
+export const isEnvelope = (u: unknown): u is Envelope<any> => Predicate.hasProperty(u, TypeId)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeRequest = <Rpc extends Rpc.Any>(
+  options: {
+    readonly requestId: Snowflake
+    readonly address: EntityAddress
+    readonly tag: Rpc.Tag<Rpc>
+    readonly payload: Rpc.Payload<Rpc>
+    readonly headers: Headers.Headers
+    readonly traceId: string
+    readonly spanId: string
+    readonly sampled: boolean
+  }
+): Request<Rpc> => ({
+  [TypeId]: TypeId,
+  _tag: "Request",
+  requestId: options.requestId,
+  tag: options.tag,
+  address: options.address,
+  payload: options.payload,
+  headers: options.headers,
+  traceId: options.traceId,
+  spanId: options.spanId,
+  sampled: options.sampled
+})
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const EnvelopeFromSelf: Schema.Schema<
+  Envelope.Any,
+  Envelope.Any
+> = Schema.declare(isEnvelope, {
+  identifier: "Envelope"
+})
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const RequestFromSelf: Schema.Schema<
+  Request.Any,
+  Request.Any
+> = Schema.declare((u): u is Request.Any => isEnvelope(u) && u._tag === "Request", {
+  identifier: "Envelope"
+})
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const PartialEncodedRequest: Schema.Struct<
+  {
+    _tag: Schema.Literal<["Request"]>
+    requestId: Schema.Schema<Snowflake, string>
+    address: typeof EntityAddress
+    tag: typeof Schema.String
+    payload: typeof Schema.Unknown
+    headers: Schema.Schema<Headers.Headers, ReadonlyRecord<string, string>>
+    traceId: typeof Schema.String
+    spanId: typeof Schema.String
+    sampled: typeof Schema.Boolean
+  }
+> = Schema.Struct({
+  _tag: Schema.Literal("Request"),
+  requestId: SnowflakeFromString,
+  address: EntityAddress,
+  tag: Schema.String,
+  payload: Schema.Unknown,
+  headers: Headers.schema,
+  traceId: Schema.String,
+  spanId: Schema.String,
+  sampled: Schema.Boolean
+}) satisfies Schema.Schema<Request.PartialEncoded, Request.Encoded>
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const PartialEncoded: Schema.Union<
+  [
+    Schema.Struct<
+      {
+        _tag: Schema.Literal<["Request"]>
+        requestId: Schema.Schema<Snowflake, string>
+        address: typeof EntityAddress
+        tag: typeof Schema.String
+        payload: typeof Schema.Unknown
+        headers: Schema.Schema<Headers.Headers, ReadonlyRecord<string, string>>
+        traceId: typeof Schema.String
+        spanId: typeof Schema.String
+        sampled: typeof Schema.Boolean
+      }
+    >,
+    typeof AckChunk,
+    typeof Interrupt
+  ]
+> = Schema.Union(PartialEncodedRequest, AckChunk, Interrupt) satisfies Schema.Schema<
+  Envelope.PartialEncoded,
+  Envelope.Encoded
+>
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const PartialEncodedArray: Schema.Schema<
+  Array<Envelope.PartialEncoded>,
+  Array<Envelope.Encoded>
+> = Schema.mutable(Schema.Array(PartialEncoded))
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const PartialEncodedRequestFromSelf: Schema.Struct<
+  {
+    _tag: Schema.Literal<["Request"]>
+    requestId: Schema.Schema<Snowflake>
+    address: Schema.Schema<EntityAddress>
+    tag: typeof Schema.String
+    payload: typeof Schema.Unknown
+    headers: Schema.Schema<Headers.Headers>
+    traceId: typeof Schema.String
+    spanId: typeof Schema.String
+    sampled: typeof Schema.Boolean
+  }
+> = Schema.Struct({
+  _tag: Schema.Literal("Request"),
+  requestId: Schema.typeSchema(SnowflakeFromString),
+  address: EntityAddressFromSelf,
+  tag: Schema.String,
+  payload: Schema.Unknown,
+  headers: Headers.schemaFromSelf,
+  traceId: Schema.String,
+  spanId: Schema.String,
+  sampled: Schema.Boolean
+}) satisfies Schema.Schema<Request.PartialEncoded>
+
+/**
+ * @since 1.0.0
+ * @category serialization / deserialization
+ */
+export const PartialEncodedFromSelf: Schema.Union<
+  [
+    Schema.Struct<
+      {
+        _tag: Schema.Literal<["Request"]>
+        requestId: Schema.Schema<Snowflake>
+        address: Schema.Schema<EntityAddress>
+        tag: typeof Schema.String
+        payload: typeof Schema.Unknown
+        headers: Schema.Schema<Headers.Headers>
+        traceId: typeof Schema.String
+        spanId: typeof Schema.String
+        sampled: typeof Schema.Boolean
+      }
+    >,
+    Schema.Schema<AckChunk>,
+    Schema.Schema<Interrupt>
+  ]
+> = Schema.Union(
+  PartialEncodedRequestFromSelf,
+  Schema.typeSchema(AckChunk),
+  Schema.typeSchema(Interrupt)
+) satisfies Schema.Schema<Envelope.PartialEncoded>
+
+/**
+ * @since 1.0.0
+ * @category primary key
+ */
+export const primaryKey = <R extends Rpc.Any>(envelope: Envelope<R>): string | null => {
+  if (envelope._tag !== "Request" || !(Predicate.hasProperty(envelope.payload, PrimaryKey.symbol))) {
+    return null
+  }
+  const value = PrimaryKey.value(envelope.payload)
+  // hash the entity address to save space?
+  return `${envelope.address.entityType}/${envelope.address.entityId}/${envelope.tag}/${value}`
+}

package/src/HttpCommon.ts

@@ -0,0 +1,73 @@
+/**
+ * @since 1.0.0
+ */
+import * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpClientRequest from "@effect/platform/HttpClientRequest"
+import * as Socket from "@effect/platform/Socket"
+import * as RpcClient from "@effect/rpc/RpcClient"
+import * as RpcSerialization from "@effect/rpc/RpcSerialization"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import { RpcClientProtocol } from "./Runners.js"
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolHttp = (options: {
+  readonly path: string
+  readonly https?: boolean | undefined
+}): Layer.Layer<
+  RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | HttpClient.HttpClient
+> =>
+  Layer.effect(
+    RpcClientProtocol,
+    Effect.gen(function*() {
+      const serialization = yield* RpcSerialization.RpcSerialization
+      const client = yield* HttpClient.HttpClient
+      const https = options.https ?? false
+      return (address) => {
+        const clientWithUrl = HttpClient.mapRequest(
+          client,
+          HttpClientRequest.prependUrl(`http${https ? "s" : ""}://${address.host}:${address.port}/${options.path}`)
+        )
+        return RpcClient.makeProtocolHttp(clientWithUrl).pipe(
+          Effect.provideService(RpcSerialization.RpcSerialization, serialization)
+        )
+      }
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClientProtocolWebsocket = (options: {
+  readonly path: string
+  readonly https?: boolean | undefined
+}): Layer.Layer<
+  RpcClientProtocol,
+  never,
+  RpcSerialization.RpcSerialization | Socket.WebSocketConstructor
+> =>
+  Layer.effect(
+    RpcClientProtocol,
+    Effect.gen(function*() {
+      const serialization = yield* RpcSerialization.RpcSerialization
+      const https = options.https ?? false
+      const constructor = yield* Socket.WebSocketConstructor
+      return Effect.fnUntraced(function*(address) {
+        const socket = yield* Socket.makeWebSocket(
+          `ws${https ? "s" : ""}://${address.host}:${address.port}/${options.path}`
+        ).pipe(
+          Effect.provideService(Socket.WebSocketConstructor, constructor)
+        )
+        return yield* RpcClient.makeProtocolSocket.pipe(
+          Effect.provideService(Socket.Socket, socket),
+          Effect.provideService(RpcSerialization.RpcSerialization, serialization)
+        )
+      })
+    })
+  )

package/src/HttpRunner.ts

@@ -0,0 +1,196 @@
+/**
+ * @since 1.0.0
+ */
+import type * as HttpApp from "@effect/platform/HttpApp"
+import type * as HttpClient from "@effect/platform/HttpClient"
+import * as HttpRouter from "@effect/platform/HttpRouter"
+import * as HttpServer from "@effect/platform/HttpServer"
+import type * as Socket from "@effect/platform/Socket"
+import type * as RpcSerialization from "@effect/rpc/RpcSerialization"
+import * as RpcServer from "@effect/rpc/RpcServer"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import type { Scope } from "effect/Scope"
+import { layerClientProtocolHttp, layerClientProtocolWebsocket } from "./HttpCommon.js"
+import type { MessageStorage } from "./MessageStorage.js"
+import * as Runners from "./Runners.js"
+import * as RunnerServer from "./RunnerServer.js"
+import * as Sharding from "./Sharding.js"
+import type * as ShardingConfig from "./ShardingConfig.js"
+import * as ShardManager from "./ShardManager.js"
+import type { ShardStorage } from "./ShardStorage.js"
+import * as SynchronizedClock from "./SynchronizedClock.js"
+
+/**
+ * @since 1.0.0
+ * @category Http App
+ */
+export const toHttpApp: Effect.Effect<
+  HttpApp.Default<never, Scope>,
+  never,
+  Scope | Sharding.Sharding | RpcSerialization.RpcSerialization | MessageStorage
+> = Effect.gen(function*() {
+  const handlers = yield* Layer.build(RunnerServer.layerHandlers)
+  return yield* RpcServer.toHttpApp(Runners.Rpcs, {
+    spanPrefix: "RunnerServer",
+    disableTracing: true
+  }).pipe(Effect.provide(handlers))
+})
+
+/**
+ * @since 1.0.0
+ * @category Http App
+ */
+export const toHttpAppWebsocket: Effect.Effect<
+  HttpApp.Default<never, Scope>,
+  never,
+  Scope | Sharding.Sharding | RpcSerialization.RpcSerialization | MessageStorage
+> = Effect.gen(function*() {
+  const handlers = yield* Layer.build(RunnerServer.layerHandlers)
+  return yield* RpcServer.toHttpAppWebsocket(Runners.Rpcs, {
+    spanPrefix: "RunnerServer",
+    disableTracing: true
+  }).pipe(
+    Effect.provide(handlers)
+  )
+})
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerClient: Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  ShardingConfig.ShardingConfig | Runners.RpcClientProtocol | MessageStorage | ShardStorage
+> = Sharding.layer.pipe(
+  Layer.provideMerge(Runners.layerRpc),
+  Layer.provideMerge(SynchronizedClock.layer),
+  Layer.provide(ShardManager.layerClientRpc)
+)
+
+/**
+ * A HTTP layer for the `Runners` services, that adds a route to the provided
+ * `HttpRouter.Tag`.
+ *
+ * By default, it uses the `HttpRouter.Default` tag.
+ *
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layer = <I = HttpRouter.Default>(options: {
+  readonly path: HttpRouter.PathInput
+  readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
+  readonly logAddress?: boolean | undefined
+}): Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardingConfig.ShardingConfig
+  | Runners.RpcClientProtocol
+  | HttpServer.HttpServer
+  | MessageStorage
+  | ShardStorage
+> => {
+  const layer = RunnerServer.layerWithClients.pipe(
+    Layer.provide(RpcServer.layerProtocolHttp(options))
+  )
+  return options.logAddress ? withLogAddress(layer) : layer
+}
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWebsocketOptions = <I = HttpRouter.Default>(options: {
+  readonly path: HttpRouter.PathInput
+  readonly routerTag?: HttpRouter.HttpRouter.TagClass<I, string, any, any>
+  readonly logAddress?: boolean | undefined
+}): Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardingConfig.ShardingConfig
+  | Runners.RpcClientProtocol
+  | HttpServer.HttpServer
+  | MessageStorage
+  | ShardStorage
+> => {
+  const layer = RunnerServer.layerWithClients.pipe(
+    Layer.provide(RpcServer.layerProtocolWebsocket(options))
+  )
+  return options.logAddress ? withLogAddress(layer) : layer
+}
+
+const withLogAddress = <A, E, R>(layer: Layer.Layer<A, E, R>): Layer.Layer<A, E, R | HttpServer.HttpServer> =>
+  Layer.effectDiscard(
+    HttpServer.addressFormattedWith((address) =>
+      Effect.annotateLogs(Effect.logInfo(`Listening on: ${address}`), {
+        package: "@effect/cluster",
+        service: "Runner"
+      })
+    )
+  ).pipe(Layer.provideMerge(layer))
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerHttp: Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardingConfig.ShardingConfig
+  | HttpClient.HttpClient
+  | HttpServer.HttpServer
+  | MessageStorage
+  | ShardStorage
+> = HttpRouter.Default.serve().pipe(
+  Layer.provideMerge(layer({ path: "/", logAddress: true })),
+  Layer.provide(layerClientProtocolHttp({ path: "/" }))
+)
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerHttpClientOnly: Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardingConfig.ShardingConfig
+  | HttpClient.HttpClient
+  | MessageStorage
+> = RunnerServer.layerClientOnly.pipe(
+  Layer.provide(layerClientProtocolHttp({ path: "/" }))
+)
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWebsocket: Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  | RpcSerialization.RpcSerialization
+  | ShardingConfig.ShardingConfig
+  | Socket.WebSocketConstructor
+  | HttpServer.HttpServer
+  | MessageStorage
+  | ShardStorage
+> = HttpRouter.Default.serve().pipe(
+  Layer.provideMerge(layerWebsocketOptions({ path: "/", logAddress: true })),
+  Layer.provide(layerClientProtocolWebsocket({ path: "/" }))
+)
+
+/**
+ * @since 1.0.0
+ * @category Layers
+ */
+export const layerWebsocketClientOnly: Layer.Layer<
+  Sharding.Sharding | Runners.Runners,
+  never,
+  ShardingConfig.ShardingConfig | MessageStorage | RpcSerialization.RpcSerialization | Socket.WebSocketConstructor
+> = RunnerServer.layerClientOnly.pipe(
+  Layer.provide(layerClientProtocolWebsocket({ path: "/" }))
+)