dfx 0.61.5 → 0.61.6

package/src/DiscordGateway/WS.ts

@@ -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 = (
@@ -38,7 +41,7 @@ const socket = (urlRef: Ref.Ref<string>) =>
         // eslint-disable-next-line no-extra-semi
         ;(ws as any).removeAllListeners?.()
         ws.close()
-      })
+      }),
     ),
   )
 
@@ -72,7 +75,7 @@ const offer = (
             resume(Effect.fail(new WebSocketCloseError(e.code, e.reason)))
           })
         },
-      )
+      ),
     ),
   )
 
@@ -117,7 +120,7 @@ const send = (
     Effect.forever,
   )
 
-const make = Effect.gen(function*(_) {
+const make = Effect.gen(function* (_) {
   const log = yield* _(Log)
 
   const connect = (
@@ -126,7 +129,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 +143,7 @@ const make = Effect.gen(function*(_) {
               ),
             ],
             { concurrency: "unbounded", discard: true },
-          )
+          ),
         ),
         Effect.scoped,
         Effect.retryWhile(isReconnect),

package/src/DiscordGateway.ts

@@ -11,13 +11,14 @@ 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>>) =>
@@ -57,7 +58,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

package/src/Helpers/interactions.ts

@@ -24,8 +24,8 @@ export const findSubCommand =
       optionsWithNested(interaction),
       Arr.findFirst(
         o =>
-          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND
-          && o.name === name,
+          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
+          o.name === name,
       ),
     )
 
@@ -114,42 +114,46 @@ export const resolved = (data: Discord.Interaction) =>
 /**
  * Try find a matching option value from the interaction.
  */
-export const resolveOptionValue = <T>(
-  name: string,
-  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-) =>
-(a: Discord.Interaction): Option.Option<T> =>
-  Option.Do.pipe(
-    Option.bind("data", () =>
-      Option.fromNullable(a.data as Discord.ApplicationCommandDatum)),
-    Option.bind("id", ({ data }) =>
-      Option.flatMapNullable(
-        getOption(name)(data),
-        ({ value }) =>
-          value as Discord.Snowflake,
-      )),
-    Option.bind("r", () => resolved(a)),
-    Option.flatMapNullable(({ id, r }) => f(id, r)),
-  )
+export const resolveOptionValue =
+  <T>(
+    name: string,
+    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+  ) =>
+  (a: Discord.Interaction): Option.Option<T> =>
+    Option.Do.pipe(
+      Option.bind("data", () =>
+        Option.fromNullable(a.data as Discord.ApplicationCommandDatum),
+      ),
+      Option.bind("id", ({ data }) =>
+        Option.flatMapNullable(
+          getOption(name)(data),
+          ({ value }) => value as Discord.Snowflake,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.flatMapNullable(({ id, r }) => f(id, r)),
+    )
 
 /**
  * Try find matching option values from the interaction.
  */
-export const resolveValues = <T>(
-  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-) =>
-(a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
-  Option.Do.pipe(
-    Option.bind("values", () =>
-      Option.flatMapNullable(
-        Option.fromNullable(a.data as Discord.MessageComponentDatum),
-        a => a.values as unknown as Array<string>,
-      )),
-    Option.bind("r", () => resolved(a)),
-    Option.map(({ r, values }) =>
-      Arr.compact(values.map(a => Option.fromNullable(f(a as any, r))))
-    ),
-  )
+export const resolveValues =
+  <T>(
+    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+  ) =>
+  (a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
+    Option.Do.pipe(
+      Option.bind("values", () =>
+        Option.flatMapNullable(
+          Option.fromNullable(a.data as Discord.MessageComponentDatum),
+          a => a.values as unknown as Array<string>,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.map(({ r, values }) =>
+        Arr.compact(values.map(a => Option.fromNullable(f(a as any, r)))),
+      ),
+    )
 
 const extractComponents = (c: Discord.Component): Array<Discord.Component> => {
   if ("components" in c) {
@@ -211,27 +215,26 @@ export const componentValue =
 
 export type InteractionResponse =
   | {
-    type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
-    data: Discord.InteractionCallbackMessage
-  }
+      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
+      data: Discord.InteractionCallbackMessage
+    }
   | {
-    type: Discord.InteractionCallbackType.UPDATE_MESSAGE
-    data: Discord.InteractionCallbackMessage
-  }
+      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
+      data: Discord.InteractionCallbackMessage
+    }
   | {
-    type: Discord.InteractionCallbackType.MODAL
-    data: Discord.InteractionCallbackModal
-  }
+      type: Discord.InteractionCallbackType.MODAL
+      data: Discord.InteractionCallbackModal
+    }
   | {
-    type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
-  }
+      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+    }
   | {
-    type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-  }
+      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+    }
   | {
-    type:
-      Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-    data: Discord.InteractionCallbackAutocomplete
-  }
+      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
+      data: Discord.InteractionCallbackAutocomplete
+    }
 
 export const response = (r: InteractionResponse) => r

package/src/Helpers/members.ts

@@ -13,5 +13,5 @@ export const roles =
  * Type-guard function for checking if the object is a guild member
  */
 export const is = (thing: unknown): thing is Discord.GuildMember =>
-  Object.prototype.hasOwnProperty.call(thing, "roles")
-  && Object.prototype.hasOwnProperty.call(thing, "joined_at")
+  Object.prototype.hasOwnProperty.call(thing, "roles") &&
+  Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/src/Helpers/permissions.ts

@@ -84,8 +84,8 @@ export const forChannel =
     } else {
       const everyone = roles.find(role => role.name === "@everyone")
 
-      basePermissions = BigInt(everyone?.permissions || "0")
-        | BigInt(memberOrRole.permissions)
+      basePermissions =
+        BigInt(everyone?.permissions || "0") | BigInt(memberOrRole.permissions)
       filteredOverwrites = overwrites.filter(
         overwriteIsForRole(guild_id)(memberOrRole),
       )

package/src/Interactions/builder.ts

@@ -8,8 +8,10 @@ import { DiscordREST, type DiscordRESTError } from "dfx/DiscordREST"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
 
-type ExtractTag<A> = A extends { _tag: infer Tag } ? Tag extends string ? Tag
-  : never
+type ExtractTag<A> = A extends { _tag: infer Tag }
+  ? Tag extends string
+    ? Tag
+    : never
   : never
 
 /**
@@ -130,17 +132,15 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(
-      DiscordREST,
-      rest =>
-        rest.getCurrentBotApplicationInformation().pipe(
-          Effect.flatMap(r => r.json),
-          Effect.flatMap(app =>
-            rest.bulkOverwriteGlobalApplicationCommands(app.id, {
-              body: Http.body.unsafeJson(Chunk.toReadonlyArray(commands)),
-            })
-          ),
+    return Effect.flatMap(DiscordREST, rest =>
+      rest.getCurrentBotApplicationInformation().pipe(
+        Effect.flatMap(r => r.json),
+        Effect.flatMap(app =>
+          rest.bulkOverwriteGlobalApplicationCommands(app.id, {
+            body: Http.body.unsafeJson(Chunk.toReadonlyArray(commands)),
+          }),
         ),
+      ),
     )
   }
 
@@ -154,14 +154,12 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(
-      DiscordREST,
-      rest =>
-        rest.bulkOverwriteGuildApplicationCommands(
-          appId,
-          guildId,
-          Chunk.toReadonlyArray(commands) as any,
-        ),
+    return Effect.flatMap(DiscordREST, rest =>
+      rest.bulkOverwriteGuildApplicationCommands(
+        appId,
+        guildId,
+        Chunk.toReadonlyArray(commands) as any,
+      ),
     )
   }
 }

package/src/Interactions/context.ts

@@ -23,7 +23,10 @@ export const SubCommandContext = Tag<SubCommandContext>()
 
 export class ResolvedDataNotFound {
   readonly _tag = "ResolvedDataNotFound"
-  constructor(readonly data: Discord.Interaction, readonly name?: string) {}
+  constructor(
+    readonly data: Discord.Interaction,
+    readonly name?: string,
+  ) {}
 }
 
 export const resolvedValues = <A>(
@@ -33,7 +36,8 @@ export const resolvedValues = <A>(
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
       () => new ResolvedDataNotFound(ix),
-    ))
+    ),
+  )
 
 export const resolved = <A>(
   name: string,
@@ -43,7 +47,8 @@ export const resolved = <A>(
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
       () => new ResolvedDataNotFound(ix, name),
-    ))
+    ),
+  )
 
 export const focusedOptionValue = Effect.map(
   FocusedOptionContext,
@@ -64,18 +69,20 @@ export const handleSubCommands = <
   commands: NER,
 ): Effect.Effect<
   | Exclude<
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-    ] ? R
-      : never,
-    SubCommandContext
-  >
+      [NER[keyof NER]] extends [
+        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
+      ]
+        ? R
+        : never,
+      SubCommandContext
+    >
   | Discord.Interaction
   | Discord.ApplicationCommandDatum,
   | ([NER[keyof NER]] extends [
-    { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-  ] ? E
-    : never)
+      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+    ]
+      ? E
+      : never)
   | SubCommandNotFound,
   Discord.InteractionResponse
 > =>
@@ -84,12 +91,12 @@ export const handleSubCommands = <
       Effect.mapError(
         Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name]),
         () => new SubCommandNotFound(data),
-      )
+      ),
     ),
     Effect.flatMap(command =>
       Effect.provideService(commands[command.name], SubCommandContext, {
         command,
-      })
+      }),
     ),
   )
 
@@ -125,10 +132,12 @@ export const optionValue = (name: string) =>
       {
         onNone: () =>
           Effect.flatMap(ApplicationCommand, data =>
-            Effect.fail(new RequiredOptionNotFound(data, name))),
+            Effect.fail(new RequiredOptionNotFound(data, name)),
+          ),
         onSome: Effect.succeed,
       },
-    ))
+    ),
+  )
 
 export const optionValueOptional = (name: string) =>
   Effect.map(
@@ -143,7 +152,10 @@ export const modalValueOption = (name: string) =>
 
 export class ModalValueNotFound {
   readonly _tag = "ModalValueNotFound"
-  constructor(readonly data: Discord.ModalSubmitDatum, readonly name: string) {}
+  constructor(
+    readonly data: Discord.ModalSubmitDatum,
+    readonly name: string,
+  ) {}
 }
 
 export const modalValue = (name: string) =>
@@ -151,4 +163,5 @@ export const modalValue = (name: string) =>
     Effect.mapError(
       IxHelpers.componentValue(name)(data),
       () => new ModalValueNotFound(data, name),
-    ))
+    ),
+  )