dfx 0.42.1 → 0.42.3

package/src/Helpers/interactions.ts

@@ -0,0 +1,229 @@
+import { Option as Maybe, Product } from "@effect/data/Option"
+import * as Arr from "@effect/data/ReadonlyArray"
+
+/**
+ * Maybe find a sub-command within the interaction options.
+ */
+export const allSubCommands = (interaction: Discord.ApplicationCommandDatum) =>
+  pipe(
+    optionsWithNested(interaction),
+    Arr.filter(
+      o => o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND,
+    ),
+  )
+
+/**
+ * Maybe find a sub-command within the interaction options.
+ */
+export const findSubCommand =
+  (name: string) => (interaction: Discord.ApplicationCommandDatum) =>
+    pipe(
+      optionsWithNested(interaction),
+      Arr.findFirst(
+        o =>
+          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
+          o.name === name,
+      ),
+    )
+
+/**
+ * If the sub-command exists return `true`, else `false`.
+ */
+export const isSubCommand = (name: string) =>
+  flow(findSubCommand(name), o => o.isSome())
+
+/**
+ * Maybe get the options for a sub-command
+ */
+export const subCommandOptions = (name: string) =>
+  flow(findSubCommand(name), o => o.flatMapNullable(o => o.options))
+
+/**
+ * A lens for accessing nested options in a interaction.
+ */
+export const optionsWithNested = (
+  data: Pick<Discord.ApplicationCommandDatum, "options">,
+): Discord.ApplicationCommandInteractionDataOption[] => {
+  const optsFromOption = (
+    opt: Discord.ApplicationCommandInteractionDataOption,
+  ): Discord.ApplicationCommandInteractionDataOption[] =>
+    Maybe.fromNullable(opt.options)
+      .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
+      .match(() => [], identity)
+
+  return Maybe.fromNullable(data.options)
+    .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
+    .getOrElse(() => [])
+}
+
+/**
+ * Return the interaction options as a name / value map.
+ */
+export const transformOptions = (
+  options: Discord.ApplicationCommandInteractionDataOption[],
+) =>
+  options.reduce(
+    (map, option) => map.set(option.name, option.value),
+    HashMap.empty<string, string | undefined>(),
+  )
+
+/**
+ * Return the interaction options as a name / value map.
+ */
+export const optionsMap = flow(optionsWithNested, transformOptions)
+
+/**
+ * Try find a matching option from the interaction.
+ */
+export const getOption = (name: string) =>
+  flow(
+    optionsWithNested,
+    Arr.findFirst(o => o.name === name),
+  )
+
+/**
+ * Try find a matching option from the interaction.
+ */
+export const focusedOption = flow(
+  optionsWithNested,
+  Arr.findFirst(o => o.focused === true),
+)
+
+/**
+ * Try find a matching option value from the interaction.
+ */
+export const optionValue = (name: string) =>
+  flow(getOption(name), o => o.flatMapNullable(o => o.value))
+
+/**
+ * Try extract resolved data
+ */
+export const resolved = (data: Discord.Interaction) =>
+  Maybe.fromNullable(data.data).flatMapNullable(
+    a => (a as Discord.ApplicationCommandDatum).resolved,
+  )
+
+/**
+ * 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): Maybe<T> =>
+    Do($ => {
+      const data = $(
+        Maybe.fromNullable(a.data as Discord.ApplicationCommandDatum),
+      )
+      const id = $(
+        getOption(name)(data).flatMapNullable(
+          ({ value }) => value as Discord.Snowflake,
+        ),
+      )
+      const r = $(resolved(a))
+      return $(Maybe.fromNullable(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): Maybe<readonly T[]> =>
+    Do($ => {
+      const values = $(
+        Maybe.fromNullable(
+          a.data as Discord.MessageComponentDatum,
+        ).flatMapNullable(a => a.values as unknown as string[]),
+      )
+      const r = $(resolved(a))
+      return $(
+        Product.productAll(values.map(a => Maybe.fromNullable(f(a as any, r)))),
+      )
+    })
+
+const extractComponents = (c: Discord.Component): Discord.Component[] => {
+  if ("components" in c) {
+    return [...c.components, ...c.components.flatMap(extractComponents)]
+  }
+
+  return []
+}
+
+/**
+ * A lens for accessing the components in a interaction.
+ */
+export const components = (
+  a: Discord.ModalSubmitDatum,
+): Discord.Component[] => [
+  ...a.components,
+  ...a.components.flatMap(extractComponents),
+]
+
+/**
+ * A lens for accessing the components in a interaction.
+ */
+export const componentsWithValue = flow(
+  components,
+  Arr.filter(c => "value" in c && c.value !== undefined),
+)
+
+/**
+ * Return the interaction components as an id / value map.
+ */
+export const transformComponents = (options: Discord.Component[]) =>
+  (options as Discord.TextInput[]).reduce(
+    (map, c) => (c.custom_id ? map.set(c.custom_id, c.value) : map),
+    HashMap.empty<string, string | undefined>(),
+  )
+
+/**
+ * Return the interaction components as an id / value map.
+ */
+export const componentsMap = flow(components, transformComponents)
+
+/**
+ * Try find a matching component from the interaction.
+ */
+export const getComponent = (id: string) =>
+  flow(
+    components,
+    Arr.findFirst(o => (o as Discord.TextInput).custom_id === id),
+  )
+
+/**
+ * Try find a matching component value from the interaction.
+ */
+export const componentValue = (id: string) =>
+  flow(getComponent(id), o =>
+    o.flatMapNullable(o => (o as Discord.TextInput).value),
+  )
+
+export type InteractionResponse =
+  | {
+      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
+      data: Discord.InteractionCallbackMessage
+    }
+  | {
+      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
+      data: Discord.InteractionCallbackMessage
+    }
+  | {
+      type: Discord.InteractionCallbackType.MODAL
+      data: Discord.InteractionCallbackModal
+    }
+  | {
+      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+    }
+  | {
+      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+    }
+  | {
+      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
+      data: Discord.InteractionCallbackAutocomplete
+    }
+
+export const response = (r: InteractionResponse) => r

package/src/Helpers/members.ts

@@ -0,0 +1,14 @@
+/**
+ * From a list of roles, filter out the ones the guild member has.
+ */
+export const roles = (roles: Discord.Role[]) => (member: Discord.GuildMember) =>
+  roles.filter(
+    role => member.roles.includes(role.id) || role.name === "@everyone",
+  )
+
+/**
+ * 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")

package/src/Helpers/permissions.ts

@@ -0,0 +1,140 @@
+import * as Flags from "dfx/Helpers/flags"
+import * as Members from "dfx/Helpers/members"
+
+/**
+ * A constant of all the permissions
+ */
+export const ALL = Flags.all(Discord.PermissionFlag)
+
+/**
+ * Check if a flag exists in the permissions.
+ */
+export const has = Flags.hasBigInt
+
+/**
+ * Convert a permissions bitfield to a list of flag names.
+ */
+export const toList = Flags.toList(Discord.PermissionFlag)
+
+/**
+ * Convert a list of flag names to a bitfield.
+ */
+export const fromList = Flags.fromListBigint(Discord.PermissionFlag)
+
+/**
+ * Reduce a list of roles to a bitfield of all the permissions added together.
+ */
+export const forRoles = (roles: Discord.Role[]) =>
+  roles.reduce(
+    (permissions, role) => permissions | BigInt(role.permissions),
+    BigInt(0),
+  )
+
+/**
+ * From a list of roles, calculate the permissions bitfield for the member.
+ */
+export const forMember =
+  (roles: Discord.Role[]) => (member: Discord.GuildMember) =>
+    pipe(Members.roles(roles)(member), forRoles)
+
+const overwriteIsForMember =
+  (guildId?: string) =>
+  (member: Discord.GuildMember) =>
+  (overwrite: Discord.Overwrite) => {
+    if (overwrite.type === 0) {
+      return overwrite.id === guildId || member.roles.includes(overwrite.id)
+    }
+    return overwrite.id === member.user?.id
+  }
+
+const overwriteIsForRole =
+  (guildId?: string) =>
+  (role: Discord.Role) =>
+  (overwrite: Discord.Overwrite) => {
+    if (overwrite.type === 0) {
+      return overwrite.id === guildId || overwrite.id === role.id
+    }
+
+    return false
+  }
+
+/**
+ * From a list of roles and a channel, calculate the permission bitfield for
+ * the guild member or role for that channel.
+ */
+export const forChannel =
+  (roles: Discord.Role[]) =>
+  ({ guild_id, permission_overwrites: overwrites = [] }: Discord.Channel) =>
+  (memberOrRole: Discord.GuildMember | Discord.Role) => {
+    const hasAdmin = has(Discord.PermissionFlag.ADMINISTRATOR)
+    let basePermissions: bigint
+    let filteredOverwrites: Discord.Overwrite[]
+
+    if (Members.is(memberOrRole)) {
+      if (memberOrRole.permissions) return BigInt(memberOrRole.permissions)
+
+      const memberRoles = Members.roles(roles)(memberOrRole)
+      basePermissions = forRoles(memberRoles)
+      filteredOverwrites = overwrites.filter(
+        overwriteIsForMember(guild_id)(memberOrRole),
+      )
+    } else {
+      const everyone = roles.find(role => role.name === "@everyone")
+
+      basePermissions =
+        BigInt(everyone?.permissions || "0") | BigInt(memberOrRole.permissions)
+      filteredOverwrites = overwrites.filter(
+        overwriteIsForRole(guild_id)(memberOrRole),
+      )
+    }
+
+    if (hasAdmin(basePermissions)) {
+      return ALL
+    }
+
+    return applyOverwrites(basePermissions)(filteredOverwrites)
+  }
+
+/**
+ * Apply permission overwrites to a bitfield.
+ */
+export const applyOverwrites =
+  (permissions: bigint) => (overwrites: Discord.Overwrite[]) =>
+    overwrites.reduce(
+      (permissions, overwrite) =>
+        (permissions & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
+      permissions,
+    )
+
+interface RolesCache<E> {
+  getForParent: (
+    parentId: string,
+  ) => Effect<never, E, ReadonlyMap<string, Discord.Role>>
+}
+
+export const hasInChannel =
+  <E>(rolesCache: RolesCache<E>, permission: bigint) =>
+  (
+    channel: Discord.Channel,
+    memberOrRole: Discord.GuildMember | Discord.Role,
+  ) =>
+    Do($ => {
+      const roles = $(rolesCache.getForParent(channel.guild_id!))
+      const channelPerms = forChannel([...roles.values()])(channel)(
+        memberOrRole,
+      )
+      return has(permission)(channelPerms)
+    })
+
+export const hasInGuild =
+  <E>(rolesCache: RolesCache<E>, permission: bigint) =>
+  (guildId: Discord.Snowflake, member: Discord.GuildMember) =>
+    Do($ => {
+      const roles = $(rolesCache.getForParent(guildId))
+      const hasPerm = has(permission)
+
+      return member.roles.some(id => {
+        const role = roles.get(id)
+        return role ? hasPerm(role.permissions) : false
+      })
+    })

package/src/Helpers/ui.ts

@@ -0,0 +1,103 @@
+import {
+  ActionRow,
+  Button,
+  ButtonStyle,
+  Component,
+  ComponentType,
+  SelectMenu,
+  SelectOption,
+  TextInput,
+  TextInputStyle,
+} from "../types.js"
+
+export type UIComponent = Exclude<Component, ActionRow>
+
+/**
+ * Helper to create an Action Row grid.
+ */
+export const grid = (items: UIComponent[][]): ActionRow[] =>
+  items.map(
+    (components): ActionRow => ({
+      type: ComponentType.ACTION_ROW,
+      components,
+    }),
+  )
+
+/**
+ * Helper to create a single column of components
+ */
+export const singleColumn = (items: UIComponent[]): ActionRow[] =>
+  items.map(c => ({
+    type: ComponentType.ACTION_ROW,
+    components: [c],
+  }))
+
+/**
+ * Helper to create a button component.
+ */
+export const button = (button: Partial<Button>): Button => ({
+  type: ComponentType.BUTTON,
+  style: ButtonStyle.PRIMARY,
+  ...button,
+})
+
+type BasicSelect = Omit<SelectMenu, "type" | "channel_types" | "options">
+
+type StringSelect = BasicSelect & {
+  options: SelectOption[]
+}
+
+type ChannelSelect = Omit<SelectMenu, "type" | "options">
+
+/**
+ * Helper to create a select component.
+ */
+export const select = (select: StringSelect): SelectMenu => ({
+  type: ComponentType.STRING_SELECT,
+  ...select,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const userSelect = (select: BasicSelect): SelectMenu => ({
+  type: ComponentType.USER_SELECT,
+  ...select,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const roleSelect = (select: BasicSelect): SelectMenu => ({
+  type: ComponentType.ROLE_SELECT,
+  ...select,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const mentionableSelect = (select: BasicSelect): SelectMenu => ({
+  type: ComponentType.MENTIONABLE_SELECT,
+  ...select,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const channelSelect = (select: ChannelSelect): SelectMenu => ({
+  type: ComponentType.CHANNEL_SELECT,
+  ...select,
+})
+
+type TextInputOpts = Omit<TextInput, "type" | "style"> & {
+  style?: TextInputStyle
+}
+
+/**
+ * Helper to create a text input
+ */
+export const textInput = (input: TextInputOpts): TextInput => ({
+  type: ComponentType.TEXT_INPUT,
+  style: TextInputStyle.SHORT,
+  ...input,
+})

package/src/Interactions/context.ts

@@ -0,0 +1,132 @@
+import * as Arr from "@effect/data/ReadonlyArray"
+import { Effect, EffectTypeId } from "@effect/io/Effect"
+import * as IxHelpers from "dfx/Helpers/interactions"
+import { ModalSubmitDatum } from "dfx/types"
+
+export const Interaction = Tag<Discord.Interaction>()
+export const ApplicationCommand = Tag<Discord.ApplicationCommandDatum>()
+export const MessageComponentData = Tag<Discord.MessageComponentDatum>()
+export const ModalSubmitData = Tag<Discord.ModalSubmitDatum>()
+
+export interface FocusedOptionContext {
+  readonly focusedOption: Discord.ApplicationCommandInteractionDataOption
+}
+export const FocusedOptionContext = Tag<FocusedOptionContext>()
+
+export interface SubCommandContext {
+  readonly command: Discord.ApplicationCommandInteractionDataOption
+}
+export const SubCommandContext = Tag<SubCommandContext>()
+
+export class ResolvedDataNotFound {
+  readonly _tag = "ResolvedDataNotFound"
+  constructor(readonly data: Discord.Interaction, readonly name?: string) {}
+}
+
+export const resolvedValues = <A>(
+  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
+) =>
+  Interaction.flatMap(ix =>
+    IxHelpers.resolveValues(f)(ix).mapError(() => new ResolvedDataNotFound(ix)),
+  )
+
+export const resolved = <A>(
+  name: string,
+  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
+) =>
+  Interaction.flatMap(ix =>
+    IxHelpers.resolveOptionValue(
+      name,
+      f,
+    )(ix).mapError(() => new ResolvedDataNotFound(ix, name)),
+  )
+
+export const focusedOptionValue = FocusedOptionContext.map(
+  _ => _.focusedOption.value ?? "",
+)
+
+export class SubCommandNotFound {
+  readonly _tag = "SubCommandNotFound"
+  constructor(readonly data: Discord.ApplicationCommandDatum) {}
+}
+
+export const handleSubCommands = <
+  NER extends Record<string, Effect<any, any, Discord.InteractionResponse>>,
+>(
+  commands: NER,
+): Effect<
+  | Exclude<
+      [NER[keyof NER]] extends [
+        { [EffectTypeId]: { _R: (_: never) => infer R } },
+      ]
+        ? R
+        : never,
+      SubCommandContext
+    >
+  | Discord.Interaction
+  | Discord.ApplicationCommandDatum,
+  | ([NER[keyof NER]] extends [
+      { [EffectTypeId]: { _E: (_: never) => infer E } },
+    ]
+      ? E
+      : never)
+  | SubCommandNotFound,
+  Discord.InteractionResponse
+> =>
+  ApplicationCommand.flatMap(data =>
+    Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name])
+      .mapError(() => new SubCommandNotFound(data))
+      .flatMap(command =>
+        commands[command.name].provideService(SubCommandContext, {
+          command,
+        }),
+      ),
+  )
+
+export const currentSubCommand = SubCommandContext.map(_ => _.command)
+
+export const optionsMap = ApplicationCommand.map(IxHelpers.optionsMap)
+
+export class RequiredOptionNotFound {
+  readonly _tag = "RequiredOptionNotFound"
+  constructor(
+    readonly data:
+      | Discord.ApplicationCommandDatum
+      | Discord.ApplicationCommandInteractionDataOption,
+    readonly name: string,
+  ) {}
+}
+
+export const option = (name: string) =>
+  ApplicationCommand.map(IxHelpers.getOption(name))
+
+export const optionValue = (name: string) =>
+  option(name).flatMap(_ =>
+    _.flatMapNullable(a => a.value).match(
+      () =>
+        ApplicationCommand.flatMap(data =>
+          Effect.fail(new RequiredOptionNotFound(data, name)),
+        ),
+      Effect.succeed,
+    ),
+  )
+
+export const optionValueOptional = (name: string) =>
+  option(name).map(o => o.flatMapNullable(o => o.value))
+
+export const modalValues = ModalSubmitData.map(IxHelpers.componentsMap)
+
+export const modalValueOption = (name: string) =>
+  ModalSubmitData.map(IxHelpers.componentValue(name))
+
+export class ModalValueNotFound {
+  readonly _tag = "ModalValueNotFound"
+  constructor(readonly data: ModalSubmitDatum, readonly name: string) {}
+}
+
+export const modalValue = (name: string) =>
+  ModalSubmitData.flatMap(data =>
+    IxHelpers.componentValue(name)(data).mapError(
+      () => new ModalValueNotFound(data, name),
+    ),
+  )