dfx 0.61.5 → 0.61.7

package/src/DiscordGateway/Shard.ts

@@ -1,6 +1,7 @@
 import * as Chunk from "@effect/data/Chunk"
 import { Tag } from "@effect/data/Context"
 import * as Duration from "@effect/data/Duration"
+import { pipe } from "@effect/data/Function"
 import * as Option from "@effect/data/Option"
 import * as ConfigSecret from "@effect/io/Config/Secret"
 import * as Effect from "@effect/io/Effect"
@@ -26,7 +27,7 @@ const enum Phase {
   Connected,
 }
 
-export const make = Effect.gen(function*(_) {
+export const make = Effect.gen(function* (_) {
   const { gateway, token } = yield* _(DiscordConfig)
   const limiter = yield* _(RateLimiter)
   const dws = yield* _(DiscordWS)
@@ -37,7 +38,7 @@ export const make = Effect.gen(function*(_) {
     hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
     sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    Effect.gen(function*(_) {
+    Effect.gen(function* (_) {
       const outboundQueue = yield* _(Queue.unbounded<Message>())
       const pendingQueue = yield* _(Queue.unbounded<Message>())
       const phase = yield* _(Ref.make(Phase.Connecting))
@@ -52,67 +53,66 @@ export const make = Effect.gen(function*(_) {
         Effect.flatMap(Ref.get(phase), phase =>
           phase === Phase.Connected
             ? Queue.offer(outboundQueue, p)
-            : Queue.offer(pendingQueue, p))
+            : Queue.offer(pendingQueue, p),
+        )
 
       const heartbeatSend = (p: Message) =>
         Effect.flatMap(Ref.get(phase), phase =>
           phase !== Phase.Connecting
             ? Queue.offer(outboundQueue, p)
-            : Effect.succeed(false))
+            : Effect.succeed(false),
+        )
 
       const prioritySend = (p: Message) => Queue.offer(outboundQueue, p)
 
-      const resume = setPhase(Phase.Connected).pipe(
+      const resume = pipe(
+        setPhase(Phase.Connected),
         Effect.zipRight(Queue.takeAll(pendingQueue)),
         Effect.tap(_ => Queue.offerAll(outboundQueue, _)),
         Effect.asUnit,
       )
 
-      const onConnecting = Queue.takeAll(outboundQueue).pipe(
+      const onConnecting = pipe(
+        Queue.takeAll(outboundQueue),
         Effect.tap(msgs =>
           Queue.offerAll(
             pendingQueue,
             Chunk.filter(
               msgs,
               msg =>
-                msg !== Reconnect
-                && msg.op !== Discord.GatewayOpcode.IDENTIFY
-                && msg.op !== Discord.GatewayOpcode.RESUME
-                && msg.op !== Discord.GatewayOpcode.HEARTBEAT,
+                msg !== Reconnect &&
+                msg.op !== Discord.GatewayOpcode.IDENTIFY &&
+                msg.op !== Discord.GatewayOpcode.RESUME &&
+                msg.op !== Discord.GatewayOpcode.HEARTBEAT,
             ),
-          )
+          ),
         ),
         Effect.zipRight(setPhase(Phase.Connecting)),
       )
 
       const socket = yield* _(dws.connect({ outbound, onConnecting }))
 
+      const isReady = Option.liftPredicate(
+        (
+          p: Discord.GatewayPayload,
+        ): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
+          p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
+      )
+
       const [latestReady, updateLatestReady] = yield* _(
-        Utils.latest(p =>
-          Option.some(p).pipe(
-            Option.filter(
-              (p): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
-                p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
-            ),
-            Option.map(p => p.d!),
-          )
-        ),
+        Utils.latest(p => Option.map(isReady(p), p => p.d!)),
       )
       const [latestSequence, updateLatestSequence] = yield* _(
         Utils.latest(p => Option.fromNullable(p.s)),
       )
       const maybeUpdateUrl = (p: Discord.GatewayPayload) =>
-        Option.some(p).pipe(
-          Option.filter(
-            (p): p is Discord.GatewayPayload<Discord.ReadyEvent> =>
-              p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
-          ),
-          Option.map(p => p.d!),
-          Option.match({
+        Option.match(
+          Option.map(isReady(p), p => p.d!),
+          {
             onNone: () => Effect.unit,
             onSome: ({ resume_gateway_url }) =>
               socket.setUrl(resume_gateway_url),
-          }),
+          },
         )
 
       const hellos = yield* _(Queue.unbounded<Discord.GatewayPayload>())
@@ -139,13 +139,15 @@ export const make = Effect.gen(function*(_) {
       )
 
       const onPayload = (p: Discord.GatewayPayload) =>
-        updateLatestReady(p).pipe(
+        pipe(
+          updateLatestReady(p),
           Effect.zipRight(updateLatestSequence(p)),
           Effect.zipRight(maybeUpdateUrl(p)),
           Effect.tap(() => {
             switch (p.op) {
               case Discord.GatewayOpcode.HELLO:
-                return Effect.tap(identify, prioritySend).pipe(
+                return pipe(
+                  Effect.tap(identify, prioritySend),
                   Effect.zipRight(setPhase(Phase.Handshake)),
                   Effect.zipRight(Queue.offer(hellos, p)),
                 )
@@ -161,20 +163,19 @@ export const make = Effect.gen(function*(_) {
                   return Effect.zipRight(resume, Hub.publish(hub, p))
                 }
                 return Hub.publish(hub, p)
+              default:
+                return Effect.unit
             }
-
-            return Effect.unit
           }),
         )
 
-      const drainSendQueue = Queue.take(sendQueue).pipe(
-        Effect.tap(send),
-        Effect.forever,
+      const drainSendQueue = Effect.forever(
+        Effect.tap(Queue.take(sendQueue), send),
       )
 
       const run = Effect.all(
         [
-          socket.take.pipe(Effect.flatMap(onPayload), Effect.forever),
+          Effect.forever(Effect.flatMap(socket.take, onPayload)),
           heartbeats,
           drainSendQueue,
           socket.run,
@@ -196,5 +197,4 @@ export const LiveShard = Layer.provide(
 )
 
 export interface RunningShard
-  extends Effect.Effect.Success<ReturnType<Shard["connect"]>>
-{}
+  extends Effect.Effect.Success<ReturnType<Shard["connect"]>> {}

package/src/DiscordGateway/Sharder.ts

@@ -1,6 +1,7 @@
 import * as Chunk from "@effect/data/Chunk"
 import { Tag } from "@effect/data/Context"
 import * as Duration from "@effect/data/Duration"
+import { pipe } from "@effect/data/Function"
 import * as HashSet from "@effect/data/HashSet"
 import type * as Option from "@effect/data/Option"
 import * as Deferred from "@effect/io/Deferred"
@@ -24,7 +25,7 @@ const claimRepeatPolicy = Schedule.spaced("3 minutes").pipe(
   Schedule.passthrough,
 ) as Schedule.Schedule<never, Option.Option<number>, Option.Some<number>>
 
-const make = Effect.gen(function*(_) {
+const make = Effect.gen(function* (_) {
   const store = yield* _(ShardStore)
   const rest = yield* _(DiscordREST)
   const { gateway: config } = yield* _(DiscordConfig)
@@ -33,25 +34,25 @@ const make = Effect.gen(function*(_) {
   const currentShards = yield* _(Ref.make(HashSet.empty<RunningShard>()))
 
   const takeConfig = (totalCount: number) =>
-    Effect.gen(function*(_) {
+    Effect.gen(function* (_) {
       const currentCount = yield* _(Ref.make(0))
 
       const claimId = (
         sharderCount: number,
       ): Effect.Effect<never, never, number> =>
-        store
-          .claimId({
+        pipe(
+          store.claimId({
             totalCount,
             sharderCount,
-          })
-          .pipe(
-            Effect.repeat(claimRepeatPolicy),
-            Effect.map(_ => _.value),
-          )
+          }),
+          Effect.repeat(claimRepeatPolicy),
+          Effect.map(_ => _.value),
+        )
 
-      return Ref.getAndUpdate(currentCount, _ => _ + 1).pipe(
+      return pipe(
+        Ref.getAndUpdate(currentCount, _ => _ + 1),
         Effect.flatMap(claimId),
-        Effect.map(id => ({ id, totalCount } as const)),
+        Effect.map(id => ({ id, totalCount }) as const),
       )
     })
 
@@ -68,7 +69,7 @@ const make = Effect.gen(function*(_) {
           reset_after: 0,
           max_concurrency: 1,
         },
-      })
+      }),
     ),
   )
 
@@ -76,13 +77,14 @@ const make = Effect.gen(function*(_) {
     hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>,
     sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>,
   ) =>
-    Effect.gen(function*(_) {
+    Effect.gen(function* (_) {
       const deferred = yield* _(
         Deferred.make<WebSocketError | WebSocketCloseError, never>(),
       )
       const take = yield* _(takeConfig(config.shardCount ?? gateway.shards))
 
-      const spawner = take.pipe(
+      const spawner = pipe(
+        take,
         Effect.map(config => ({
           ...config,
           url: gateway.url,
@@ -93,10 +95,10 @@ const make = Effect.gen(function*(_) {
             `dfx.sharder.${id % concurrency}`,
             Duration.millis(config.identifyRateLimit[0]),
             config.identifyRateLimit[1],
-          )
+          ),
         ),
         Effect.flatMap(c =>
-          shard.connect([c.id, c.totalCount], hub, sendQueue)
+          shard.connect([c.id, c.totalCount], hub, sendQueue),
         ),
         Effect.flatMap(shard =>
           Effect.acquireUseRelease(
@@ -106,7 +108,7 @@ const make = Effect.gen(function*(_) {
           ).pipe(
             Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
             Effect.fork,
-          )
+          ),
         ),
         Effect.forever,
       )

package/src/DiscordGateway/WS.ts

@@ -1,10 +1,10 @@
 import { Tag } from "@effect/data/Context"
 import * as Duration from "@effect/data/Duration"
+import { pipe } from "@effect/data/Function"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
 import * as Queue from "@effect/io/Queue"
 import * as Ref from "@effect/io/Ref"
-import * as Runtime from "@effect/io/Runtime"
 import { Log } from "dfx/Log"
 import WebSocket from "isomorphic-ws"
 
@@ -22,7 +22,10 @@ export class WebSocketError {
 
 export class WebSocketCloseError {
   readonly _tag = "WebSocketCloseError"
-  constructor(readonly code: number, readonly reason: string) {}
+  constructor(
+    readonly code: number,
+    readonly reason: string,
+  ) {}
 }
 
 const isReconnect = (
@@ -31,14 +34,15 @@ const isReconnect = (
   e._tag === "WebSocketCloseError" && e.code === 1012
 
 const socket = (urlRef: Ref.Ref<string>) =>
-  Ref.get(urlRef).pipe(
+  pipe(
+    Ref.get(urlRef),
     Effect.map(_ => new WebSocket(_) as any as globalThis.WebSocket),
     Effect.acquireRelease(ws =>
       Effect.sync(() => {
         // eslint-disable-next-line no-extra-semi
         ;(ws as any).removeAllListeners?.()
         ws.close()
-      })
+      }),
     ),
   )
 
@@ -47,34 +51,24 @@ const offer = (
   queue: Queue.Enqueue<WebSocket.Data>,
   log: Log,
 ) =>
-  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 },
-              ),
-            )
-          })
+  Effect.async<never, WebSocketError | WebSocketCloseError, never>(resume => {
+    ws.addEventListener("message", message => {
+      Effect.runFork(
+        Effect.zipRight(
+          log.debug("WS", "receive", message.data),
+          Queue.offer(queue, message.data),
+        ),
+      )
+    })
 
-          ws.addEventListener("error", cause => {
-            resume(Effect.fail(new WebSocketError("error", cause)))
-          })
+    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("close", e => {
+      resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
+    })
+  })
 
 const waitForOpen = (ws: globalThis.WebSocket, timeout: Duration.Duration) =>
   Effect.timeoutFail(
@@ -100,7 +94,8 @@ const send = (
   take: Effect.Effect<never, never, Message>,
   log: Log,
 ) =>
-  take.pipe(
+  pipe(
+    take,
     Effect.tap(data => log.debug("WS", "send", data)),
     Effect.tap(data => {
       if (data === Reconnect) {
@@ -117,7 +112,7 @@ const send = (
     Effect.forever,
   )
 
-const make = Effect.gen(function*(_) {
+const make = Effect.gen(function* (_) {
   const log = yield* _(Log)
 
   const connect = (
@@ -126,21 +121,23 @@ const make = Effect.gen(function*(_) {
     onConnecting = Effect.unit,
     openTimeout = Duration.seconds(3),
   ) =>
-    Effect.gen(function*(_) {
+    Effect.gen(function* (_) {
       const queue = yield* _(Queue.unbounded<WebSocket.Data>())
 
-      const run = onConnecting.pipe(
+      const run = pipe(
+        onConnecting,
         Effect.zipRight(socket(url)),
         Effect.flatMap(ws =>
           Effect.all(
             [
               offer(ws, queue, log),
-              waitForOpen(ws, openTimeout).pipe(
-                Effect.zipRight(send(ws, takeOutbound, log)),
+              Effect.zipRight(
+                waitForOpen(ws, openTimeout),
+                send(ws, takeOutbound, log),
               ),
             ],
             { concurrency: "unbounded", discard: true },
-          )
+          ),
         ),
         Effect.scoped,
         Effect.retryWhile(isReconnect),

package/src/DiscordGateway.ts

@@ -11,13 +11,17 @@ import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 
-const fromDispatchFactory = <R, E>(
-  source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
-) =>
-<K extends keyof Discord.ReceiveEvents>(
-  event: K,
-): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
-  Stream.filter(source, p => p.t === event).pipe(Stream.map(p => p.d! as any))
+const fromDispatchFactory =
+  <R, E>(
+    source: Stream.Stream<R, E, Discord.GatewayPayload<Discord.ReceiveEvent>>,
+  ) =>
+  <K extends keyof Discord.ReceiveEvents>(
+    event: K,
+  ): Stream.Stream<R, E, Discord.ReceiveEvents[K]> =>
+    Stream.map(
+      Stream.filter(source, p => p.t === event),
+      p => p.d! as any,
+    )
 
 const handleDispatchFactory =
   (hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
@@ -57,7 +61,7 @@ export interface DiscordGateway {
 }
 export const DiscordGateway = Tag<DiscordGateway>()
 
-export const make = Effect.gen(function*(_) {
+export const make = Effect.gen(function* (_) {
   const sharder = yield* _(Sharder)
   const hub = yield* _(
     Hub.unbounded<Discord.GatewayPayload<Discord.ReceiveEvent>>(),

package/src/DiscordREST/utils.ts

@@ -9,10 +9,8 @@ export const routeFromConfig = (path: string, method: string) => {
   // Only keep major ID's
   const routeURL = path
     .split("?")[0]
-    .replace(
-      /\/([A-Za-z]+)\/(\d{16,21}|@me)/g,
-      (match, resource) =>
-        majorResources.includes(resource) ? match : `/${resource}`,
+    .replace(/\/([A-Za-z]+)\/(\d{16,21}|@me)/g, (match, resource) =>
+      majorResources.includes(resource) ? match : `/${resource}`,
     )
     // Strip reactions
     .replace(/\/reactions\/(.*)/, "/reactions")

package/src/DiscordREST.ts

@@ -29,7 +29,7 @@ export class DiscordRESTError {
   ) {}
 }
 
-const make = Effect.gen(function*(_) {
+const make = Effect.gen(function* (_) {
   const { rest, token } = yield* _(DiscordConfig)
 
   const http = yield* _(Http.client.Client)
@@ -65,7 +65,7 @@ const make = Effect.gen(function*(_) {
       Effect.tap(invalid =>
         invalid
           ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
-          : Effect.unit
+          : Effect.unit,
       ),
       Effect.asUnit,
     )
@@ -90,7 +90,7 @@ const make = Effect.gen(function*(_) {
                 bucket.limit,
               ),
             ),
-        })
+        }),
       ),
     )
 
@@ -102,9 +102,8 @@ const make = Effect.gen(function*(_) {
     Effect.Do.pipe(
       Effect.let("route", () => routeFromConfig(request.url, request.method)),
       Effect.bind("rateLimit", () => rateLimitFromHeaders(response.headers)),
-      Effect.bind(
-        "hasBucket",
-        ({ rateLimit }) => store.hasBucket(rateLimit.bucket),
+      Effect.bind("hasBucket", ({ rateLimit }) =>
+        store.hasBucket(rateLimit.bucket),
       ),
       Effect.flatMap(({ hasBucket, rateLimit, route }) => {
         const effectsToRun = [
@@ -118,9 +117,10 @@ const make = Effect.gen(function*(_) {
             store.putBucket({
               key: rateLimit.bucket,
               resetAfter: Duration.toMillis(rateLimit.retryAfter),
-              limit: !hasBucket && rateLimit.remaining > 0
-                ? rateLimit.remaining
-                : rateLimit.limit,
+              limit:
+                !hasBucket && rateLimit.remaining > 0
+                  ? rateLimit.remaining
+                  : rateLimit.limit,
             }),
           )
         }
@@ -140,20 +140,19 @@ const make = Effect.gen(function*(_) {
         Http.request.prependUrl(req, rest.baseUrl),
         Http.request.setHeaders({
           Authorization: `Bot ${ConfigSecret.value(token)}`,
-          "User-Agent":
-            `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
+          "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
         }),
-      )
+      ),
     ),
     Http.client.catchAll(error =>
       error.reason === "StatusCode"
         ? error.response.json.pipe(
-          Effect.mapError(_ => new DiscordRESTError(_)),
-          Effect.flatMap(body =>
-            Effect.fail(new DiscordRESTError(error, body))
-          ),
-        )
-        : Effect.fail(new DiscordRESTError(error))
+            Effect.mapError(_ => new DiscordRESTError(_)),
+            Effect.flatMap(body =>
+              Effect.fail(new DiscordRESTError(error, body)),
+            ),
+          )
+        : Effect.fail(new DiscordRESTError(error)),
     ),
   )
 
@@ -201,9 +200,8 @@ const make = Effect.gen(function*(_) {
                 Effect.zipRight(updateBuckets(request, response)),
                 Effect.zipRight(
                   Effect.sleep(
-                    Option.getOrElse(
-                      retryAfter(response.headers),
-                      () => Duration.seconds(5),
+                    Option.getOrElse(retryAfter(response.headers), () =>
+                      Duration.seconds(5),
                     ),
                   ),
                 ),
@@ -221,9 +219,10 @@ const make = Effect.gen(function*(_) {
       options = {},
       params,
       url,
-    }: Discord.Route<P, Partial<Http.request.Options.NoUrl>>): RestResponse<
-      R
-    > => {
+    }: Discord.Route<
+      P,
+      Partial<Http.request.Options.NoUrl>
+    >): RestResponse<R> => {
       const hasBody = method !== "GET" && method !== "DELETE"
       let request = Http.request.make(method as any)(url, options)
 
@@ -248,8 +247,7 @@ const make = Effect.gen(function*(_) {
 })
 
 export interface DiscordREST
-  extends Discord.Endpoints<Partial<Http.request.Options.NoUrl>>
-{
+  extends Discord.Endpoints<Partial<Http.request.Options.NoUrl>> {
   readonly executor: <A = unknown>(
     request: Http.request.ClientRequest,
   ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>

package/src/Helpers/flags.ts

@@ -33,14 +33,16 @@ export function toList<T extends Flags<any>>(
  * Returns a function that converts a list of flags names to a bigint bitfield.
  */
 export const fromListBigint =
-  <T extends Flags<bigint>>(flags: T) => (list: Array<keyof T>) =>
+  <T extends Flags<bigint>>(flags: T) =>
+  (list: Array<keyof T>) =>
     list.reduce((acc, key) => acc | flags[key], BigInt(0))
 
 /**
  * Returns a function that converts a list of flags names to a bitfield.
  */
 export const fromList =
-  <T extends Flags<number>>(flags: T) => (list: Array<keyof T>) =>
+  <T extends Flags<number>>(flags: T) =>
+  (list: Array<keyof T>) =>
     list.reduce((acc, key) => acc | flags[key], 0)
 
 /**

package/src/Helpers/intents.ts

@@ -9,9 +9,10 @@ export const ALL = Flags.all(Discord.GatewayIntents)
 /**
  * Privileged intents
  */
-export const PRIVILEGED = Discord.GatewayIntents.GUILD_PRESENCES
-  | Discord.GatewayIntents.GUILD_MEMBERS
-  | Discord.GatewayIntents.MESSAGE_CONTENT
+export const PRIVILEGED =
+  Discord.GatewayIntents.GUILD_PRESENCES |
+  Discord.GatewayIntents.GUILD_MEMBERS |
+  Discord.GatewayIntents.MESSAGE_CONTENT
 
 /**
  * Un-privileged intents