dfx 0.59.0 → 0.61.0

package/src/Cache/memoryTTL.ts

@@ -160,16 +160,18 @@ export const createWithParent = <T>(opts: MemoryTTLOpts) =>
                       if (item._tag === "None") {
                         ids.delete(id)
                       }
-                    }),
+                    })
                   ),
                   Effect.map(item => [id, item] as const),
                 ),
               { concurrency: "unbounded" },
-            ),
+            )
           ),
           Effect.map(
-            ReadonlyArray.reduce(new Map<string, T>(), (acc, [id, item]) =>
-              item._tag === "Some" ? acc.set(id, item.value) : acc,
+            ReadonlyArray.reduce(
+              new Map<string, T>(),
+              (acc, [id, item]) =>
+                item._tag === "Some" ? acc.set(id, item.value) : acc,
             ),
           ),
           Effect.option,

package/src/Cache/prelude.ts

@@ -32,17 +32,19 @@ export const opsWithParent = <E, T>({
   remove,
   update,
 }: OptsWithParentOptions<E, T>) => {
-  const fromParentOps = Stream.flatMap(fromParent, ([parentId, a]) =>
-    Stream.fromIterable(
-      a.map(
-        (resource): ParentCacheOp<T> => ({
-          op: "create",
-          parentId,
-          resourceId: id(resource),
-          resource,
-        }),
+  const fromParentOps = Stream.flatMap(
+    fromParent,
+    ([parentId, a]) =>
+      Stream.fromIterable(
+        a.map(
+          (resource): ParentCacheOp<T> => ({
+            op: "create",
+            parentId,
+            resourceId: id(resource),
+            resource,
+          }),
+        ),
       ),
-    ),
   )
 
   const createOps = Stream.map(
@@ -129,7 +131,7 @@ export const ops = <E, T>({ create, id, remove, update }: OpsOptions<E, T>) => {
 export const guilds = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, CacheDriver<E, Discord.Guild>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)
@@ -156,7 +158,7 @@ export const guilds = <RM, EM, E>(
 export const channels = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Channel>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)
@@ -199,7 +201,7 @@ export const channels = <RM, EM, E>(
 export const roles = <RM, EM, E>(
   makeDriver: Effect.Effect<RM, EM, ParentCacheDriver<E, Discord.Role>>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const driver = yield* _(makeDriver)
     const gateway = yield* _(DiscordGateway)
     const rest = yield* _(DiscordREST)

package/src/Cache.ts

@@ -1,7 +1,7 @@
-import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
-import * as Effect from "@effect/io/Effect"
 import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 import * as Stream from "@effect/stream/Stream"
+import type { CacheDriver, ParentCacheDriver } from "dfx/Cache/driver"
 
 export * from "dfx/Cache/driver"
 export {
@@ -97,7 +97,7 @@ export const makeWithParent = <EOps, EDriver, EMiss, EPMiss, A>({
                 Effect.all(
                   entries.map(([id, a]) => driver.set(parentId, id, a)),
                   { concurrency: "unbounded" },
-                ),
+                )
               ),
               Effect.map(entries => new Map(entries) as ReadonlyMap<string, A>),
             ),

package/src/DiscordGateway/DiscordWS.ts

@@ -1,10 +1,10 @@
-import { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
-import type WebSocket from "isomorphic-ws"
-import type * as Discord from "dfx/types"
+import { Tag } from "@effect/data/Context"
 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 { LiveWS, Reconnect, WS } from "dfx/DiscordGateway/WS"
+import type * as Discord from "dfx/types"
+import type WebSocket from "isomorphic-ws"
 
 export type Message = Discord.GatewayPayload | Reconnect
 
@@ -28,7 +28,7 @@ export const LiveJsonDiscordWSCodec = Layer.succeed(DiscordWSCodec, {
   decode: p => JSON.parse(p.toString("utf8")),
 })
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const ws = yield* _(WS)
   const encoding = yield* _(DiscordWSCodec)
 
@@ -38,23 +38,22 @@ const make = Effect.gen(function* (_) {
     url = "wss://gateway.discord.gg/",
     version = 10,
   }: OpenOpts) =>
-    Effect.gen(function* (_) {
+    Effect.gen(function*(_) {
       const urlRef = yield* _(
         Ref.make(`${url}?v=${version}&encoding=${encoding.type}`),
       )
       const setUrl = (url: string) =>
         Ref.set(urlRef, `${url}?v=${version}&encoding=${encoding.type}`)
       const takeOutbound = Effect.map(outbound, msg =>
-        msg === Reconnect ? msg : encoding.encode(msg),
-      )
+        msg === Reconnect ? msg : encoding.encode(msg))
       const socket = yield* _(ws.connect(urlRef, takeOutbound, onConnecting))
       const take = Effect.map(socket.take, encoding.decode)
 
       const run = Effect.retryWhile(
         socket.run,
         e =>
-          (e._tag === "WebSocketCloseError" && e.code < 2000) ||
-          (e._tag === "WebSocketError" && e.reason === "open-timeout"),
+          (e._tag === "WebSocketCloseError" && e.code < 2000)
+          || (e._tag === "WebSocketError" && e.reason === "open-timeout"),
       )
 
       return {

package/src/DiscordGateway/Shard/heartbeats.ts

@@ -35,7 +35,7 @@ export const send = (
   seqRef: Ref.Ref<Option.Option<number>>,
   send: (p: DiscordWS.Message) => Effect.Effect<never, never, boolean>,
 ) =>
-  Effect.gen(function* (_) {
+  Effect.gen(function*(_) {
     const ackedRef = yield* _(Ref.make(true))
 
     const heartbeats = EffectU.foreverSwitch(

package/src/DiscordGateway/Shard/utils.ts

@@ -1,8 +1,8 @@
 import * as Option from "@effect/data/Option"
 import * as Effect from "@effect/io/Effect"
 import * as Ref from "@effect/io/Ref"
-import type * as Discord from "dfx/types"
 import * as Stream from "@effect/stream/Stream"
+import type * as Discord from "dfx/types"
 
 export const opCode =
   <R, E>(source: Stream.Stream<R, E, Discord.GatewayPayload>) =>
@@ -13,16 +13,15 @@ export const opCode =
       Stream.filter((p): p is Discord.GatewayPayload<T> => p.op === code),
     )
 
-const maybeUpdateRef =
-  <T>(
-    f: (p: Discord.GatewayPayload) => Option.Option<T>,
-    ref: Ref.Ref<Option.Option<T>>,
-  ) =>
-  (_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
-    Option.match(f(_), {
-      onNone: () => Effect.unit,
-      onSome: a => Ref.set(ref, Option.some(a)),
-    })
+const maybeUpdateRef = <T>(
+  f: (p: Discord.GatewayPayload) => Option.Option<T>,
+  ref: Ref.Ref<Option.Option<T>>,
+) =>
+(_: Discord.GatewayPayload): Effect.Effect<never, never, void> =>
+  Option.match(f(_), {
+    onNone: () => Effect.unit,
+    onSome: a => Ref.set(ref, Option.some(a)),
+  })
 
 export const latest = <T>(
   f: (p: Discord.GatewayPayload) => Option.Option<T>,
@@ -36,6 +35,5 @@ export const latest = <T>(
 > =>
   Effect.map(
     Ref.make<Option.Option<T>>(Option.none()),
-
     ref => [ref, maybeUpdateRef(f, ref)] as const,
   )

package/src/DiscordGateway/Shard.ts

@@ -1,5 +1,14 @@
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as Option from "@effect/data/Option"
+import * as ConfigSecret from "@effect/io/Config/Secret"
+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 { DiscordConfig } from "dfx/DiscordConfig"
-import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
 import type { Message } from "dfx/DiscordGateway/DiscordWS"
 import { DiscordWS, LiveDiscordWS } from "dfx/DiscordGateway/DiscordWS"
 import * as Heartbeats from "dfx/DiscordGateway/Shard/heartbeats"
@@ -8,17 +17,8 @@ import * as InvalidSession from "dfx/DiscordGateway/Shard/invalidSession"
 import * as Utils from "dfx/DiscordGateway/Shard/utils"
 import { Reconnect } from "dfx/DiscordGateway/WS"
 import { Log } from "dfx/Log"
+import { LiveRateLimiter, RateLimiter } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
-import { Tag } from "@effect/data/Context"
-import * as Option from "@effect/data/Option"
-import * as Hub from "@effect/io/Hub"
-import * as Queue from "@effect/io/Queue"
-import * as Ref from "@effect/io/Ref"
-import * as Duration from "@effect/data/Duration"
-import * as Chunk from "@effect/data/Chunk"
-import * as ConfigSecret from "@effect/io/Config/Secret"
 
 const enum Phase {
   Connecting,
@@ -26,7 +26,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 +37,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,15 +52,13 @@ 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)
 
@@ -77,12 +75,12 @@ export const make = Effect.gen(function* (_) {
             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)),
       )
@@ -97,7 +95,7 @@ export const make = Effect.gen(function* (_) {
                 p.op === Discord.GatewayOpcode.DISPATCH && p.t === "READY",
             ),
             Option.map(p => p.d!),
-          ),
+          )
         ),
       )
       const [latestSequence, updateLatestSequence] = yield* _(
@@ -198,4 +196,5 @@ 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/ShardStore.ts

@@ -1,7 +1,7 @@
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
 import { Tag } from "@effect/data/Context"
 import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
 
 export interface ClaimIdContext {
   sharderCount: number

package/src/DiscordGateway/Sharder.ts

@@ -24,7 +24,7 @@ const claimRepeatPolicy = Schedule.fixed("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,7 +33,7 @@ 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 = (
@@ -68,7 +68,7 @@ const make = Effect.gen(function* (_) {
           reset_after: 0,
           max_concurrency: 1,
         },
-      }),
+      })
     ),
   )
 
@@ -76,7 +76,7 @@ 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>(),
       )
@@ -93,10 +93,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 +106,7 @@ const make = Effect.gen(function* (_) {
           ).pipe(
             Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
             Effect.fork,
-          ),
+          )
         ),
         Effect.forever,
       )

package/src/DiscordGateway/WS.ts

@@ -1,12 +1,12 @@
-import { Log } from "dfx/Log"
-import WebSocket from "isomorphic-ws"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
 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 Ref from "@effect/io/Ref"
 import * as Runtime from "@effect/io/Runtime"
-import * as Duration from "@effect/data/Duration"
+import { Log } from "dfx/Log"
+import WebSocket from "isomorphic-ws"
 
 export const Reconnect = Symbol()
 export type Reconnect = typeof Reconnect
@@ -38,7 +38,7 @@ const socket = (urlRef: Ref.Ref<string>) =>
         // eslint-disable-next-line no-extra-semi
         ;(ws as any).removeAllListeners?.()
         ws.close()
-      }),
+      })
     ),
   )
 
@@ -72,7 +72,7 @@ const offer = (
             resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
           })
         },
-      ),
+      )
     ),
   )
 
@@ -117,7 +117,7 @@ const send = (
     Effect.forever,
   )
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const log = yield* _(Log)
 
   const connect = (
@@ -126,7 +126,7 @@ 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(
@@ -140,7 +140,7 @@ const make = Effect.gen(function* (_) {
               ),
             ],
             { concurrency: "unbounded", discard: true },
-          ),
+          )
         ),
         Effect.scoped,
         Effect.retryWhile(isReconnect),

package/src/DiscordGateway.ts

@@ -11,14 +11,13 @@ 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.filter(source, p => p.t === event).pipe(Stream.map(p => p.d! as any))
 
 const handleDispatchFactory =
   (hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>) =>
@@ -58,7 +57,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/types.ts

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

package/src/DiscordREST/utils.ts

@@ -1,5 +1,5 @@
-import * as Option from "@effect/data/Option"
 import * as Duration from "@effect/data/Duration"
+import * as Option from "@effect/data/Option"
 
 const majorResources = ["channels", "guilds", "webhooks"] as const
 
@@ -7,8 +7,10 @@ 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

@@ -17,7 +17,7 @@ import {
   routeFromConfig,
 } from "dfx/DiscordREST/utils"
 import { Log } from "dfx/Log"
-import { LiveRateLimiter, RateLimitStore, RateLimiter } from "dfx/RateLimit"
+import { LiveRateLimiter, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
 
@@ -28,7 +28,7 @@ export class DiscordRESTError {
 
 export { ResponseDecodeError } from "@effect-http/client"
 
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const { rest, token } = yield* _(DiscordConfig)
 
   const http = yield* _(Http.HttpRequestExecutor)
@@ -64,7 +64,7 @@ const make = Effect.gen(function* (_) {
       Effect.tap(invalid =>
         invalid
           ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
-          : Effect.unit,
+          : Effect.unit
       ),
       Effect.asUnit,
     )
@@ -86,7 +86,7 @@ const make = Effect.gen(function* (_) {
                 bucket.limit,
               ),
             ),
-        }),
+        })
       ),
     )
 
@@ -95,8 +95,9 @@ 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 = [
@@ -110,10 +111,9 @@ 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,
             }),
           )
         }
@@ -134,19 +134,20 @@ const make = Effect.gen(function* (_) {
         Http.updateUrl(req, _ => `${rest.baseUrl}${_}`),
         Http.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.executor.catchAll(error =>
       error._tag === "StatusCodeError"
         ? 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))
     ),
   )
 
@@ -194,8 +195,9 @@ 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),
                     ),
                   ),
                 ),
@@ -222,9 +224,9 @@ const make = Effect.gen(function* (_) {
           request = Http.appendParams(request, params as any)
         }
       } else if (
-        params &&
-        request.body._tag === "Some" &&
-        request.body.value._tag === "FormDataBody"
+        params
+        && request.body._tag === "Some"
+        && request.body.value._tag === "FormDataBody"
       ) {
         request.body.value.value.append("payload_json", JSON.stringify(params))
       } else if (params) {
@@ -242,7 +244,8 @@ const make = Effect.gen(function* (_) {
 })
 
 export interface DiscordREST
-  extends Discord.Endpoints<Partial<Http.MakeOptions>> {
+  extends Discord.Endpoints<Partial<Http.MakeOptions>>
+{
   readonly executor: <A = unknown>(
     request: Http.Request,
   ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>

package/src/Helpers/flags.ts

@@ -33,16 +33,14 @@ 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,10 +9,9 @@ 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