dfx 0.60.0 → 0.61.0

package/src/Helpers/interactions.ts

@@ -1,8 +1,8 @@
+import { identity, pipe } from "@effect/data/Function"
+import * as HashMap from "@effect/data/HashMap"
 import * as Option from "@effect/data/Option"
 import * as Arr from "@effect/data/ReadonlyArray"
 import * as Discord from "dfx/types"
-import { identity, pipe } from "@effect/data/Function"
-import * as HashMap from "@effect/data/HashMap"
 
 /**
  * Option find a sub-command within the interaction options.
@@ -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,46 +114,42 @@ 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) {
@@ -215,26 +211,27 @@ 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

@@ -5,13 +5,11 @@ import type * as Cause from "@effect/io/Cause"
 import * as Effect from "@effect/io/Effect"
 import { catchTag } from "@effect/io/Effect"
 import { DiscordREST, type DiscordRESTError } from "dfx/DiscordREST"
-import type * as Discord from "dfx/types"
 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
 
 /**
@@ -132,15 +130,17 @@ 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.json(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.json(Chunk.toReadonlyArray(commands)),
+            })
+          ),
         ),
-      ),
     )
   }
 
@@ -154,12 +154,14 @@ 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

@@ -33,8 +33,7 @@ export const resolvedValues = <A>(
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
       () => new ResolvedDataNotFound(ix),
-    ),
-  )
+    ))
 
 export const resolved = <A>(
   name: string,
@@ -44,8 +43,7 @@ export const resolved = <A>(
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
       () => new ResolvedDataNotFound(ix, name),
-    ),
-  )
+    ))
 
 export const focusedOptionValue = Effect.map(
   FocusedOptionContext,
@@ -66,20 +64,18 @@ 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
 > =>
@@ -88,12 +84,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,
-      }),
+      })
     ),
   )
 
@@ -129,12 +125,10 @@ 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(
@@ -157,5 +151,4 @@ export const modalValue = (name: string) =>
     Effect.mapError(
       IxHelpers.componentValue(name)(data),
       () => new ModalValueNotFound(data, name),
-    ),
-  )
+    ))

package/src/Interactions/definitions.ts

@@ -25,7 +25,9 @@ export class GlobalApplicationCommand<R, E> {
 export const global = <
   R,
   E,
-  const A extends DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>,
+  const A extends DeepReadonlyObject<
+    Discord.CreateGlobalApplicationCommandParams
+  >,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -46,7 +48,9 @@ export class GuildApplicationCommand<R, E> {
 export const guild = <
   R,
   E,
-  const A extends DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>,
+  const A extends DeepReadonlyObject<
+    Discord.CreateGuildApplicationCommandParams
+  >,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -119,12 +123,9 @@ export const autocomplete = <R1, R2, E1, E2>(
   >(pred as any, handle as any)
 
 // ==== Command handler helpers
-type DeepReadonly<T> = T extends Array<infer R>
-  ? ReadonlyArray<DeepReadonly<R>>
-  : T extends Function
-  ? T
-  : T extends object
-  ? DeepReadonlyObject<T>
+type DeepReadonly<T> = T extends Array<infer R> ? ReadonlyArray<DeepReadonly<R>>
+  : T extends Function ? T
+  : T extends object ? DeepReadonlyObject<T>
   : T
 type DeepReadonlyObject<T> = {
   readonly [P in keyof T]: DeepReadonly<T[P]>
@@ -161,29 +162,26 @@ export interface CommandHelper<A> {
   >
 
   subCommands: <
-    NER extends SubCommandNames<A> extends never
-      ? never
+    NER extends SubCommandNames<A> extends never ? never
       : Record<
-          SubCommandNames<A>,
-          Effect.Effect<any, any, Discord.InteractionResponse>
-        >,
+        SubCommandNames<A>,
+        Effect.Effect<any, any, Discord.InteractionResponse>
+      >,
   >(
     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
+    ] ? E
       : never,
     Discord.InteractionResponse
   >
@@ -203,10 +201,9 @@ interface CommandOption {
 type SubCommands<A> = A extends {
   readonly type: Discord.ApplicationCommandOptionType.SUB_COMMAND
   readonly options?: ReadonlyArray<CommandOption>
-}
-  ? A
+} ? A
   : A extends { readonly options: ReadonlyArray<CommandOption> }
-  ? SubCommands<A["options"][number]>
+    ? SubCommands<A["options"][number]>
   : never
 
 type SubCommandNames<A> = Option<SubCommands<A>>["name"]
@@ -283,20 +280,16 @@ type SubCommandResolvables<A> = Extract<
 type AllResolvables<A> = Resolvables<A> | SubCommandResolvables<A>
 
 // == Utilities
-type StringLiteral<T> = T extends string
-  ? string extends T
-    ? never
-    : T
+type StringLiteral<T> = T extends string ? string extends T ? never
+  : T
   : never
 
 type Option<A> = A extends { readonly name: infer N }
-  ? N extends StringLiteral<N>
-    ? A
-    : never
+  ? N extends StringLiteral<N> ? A
+  : never
   : never
 
 type OptionsWithLiteral<A, T> = A extends {
   readonly options: ReadonlyArray<CommandOption>
-}
-  ? Extract<A["options"][number], Option<A["options"][number]> & T>
+} ? Extract<A["options"][number], Option<A["options"][number]> & T>
   : never

package/src/Interactions/gateway.ts

@@ -18,7 +18,7 @@ import type {
 import type { DefinitionNotFound } from "dfx/Interactions/handlers"
 import { handlers } from "dfx/Interactions/handlers"
 import type { InteractionBuilder } from "dfx/Interactions/index"
-import { Interaction, builder } from "dfx/Interactions/index"
+import { builder, Interaction } from "dfx/Interactions/index"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 
@@ -29,86 +29,84 @@ export interface RunOpts {
 /**
  * @tsplus pipeable dfx/InteractionBuilder runGateway
  */
-export const run =
-  <R, R2, E, TE, E2>(
-    postHandler: (
-      effect: Effect.Effect<
-        R | DiscordREST | Discord.Interaction,
-        TE | DiscordRESTError | DefinitionNotFound,
-        void
-      >,
-    ) => Effect.Effect<R2, E2, void>,
-    { sync = true }: RunOpts = {},
-  ) =>
-  (
-    ix: InteractionBuilder<R, E, TE>,
-  ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
-    E2 | DiscordRESTError | Http.ResponseDecodeError,
-    never
-  > =>
-    Effect.gen(function* (_) {
-      const GlobalApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GlobalApplicationCommand<R, E> =>
-            _._tag === "GlobalApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-      const GuildApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GuildApplicationCommand<R, E> =>
-            _._tag === "GuildApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-
-      const gateway = yield* _(DiscordGateway)
-      const rest = yield* _(DiscordREST)
-
-      const application = yield* _(
-        rest.getCurrentBotApplicationInformation(),
-        Effect.flatMap(a => a.json),
-      )
-
-      const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
-        application.id,
-        { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
-      )
-
-      const guildSync = GuildApplicationCommand.length
-        ? gateway.handleDispatch("GUILD_CREATE", a =>
-            rest.bulkOverwriteGuildApplicationCommands(
-              application.id,
-              a.id,
-              GuildApplicationCommand.map(_ => _.command) as any,
-            ),
-          )
-        : Effect.never
-
-      const handle = handlers(ix.definitions, (i, r) =>
-        rest.createInteractionResponse(i.id, i.token, r),
-      )
-
-      const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
-      )
-
-      return yield* _(
-        sync
-          ? Effect.forever(
-              Effect.all([run, globalSync, guildSync], {
-                concurrency: "unbounded",
-                discard: true,
-              }),
-            )
-          : run,
-      )
-    })
-
-const makeRegistry = Effect.gen(function* (_) {
+export const run = <R, R2, E, TE, E2>(
+  postHandler: (
+    effect: Effect.Effect<
+      R | DiscordREST | Discord.Interaction,
+      TE | DiscordRESTError | DefinitionNotFound,
+      void
+    >,
+  ) => Effect.Effect<R2, E2, void>,
+  { sync = true }: RunOpts = {},
+) =>
+(
+  ix: InteractionBuilder<R, E, TE>,
+): Effect.Effect<
+  DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+  E2 | DiscordRESTError | Http.ResponseDecodeError,
+  never
+> =>
+  Effect.gen(function*(_) {
+    const GlobalApplicationCommand = ix.definitions.pipe(
+      Chunk.map(_ => _[0]),
+      Chunk.filter(
+        (_): _ is GlobalApplicationCommand<R, E> =>
+          _._tag === "GlobalApplicationCommand",
+      ),
+      Chunk.toReadonlyArray,
+    )
+    const GuildApplicationCommand = ix.definitions.pipe(
+      Chunk.map(_ => _[0]),
+      Chunk.filter(
+        (_): _ is GuildApplicationCommand<R, E> =>
+          _._tag === "GuildApplicationCommand",
+      ),
+      Chunk.toReadonlyArray,
+    )
+
+    const gateway = yield* _(DiscordGateway)
+    const rest = yield* _(DiscordREST)
+
+    const application = yield* _(
+      rest.getCurrentBotApplicationInformation(),
+      Effect.flatMap(a => a.json),
+    )
+
+    const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
+      application.id,
+      { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
+    )
+
+    const guildSync = GuildApplicationCommand.length
+      ? gateway.handleDispatch("GUILD_CREATE", a =>
+        rest.bulkOverwriteGuildApplicationCommands(
+          application.id,
+          a.id,
+          GuildApplicationCommand.map(_ =>
+            _.command
+          ) as any,
+        ))
+      : Effect.never
+
+    const handle = handlers(ix.definitions, (i, r) =>
+      rest.createInteractionResponse(i.id, i.token, r))
+
+    const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
+      Effect.provideService(postHandler(handle[i.type](i)), Interaction, i))
+
+    return yield* _(
+      sync
+        ? Effect.forever(
+          Effect.all([run, globalSync, guildSync], {
+            concurrency: "unbounded",
+            discard: true,
+          }),
+        )
+        : run,
+    )
+  })
+
+const makeRegistry = Effect.gen(function*(_) {
   const ref = yield* _(
     Ref.make(builder as InteractionBuilder<never, never, never>),
   )
@@ -132,8 +130,7 @@ const makeRegistry = Effect.gen(function* (_) {
       Effect.delay(
         pipe(ix, run(Effect.catchAllCause(onError), opts)),
         Duration.seconds(0.1),
-      ),
-    )
+      ))
 
   return { register, run: run_ } as const
 })