dfx 0.51.0 → 0.51.2

package/src/DiscordGateway/Sharder.ts

@@ -1,114 +1,135 @@
-import { millis } from "@effect/data/Duration"
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as HashSet from "@effect/data/HashSet"
+import * as Option from "@effect/data/Option"
+import * as Deferred from "@effect/io/Deferred"
+import * as Effect from "@effect/io/Effect"
+import * as Hub from "@effect/io/Hub"
+import * as Layer from "@effect/io/Layer"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
+import * as Schedule from "@effect/io/Schedule"
 import { DiscordConfig } from "dfx/DiscordConfig"
+import { LiveShard, RunningShard, Shard } from "dfx/DiscordGateway/Shard"
+import { ShardStore } from "dfx/DiscordGateway/ShardStore"
+import { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import { DiscordREST } from "dfx/DiscordREST"
-import { LiveRateLimiter, RateLimiter } from "../RateLimit.js"
-import { LiveShard, RunningShard, Shard } from "./Shard.js"
-import { ShardStore } from "./ShardStore.js"
-import { WebSocketCloseError, WebSocketError } from "./WS.js"
-import { Some } from "@effect/data/Option"
+import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
+import * as Discord from "dfx/types"
 
-const claimRepeatPolicy = Schedule.fixed(Duration.minutes(3)).whileInput(
-  (_: Maybe<number>) => _.isNone(),
-).passthrough as Schedule<never, Maybe<number>, Some<number>>
+const claimRepeatPolicy = Schedule.fixed("3 minutes").pipe(
+  Schedule.whileInput((_: Option.Option<number>) => _._tag === "None"),
+  Schedule.passthrough,
+) as Schedule.Schedule<never, Option.Option<number>, Option.Some<number>>
 
-const make = Do($ => {
-  const store = $(ShardStore.accessWith(identity))
-  const rest = $(DiscordREST.accessWith(identity))
-  const { gateway: config } = $(DiscordConfig.accessWith(identity))
-  const limiter = $(RateLimiter.accessWith(identity))
-  const shard = $(Shard.accessWith(identity))
-  const currentShards = $(Ref.make(HashSet.empty<RunningShard>()))
+const make = Effect.gen(function* (_) {
+  const store = yield* _(ShardStore)
+  const rest = yield* _(DiscordREST)
+  const { gateway: config } = yield* _(DiscordConfig)
+  const limiter = yield* _(RateLimiter)
+  const shard = yield* _(Shard)
+  const currentShards = yield* _(Ref.make(HashSet.empty<RunningShard>()))
 
   const takeConfig = (totalCount: number) =>
-    Do($ => {
-      const currentCount = $(Ref.make(0))
+    Effect.gen(function* (_) {
+      const currentCount = yield* _(Ref.make(0))
 
-      const claimId = (sharderCount: number): Effect<never, never, number> =>
+      const claimId = (
+        sharderCount: number,
+      ): Effect.Effect<never, never, number> =>
         store
           .claimId({
             totalCount,
             sharderCount,
           })
-          .repeat(claimRepeatPolicy)
-          .map(_ => _.value)
+          .pipe(
+            Effect.repeat(claimRepeatPolicy),
+            Effect.map(_ => _.value),
+          )
 
-      return currentCount
-        .getAndUpdate(_ => _ + 1)
-        .flatMap(claimId)
-        .map(id => ({ id, totalCount } as const))
+      return Ref.getAndUpdate(currentCount, _ => _ + 1).pipe(
+        Effect.flatMap(claimId),
+        Effect.map(id => ({ id, totalCount } as const)),
+      )
     })
 
-  const gateway = $(
-    rest
-      .getGatewayBot()
-      .flatMap(r => r.json)
-      .catchAll(() =>
-        Effect.succeed<Discord.GetGatewayBotResponse>({
-          url: "wss://gateway.discord.gg/",
-          shards: 1,
-          session_start_limit: {
-            total: 0,
-            remaining: 0,
-            reset_after: 0,
-            max_concurrency: 1,
-          },
-        }),
-      ),
+  const gateway = yield* _(
+    rest.getGatewayBot(),
+    Effect.flatMap(r => r.json),
+    Effect.catchAll(() =>
+      Effect.succeed<Discord.GetGatewayBotResponse>({
+        url: "wss://gateway.discord.gg/",
+        shards: 1,
+        session_start_limit: {
+          total: 0,
+          remaining: 0,
+          reset_after: 0,
+          max_concurrency: 1,
+        },
+      }),
+    ),
   )
 
   const run = (
-    hub: Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
-    sendQueue: Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
+    hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
+    sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    Do($ => {
-      const deferred = $(
+    Effect.gen(function* (_) {
+      const deferred = yield* _(
         Deferred.make<WebSocketError | WebSocketCloseError, never>(),
       )
-      const take = $(takeConfig(config.shardCount ?? gateway.shards))
+      const take = yield* _(takeConfig(config.shardCount ?? gateway.shards))
 
-      const spawner = take
-        .map(config => ({
+      const spawner = take.pipe(
+        Effect.map(config => ({
           ...config,
           url: gateway.url,
           concurrency: gateway.session_start_limit.max_concurrency,
-        }))
-        .tap(({ id, concurrency }) =>
+        })),
+        Effect.tap(({ id, concurrency }) =>
           limiter.maybeWait(
             `dfx.sharder.${id % concurrency}`,
-            millis(config.identifyRateLimit[0]),
+            Duration.millis(config.identifyRateLimit[0]),
             config.identifyRateLimit[1],
           ),
-        )
-        .flatMap(c => shard.connect([c.id, c.totalCount], hub, sendQueue))
-        .flatMap(
-          shard =>
-            currentShards
-              .update(_ => _.add(shard))
-              .acquireUseRelease(
-                () => shard.run,
-                () => currentShards.update(_ => _.remove(shard)),
-              )
-              .catchAllCause(_ => deferred.failCause(_)).fork,
-        ).forever
+        ),
+        Effect.flatMap(c =>
+          shard.connect([c.id, c.totalCount], hub, sendQueue),
+        ),
+        Effect.flatMap(shard =>
+          Effect.acquireUseRelease(
+            Ref.update(currentShards, HashSet.add(shard)),
+            () => shard.run,
+            () => Ref.update(currentShards, HashSet.remove(shard)),
+          ).pipe(
+            Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
+            Effect.fork,
+          ),
+        ),
+        Effect.forever,
+      )
 
-      const spawners = Chunk.range(
-        1,
-        gateway.session_start_limit.max_concurrency,
-      ).map(() => spawner)
+      const spawners = Chunk.map(
+        Chunk.range(1, gateway.session_start_limit.max_concurrency),
+        () => spawner,
+      )
 
-      return $(
+      return yield* _(
         Effect.all(
           Effect.all(spawners, { concurrency: "unbounded", discard: true }),
-          deferred.await,
+          Deferred.await(deferred),
           { concurrency: "unbounded", discard: true },
-        ) as Effect<never, WebSocketError | WebSocketCloseError, never>,
+        ) as Effect.Effect<never, WebSocketError | WebSocketCloseError, never>,
       )
     })
 
-  return { shards: currentShards.get, run } as const
+  return { shards: Ref.get(currentShards), run } as const
 })
 
-export interface Sharder extends Effect.Success<typeof make> {}
+export interface Sharder extends Effect.Effect.Success<typeof make> {}
 export const Sharder = Tag<Sharder>()
-export const LiveSharder =
-  (LiveRateLimiter + LiveShard) >> Layer.effect(Sharder, make)
+export const LiveSharder = Layer.provide(
+  Layer.merge(LiveRateLimiter, LiveShard),
+  Layer.effect(Sharder, make),
+)

package/src/DiscordGateway/WS.ts

@@ -1,9 +1,16 @@
 import { Log } from "dfx/Log"
 import WebSocket from "isomorphic-ws"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+import * as Ref from "@effect/io/Ref"
+import * as Queue from "@effect/io/Queue"
+import * as Runtime from "@effect/io/Runtime"
+import * as Duration from "@effect/data/Duration"
 
 export const Reconnect = Symbol()
 export type Reconnect = typeof Reconnect
-export type Message = string | Buffer | ArrayBuffer | Reconnect
+export type Message = string | Uint8Array | ArrayBuffer | Reconnect
 
 export class WebSocketError {
   readonly _tag = "WebSocketError"
@@ -23,66 +30,77 @@ const isReconnect = (
 ): e is WebSocketCloseError =>
   e._tag === "WebSocketCloseError" && e.code === 1012
 
-const socket = (urlRef: Ref<string>) =>
-  urlRef.get
-    .map(_ => new WebSocket(_) as any as globalThis.WebSocket)
-    .acquireRelease(ws =>
+const socket = (urlRef: Ref.Ref<string>) =>
+  Ref.get(urlRef).pipe(
+    Effect.map(_ => new WebSocket(_) as any as globalThis.WebSocket),
+    Effect.acquireRelease(ws =>
       Effect.sync(() => {
+        // eslint-disable-next-line @typescript-eslint/no-extra-semi
         ;(ws as any).removeAllListeners?.()
         ws.close()
       }),
-    )
+    ),
+  )
 
 const offer = (
   ws: globalThis.WebSocket,
-  queue: Enqueue<WebSocket.Data>,
+  queue: Queue.Enqueue<WebSocket.Data>,
   log: Log,
 ) =>
-  Effect.runtime<never>().flatMap(runtime =>
-    Effect.async<never, WebSocketError | WebSocketCloseError, never>(resume => {
-      const run = runtime.runFork
-      ws.addEventListener("message", message => {
-        run(
-          queue
-            .offer(message.data)
-            .zipLeft(log.debug("WS", "offer", message.data), {}),
-        )
-      })
+  Effect.runtime<never>().pipe(
+    Effect.flatMap(runtime =>
+      Effect.async<never, WebSocketError | WebSocketCloseError, never>(
+        resume => {
+          const run = Runtime.runFork(runtime)
+          ws.addEventListener("message", message => {
+            run(
+              Effect.all(
+                log.debug("WS", "receive", message.data),
+                Queue.offer(queue, message.data),
+                { concurrency: "unbounded", discard: true },
+              ),
+            )
+          })
+
+          ws.addEventListener("error", cause => {
+            resume(Effect.fail(new WebSocketError("error", cause)))
+          })
+
+          ws.addEventListener("close", e => {
+            resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
+          })
+        },
+      ),
+    ),
+  )
 
-      ws.addEventListener("error", cause => {
-        resume(Effect.fail(new WebSocketError("error", cause)))
-      })
+const waitForOpen = (ws: globalThis.WebSocket, timeout: Duration.Duration) =>
+  Effect.timeoutFail(
+    Effect.suspend(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        return Effect.unit
+      }
 
-      ws.addEventListener("close", e => {
-        resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
+      return Effect.async<never, never, void>(resume => {
+        ws.addEventListener("open", () => resume(Effect.unit), {
+          once: true,
+        })
       })
     }),
+    {
+      onTimeout: () => new WebSocketError("open-timeout"),
+      duration: timeout,
+    },
   )
 
-const waitForOpen = (ws: globalThis.WebSocket, timeout: Duration) =>
-  Effect.suspend(() => {
-    if (ws.readyState === WebSocket.OPEN) {
-      return Effect.unit
-    }
-
-    return Effect.async<never, never, void>(resume => {
-      ws.addEventListener("open", () => resume(Effect.unit), {
-        once: true,
-      })
-    })
-  }).timeoutFail({
-    onTimeout: () => new WebSocketError("open-timeout"),
-    duration: timeout,
-  })
-
 const send = (
   ws: globalThis.WebSocket,
-  take: Effect<never, never, Message>,
+  take: Effect.Effect<never, never, Message>,
   log: Log,
 ) =>
-  take
-    .tap(data => log.debug("WS", "send", data))
-    .tap(data => {
+  take.pipe(
+    Effect.tap(data => log.debug("WS", "send", data)),
+    Effect.tap(data => {
       if (data === Reconnect) {
         return Effect.failSync(() => {
           ws.close(1012, "reconnecting")
@@ -93,36 +111,43 @@ const send = (
       return Effect.sync(() => {
         ws.send(data)
       })
-    }).forever
+    }),
+    Effect.forever,
+  )
 
-const make = Do($ => {
-  const log = $(Log.accessWith(identity))
+const make = Effect.gen(function* (_) {
+  const log = yield* _(Log)
 
   const connect = (
-    url: Ref<string>,
-    takeOutbound: Effect<never, never, Message>,
+    url: Ref.Ref<string>,
+    takeOutbound: Effect.Effect<never, never, Message>,
     onConnecting = Effect.unit,
     openTimeout = Duration.seconds(3),
   ) =>
-    Do($ => {
-      const queue = $(Queue.unbounded<WebSocket.Data>())
-
-      const run = onConnecting
-        .zipRight(socket(url))
-        .flatMap(ws =>
-          offer(ws, queue, log).zipLeft(
-            waitForOpen(ws, openTimeout).zipRight(send(ws, takeOutbound, log)),
-            { parallel: true },
+    Effect.gen(function* (_) {
+      const queue = yield* _(Queue.unbounded<WebSocket.Data>())
+
+      const run = onConnecting.pipe(
+        Effect.zipRight(socket(url)),
+        Effect.flatMap(ws =>
+          Effect.all(
+            offer(ws, queue, log),
+            waitForOpen(ws, openTimeout).pipe(
+              Effect.zipRight(send(ws, takeOutbound, log)),
+            ),
+            { concurrency: "unbounded", discard: true },
           ),
-        )
-        .scoped.retryWhile(isReconnect)
+        ),
+        Effect.scoped,
+        Effect.retryWhile(isReconnect),
+      )
 
-      return { run, take: queue.take() } as const
+      return { run, take: Queue.take(queue) } as const
     })
 
   return { connect } as const
 })
 
-export interface WS extends Effect.Success<typeof make> {}
+export interface WS extends Effect.Effect.Success<typeof make> {}
 export const WS = Tag<WS>()
 export const LiveWS = Layer.effect(WS, make)

package/src/DiscordGateway.ts

@@ -1,30 +1,70 @@
-import { LiveSharder, Sharder } from "./DiscordGateway/Sharder.js"
+import { Tag } from "@effect/data/Context"
+import * as HashSet from "@effect/data/HashSet"
+import * as Effect from "@effect/io/Effect"
+import * as Hub from "@effect/io/Hub"
+import * as Layer from "@effect/io/Layer"
+import * as Queue from "@effect/io/Queue"
+import * as Stream from "@effect/stream/Stream"
+import { RunningShard } from "dfx/DiscordGateway/Shard"
+import { LiveSharder, Sharder } from "dfx/DiscordGateway/Sharder"
+import { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
+import * as Discord from "dfx/types"
+import * as EffectUtils from "dfx/utils/Effect"
 
 const fromDispatchFactory =
-  <R, E>(source: Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
+  <R, E>(
+    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+  ) =>
   <K extends keyof Discord.ReceiveEvents>(
     event: K,
-  ): Stream<R, E, Discord.ReceiveEvents[K]> =>
-    source.filter(p => p.t === event).map(p => p.d! as any)
+  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+    Stream.filter(source, p => p.t === event).pipe(Stream.map(p => p.d! as any))
 
 const handleDispatchFactory =
-  (hub: Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
+  (hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
   <K extends keyof Discord.ReceiveEvents, R, E, A>(
     event: K,
-    handle: (event: Discord.ReceiveEvents[K]) => Effect<R, E, A>,
-  ): Effect<R, E, never> =>
-    hub.subscribeForEachPar(_ => {
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<R, E, A>,
+  ): Effect.Effect<R, E, never> =>
+    EffectUtils.subscribeForEachPar(hub, _ => {
       if (_.t === event) {
         return handle(_.d as any)
       }
       return Effect.unit
     })
 
-export const make = Do($ => {
-  const sharder = $(Sharder.accessWith(identity))
-  const hub = $(Hub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>())
+export interface DiscordGateway {
+  readonly run: Effect.Effect<
+    never,
+    WebSocketError | WebSocketCloseError,
+    never
+  >
+  readonly dispatch: Stream.Stream<
+    never,
+    never,
+    Discord.GatewayPayload<Discord.ReceiveEvent>
+  >
+  readonly fromDispatch: <K extends keyof Discord.ReceiveEvents>(
+    event: K,
+  ) => Stream.Stream<never, never, Discord.ReceiveEvents[K]>
+  readonly handleDispatch: <K extends keyof Discord.ReceiveEvents, R, E, A>(
+    event: K,
+    handle: (event: Discord.ReceiveEvents[K]) => Effect.Effect<R, E, A>,
+  ) => Effect.Effect<R, E, never>
+  readonly send: (
+    payload: Discord.GatewayPayload<Discord.SendEvent>,
+  ) => Effect.Effect<never, never, boolean>
+  readonly shards: Effect.Effect<never, never, HashSet.HashSet<RunningShard>>
+}
+export const DiscordGateway = Tag<DiscordGateway>()
 
-  const sendQueue = $(
+export const make = Effect.gen(function* (_) {
+  const sharder = yield* _(Sharder)
+  const hub = yield* _(
+    Hub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),
+  )
+
+  const sendQueue = yield* _(
     Queue.unbounded<Discord.GatewayPayload<Discord.SendEvent>>(),
   )
   const send = (payload: Discord.GatewayPayload<Discord.SendEvent>) =>
@@ -36,17 +76,17 @@ export const make = Do($ => {
 
   const run = sharder.run(hub, sendQueue)
 
-  return {
+  return DiscordGateway.of({
     run,
     dispatch,
     fromDispatch,
     handleDispatch,
     send,
     shards: sharder.shards,
-  } as const
+  })
 })
 
-export interface DiscordGateway extends Effect.Success<typeof make> {}
-export const DiscordGateway = Tag<DiscordGateway>()
-export const LiveDiscordGateway =
-  LiveSharder >> Layer.effect(DiscordGateway, make)
+export const LiveDiscordGateway = Layer.provide(
+  LiveSharder,
+  Layer.effect(DiscordGateway, make),
+)

package/src/DiscordREST/types.ts

@@ -1,12 +1,12 @@
-import * as Http from "@effect-http/client"
-import { DiscordRESTError } from "dfx/DiscordREST"
-import { Effect } from "dfx/_common"
+import type * as Http from "@effect-http/client"
+import type { DiscordRESTError } from "dfx/DiscordREST"
+import type * as Effect from "@effect/io/Effect"
 
 export interface ResponseWithData<A> extends Http.response.Response {
-  readonly json: Effect<never, Http.ResponseDecodeError, A>
+  readonly json: Effect.Effect<never, Http.ResponseDecodeError, A>
 }
 
-export type RestResponse<T> = Effect<
+export type RestResponse<T> = Effect.Effect<
   never,
   DiscordRESTError,
   ResponseWithData<T>

package/src/DiscordREST/utils.ts

@@ -1,4 +1,5 @@
 import * as Option from "@effect/data/Option"
+import * as Duration from "@effect/data/Duration"
 
 const majorResources = ["channels", "guilds", "webhooks"] as const
 
@@ -16,18 +17,20 @@ export const routeFromConfig = (path: string, method: string) => {
 }
 
 export const numberHeader = (headers: Headers) => (key: string) =>
-  Maybe.fromNullable(headers.get(key))
-    .map(parseFloat)
-    .filter(n => !isNaN(n))
+  Option.fromNullable(headers.get(key)).pipe(
+    Option.map(parseFloat),
+    Option.filter(n => !isNaN(n)),
+  )
 
 export const retryAfter = (headers: Headers) =>
-  numberHeader(headers)("x-ratelimit-reset-after")
-    .orElse(() => numberHeader(headers)("retry-after"))
-    .map(Duration.seconds)
+  numberHeader(headers)("x-ratelimit-reset-after").pipe(
+    Option.orElse(() => numberHeader(headers)("retry-after")),
+    Option.map(Duration.seconds),
+  )
 
 export const rateLimitFromHeaders = (headers: Headers) =>
   Option.all({
-    bucket: Maybe.fromNullable(headers.get("x-ratelimit-bucket")),
+    bucket: Option.fromNullable(headers.get("x-ratelimit-bucket")),
     retryAfter: retryAfter(headers),
     limit: numberHeader(headers)("x-ratelimit-limit"),
     remaining: numberHeader(headers)("x-ratelimit-remaining"),