dfx 1.0.4 → 1.0.5

package/dist/src/Helpers/interactions.ts

@@ -0,0 +1,317 @@
+import * as Discord from "../types.ts"
+import * as Arr from "effect/Array"
+import { identity, pipe } from "effect/Function"
+import * as HashMap from "effect/HashMap"
+import * as Option from "effect/Option"
+
+/**
+ * Option find a sub-command within the interaction options.
+ */
+export const allSubCommands = (
+  interaction: Discord.APIApplicationCommandInteraction["data"],
+) =>
+  pipe(
+    optionsWithNested(interaction as any),
+    Arr.filter(
+      o => o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND,
+    ),
+  )
+
+/**
+ * Get the target for the application command data.
+ */
+export const target = (
+  interaction: Discord.APIApplicationCommandInteraction["data"],
+):
+  | Discord.APIApplicationCommandInteraction["data"]
+  | Discord.UserResponse
+  | Discord.MessageResponse => targetTypes[interaction.type](interaction)
+
+const targetTypes: Record<
+  Discord.ApplicationCommandType,
+  (
+    data: any,
+  ) =>
+    | Discord.UserResponse
+    | Discord.MessageResponse
+    | Discord.APIApplicationCommandInteraction["data"]
+> = {
+  [Discord.ApplicationCommandType.USER]: data =>
+    data.resolved.users![(data as any).target_id] as Discord.UserResponse,
+  [Discord.ApplicationCommandType.MESSAGE]: data =>
+    data.resolved.messages![data.target_id],
+  [Discord.ApplicationCommandType.CHAT]: data => data,
+  [Discord.ApplicationCommandType.PRIMARY_ENTRY_POINT]: data => data,
+}
+
+/**
+ * Option find a sub-command within the interaction options.
+ */
+export const findSubCommand =
+  (name: string) =>
+  (interaction: Discord.APIApplicationCommandInteraction["data"]) =>
+    pipe(
+      optionsWithNested(interaction as any),
+      Arr.findFirst(
+        (
+          o,
+        ): o is Discord.APIApplicationCommandInteractionDataSubcommandOption =>
+          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
+          o.name === name,
+      ),
+    )
+
+/**
+ * If the sub-command exists return `true`, else `false`.
+ */
+export const isSubCommand =
+  (name: string) => (_: Discord.APIApplicationCommandInteraction["data"]) =>
+    Option.isSome(findSubCommand(name)(_))
+
+/**
+ * Option get the options for a sub-command
+ */
+export const subCommandOptions =
+  (name: string) => (_: Discord.APIApplicationCommandInteraction["data"]) =>
+    Option.flatMapNullishOr(findSubCommand(name)(_), o => o.options)
+
+/**
+ * A lens for accessing nested options in a interaction.
+ */
+export const optionsWithNested = (data: {
+  readonly options?:
+    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+    | undefined
+}): Array<Discord.APIApplicationCommandInteractionDataOption> => {
+  const optsFromOption = (opt: {
+    readonly options?: ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+  }): Array<Discord.APIApplicationCommandInteractionDataOption> =>
+    Option.fromNullishOr(opt.options).pipe(
+      Option.map(opts => [
+        ...opts,
+        ...opts.flatMap(_ => optsFromOption(_ as any)),
+      ]),
+      Option.match({ onNone: () => [], onSome: identity }),
+    )
+
+  return Option.fromNullishOr(data.options).pipe(
+    Option.map(opts => [
+      ...opts,
+      ...opts.flatMap(_ => optsFromOption(_ as any)),
+    ]),
+    Option.getOrElse(() => []),
+  )
+}
+
+/**
+ * Return the interaction options as a name / value map.
+ */
+export const transformOptions = (
+  options: Array<Discord.APIApplicationCommandInteractionDataOption>,
+) =>
+  options.reduce(
+    (map, option) => HashMap.set(map, option.name, (option as any).value),
+    HashMap.empty<string, string | number | boolean | undefined>(),
+  )
+
+/**
+ * Return the interaction options as a name / value map.
+ */
+export const optionsMap = (data: {
+  readonly options?:
+    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+    | undefined
+}) => transformOptions(optionsWithNested(data))
+
+/**
+ * Try find a matching option from the interaction.
+ */
+export const getOption =
+  (name: string) =>
+  (data: {
+    readonly options?:
+      | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+      | undefined
+  }) =>
+    Arr.findFirst(optionsWithNested(data), o => o.name === name)
+
+/**
+ * Try find a matching option from the interaction.
+ */
+export const focusedOption = (data: {
+  readonly options?:
+    | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+    | undefined
+}) =>
+  Arr.findFirst(
+    optionsWithNested(data),
+    o => "focused" in o && o.focused === true,
+  )
+
+/**
+ * Try find a matching option value from the interaction.
+ */
+export const optionValue =
+  (name: string) =>
+  (data: {
+    readonly options?:
+      | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
+      | undefined
+  }) =>
+    Option.flatMapNullishOr(getOption(name)(data), o =>
+      "value" in o ? o.value : undefined,
+    )
+
+/**
+ * Try extract resolved data
+ */
+export const resolved = (data: Discord.APIInteraction) =>
+  Option.flatMapNullishOr(Option.fromNullishOr(data.data), a =>
+    "resolved" in a
+      ? (a.resolved as Discord.InteractionDataResolved)
+      : undefined,
+  )
+
+/**
+ * Try find a matching option value from the interaction.
+ */
+export const resolveOptionValue =
+  <T>(
+    name: string,
+    f: (
+      id: Discord.Snowflake,
+      data: Discord.InteractionDataResolved,
+    ) => T | undefined,
+  ) =>
+  (a: Discord.APIInteraction): Option.Option<T> =>
+    Option.Do.pipe(
+      Option.bind("data", () => Option.fromNullishOr(a.data as any)),
+      Option.bind("id", ({ data }) =>
+        Option.flatMapNullishOr(
+          getOption(name)(data) as Option.Option<{ value: Discord.Snowflake }>,
+          ({ value }) => value,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.flatMapNullishOr(({ id, r }) => f(id, r)),
+    )
+
+/**
+ * Try find matching option values from the interaction.
+ */
+export const resolveValues =
+  <T>(
+    f: (
+      id: Discord.Snowflake,
+      data: Discord.InteractionDataResolved,
+    ) => T | undefined,
+  ) =>
+  (a: Discord.APIInteraction): Option.Option<ReadonlyArray<T>> =>
+    Option.Do.pipe(
+      Option.bind("values", () =>
+        Option.flatMapNullishOr(
+          Option.fromNullishOr(a.data as any),
+          data => data.values as unknown as Array<string>,
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.map(({ r, values }) =>
+        Arr.getSomes(
+          values.map(value => Option.fromNullishOr(f(value as any, r))),
+        ),
+      ),
+    )
+
+const extractComponents = (
+  c: Discord.AllComponents,
+): Array<Discord.AllComponents> => {
+  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.APIModalSubmission,
+): Array<Discord.AllComponents> => [
+  ...(a.components as any),
+  ...a.components.flatMap(extractComponents as any),
+]
+
+/**
+ * A lens for accessing the components in a interaction.
+ */
+export const componentsWithValue = (data: Discord.APIModalSubmission) =>
+  Arr.filter(components(data), c => "value" in c && c.value !== undefined)
+
+/**
+ * Return the interaction components as an id / value map.
+ */
+export const transformComponents = (options: Array<Discord.AllComponents>) =>
+  (options as Array<Discord.TextInputComponentResponse>).reduce(
+    (map, c) => (c.custom_id ? HashMap.set(map, c.custom_id, c.value) : map),
+    HashMap.empty<string, string | undefined | null>(),
+  )
+
+/**
+ * Return the interaction components as an id / value map.
+ */
+export const componentsMap = (data: Discord.APIModalSubmission) =>
+  transformComponents(components(data))
+
+/**
+ * Try find a matching component from the interaction.
+ */
+export const getComponent =
+  (id: string) => (data: Discord.APIModalSubmission) =>
+    Arr.findFirst(
+      components(data),
+      o => (o as Discord.TextInputComponentResponse).custom_id === id,
+    )
+
+/**
+ * Try find a matching component value from the interaction.
+ */
+export const componentValue =
+  (id: string) => (data: Discord.APIModalSubmission) =>
+    Option.flatMapNullishOr(
+      getComponent(id)(data),
+      o => (o as Discord.TextInputComponentResponse).value,
+    )
+
+export type InteractionResponse =
+  | {
+      type: typeof Discord.InteractionCallbackTypes.CHANNEL_MESSAGE_WITH_SOURCE
+      data: Discord.IncomingWebhookInteractionRequest
+      files?: ReadonlyArray<File>
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.UPDATE_MESSAGE
+      data: Discord.IncomingWebhookUpdateForInteractionCallbackRequestPartial
+      files?: ReadonlyArray<File>
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.MODAL
+      data: Discord.ModalInteractionCallbackRequestData
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.DEFERRED_UPDATE_MESSAGE
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
+      data: Discord.ApplicationCommandAutocompleteCallbackRequest["data"]
+    }
+  | {
+      type: typeof Discord.InteractionCallbackTypes.LAUNCH_ACTIVITY
+    }
+
+export const response = (
+  r: InteractionResponse,
+): Discord.CreateInteractionResponseRequest => r

package/dist/src/Helpers/members.ts

@@ -0,0 +1,18 @@
+import type * as Discord from "../types.ts"
+
+/**
+ * From a list of roles, filter out the ones the guild member has.
+ */
+export const roles =
+  (guildRoles: Array<Discord.GuildRoleResponse>) =>
+  (member: Discord.GuildMemberResponse) =>
+    guildRoles.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.GuildMemberResponse =>
+  Object.prototype.hasOwnProperty.call(thing, "roles") &&
+  Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/dist/src/Helpers/permissions.ts

@@ -0,0 +1,145 @@
+import { pipe } from "effect/Function"
+import * as Effect from "effect/Effect"
+import * as Flags from "./flags.ts"
+import * as Members from "./members.ts"
+import * as Discord from "../types.ts"
+
+/**
+ * A constant of all the permissions
+ */
+export const ALL = Flags.all(Discord.Permissions)
+
+/**
+ * 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.Permissions)
+
+/**
+ * Convert a list of flag names to a bitfield.
+ */
+export const fromList = Flags.fromListBigint(Discord.Permissions)
+
+/**
+ * Reduce a list of roles to a bitfield of all the permissions added together.
+ */
+export const forRoles = (roles: Array<Discord.GuildRoleResponse>) =>
+  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: Array<Discord.GuildRoleResponse>) =>
+  (member: Discord.GuildMemberResponse) =>
+    pipe(Members.roles(roles)(member), forRoles)
+
+const overwriteIsForMember =
+  (guildId?: string) =>
+  (member: Discord.GuildMemberResponse) =>
+  (overwrite: Discord.ChannelPermissionOverwriteResponse) => {
+    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.GuildRoleResponse) =>
+  (overwrite: Discord.ChannelPermissionOverwriteResponse) => {
+    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: Array<Discord.GuildRoleResponse>) =>
+  ({ guild_id, permission_overwrites }: Discord.GuildChannelResponse) =>
+  (memberOrRole: Discord.GuildMemberResponse | Discord.GuildRoleResponse) => {
+    const overwrites = permission_overwrites || []
+    const hasAdmin = has(Discord.Permissions.Administrator)
+    let basePermissions: bigint
+    let filteredOverwrites: Array<Discord.ChannelPermissionOverwriteResponse>
+
+    if (Members.is(memberOrRole)) {
+      if ((memberOrRole as any).permissions)
+        return BigInt((memberOrRole as any).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: ReadonlyArray<Discord.ChannelPermissionOverwriteResponse>) =>
+    overwrites.reduce(
+      (current, overwrite) =>
+        (current & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
+      permissions,
+    )
+
+interface RolesCache<E> {
+  getForParent: (
+    parentId: string,
+  ) => Effect.Effect<ReadonlyMap<string, Discord.GuildRoleResponse>, E>
+}
+
+export const hasInChannel =
+  <E>(rolesCache: RolesCache<E>, permission: bigint) =>
+  (
+    channel: Discord.GuildChannelResponse,
+    memberOrRole: Discord.GuildMemberResponse | Discord.GuildRoleResponse,
+  ) =>
+    Effect.map(rolesCache.getForParent(channel.guild_id!), roles => {
+      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.GuildMemberResponse) =>
+    Effect.map(rolesCache.getForParent(guildId), roles => {
+      const hasPerm = has(permission)
+
+      return member.roles.some(id => {
+        const role = roles.get(id)
+        return role ? hasPerm(role.permissions) : false
+      })
+    })