dfx 1.0.4 → 1.0.5

package/dist/src/Helpers/ui.ts

@@ -0,0 +1,253 @@
+import type {
+  ActionRowComponentForMessageRequest,
+  ActionRowComponentForModalRequest,
+  ButtonComponentForMessageRequest,
+  ChannelSelectComponentForMessageRequest,
+  ContainerComponentForMessageRequest,
+  FileComponentForMessageRequest,
+  MediaGalleryComponentForMessageRequest,
+  MentionableSelectComponentForMessageRequest,
+  MessageCreateRequest,
+  PollAnswerCreateRequest,
+  PollCreateRequest,
+  PollMediaCreateRequest,
+  RoleSelectComponentForMessageRequest,
+  SectionComponentForMessageRequest,
+  SeparatorComponentForMessageRequest,
+  StringSelectComponentForMessageRequest,
+  TextDisplayComponentForMessageRequest,
+  TextInputComponentForModalRequest,
+  ThumbnailComponentForMessageRequest,
+  UserSelectComponentForMessageRequest,
+} from "../types.ts"
+import {
+  TextInputStyleTypes,
+  ButtonStyleTypes,
+  MessageComponentTypes,
+  MessageFlags,
+} from "../types.ts"
+
+type ActionRowComponents = ReadonlyArray<
+  | ActionRowComponentForMessageRequest["components"][number]
+  | ActionRowComponentForModalRequest["components"][number]
+>
+
+/**
+ * Helper to create an Action Row.
+ */
+export const row = <const C extends ActionRowComponents>(
+  components: C,
+): {
+  readonly type: typeof MessageComponentTypes.ACTION_ROW
+  readonly components: C
+} => ({
+  type: MessageComponentTypes.ACTION_ROW,
+  components,
+})
+
+/**
+ * Helper to create an Action Row grid.
+ */
+export const grid = <C extends ActionRowComponents>(
+  items: ReadonlyArray<C>,
+): ReadonlyArray<{
+  readonly type: typeof MessageComponentTypes.ACTION_ROW
+  readonly components: C
+}> => items.map(row)
+
+/**
+ * Helper to create a single column of components
+ */
+export const singleColumn = <C extends ActionRowComponents>(
+  items: C,
+): ReadonlyArray<{
+  readonly type: typeof MessageComponentTypes.ACTION_ROW
+  readonly components: C
+}> => items.map(c => row([c as any])) as any
+
+/**
+ * Helper to create a button component.
+ */
+export const button = (
+  options: Partial<ButtonComponentForMessageRequest>,
+): ButtonComponentForMessageRequest => ({
+  type: MessageComponentTypes.BUTTON,
+  style: ButtonStyleTypes.PRIMARY,
+  ...options,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const select = (
+  options: Omit<StringSelectComponentForMessageRequest, "type">,
+): StringSelectComponentForMessageRequest => ({
+  type: MessageComponentTypes.STRING_SELECT,
+  ...options,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const userSelect = (
+  options: Omit<UserSelectComponentForMessageRequest, "type">,
+): UserSelectComponentForMessageRequest => ({
+  type: MessageComponentTypes.USER_SELECT,
+  ...options,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const roleSelect = (
+  options: Omit<RoleSelectComponentForMessageRequest, "type">,
+): RoleSelectComponentForMessageRequest => ({
+  type: MessageComponentTypes.ROLE_SELECT,
+  ...options,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const mentionableSelect = (
+  options: Omit<MentionableSelectComponentForMessageRequest, "type">,
+): MentionableSelectComponentForMessageRequest => ({
+  type: MessageComponentTypes.MENTIONABLE_SELECT,
+  ...options,
+})
+
+/**
+ * Helper to create a select component.
+ */
+export const channelSelect = (
+  options: Omit<ChannelSelectComponentForMessageRequest, "type">,
+): ChannelSelectComponentForMessageRequest => ({
+  type: MessageComponentTypes.CHANNEL_SELECT,
+  ...options,
+})
+
+type TextInputOpts = Omit<
+  TextInputComponentForModalRequest,
+  "type" | "style"
+> & {
+  style?: TextInputStyleTypes
+}
+
+/**
+ * Helper to create a text input
+ */
+export const textInput = (
+  input: TextInputOpts,
+): TextInputComponentForModalRequest => ({
+  type: MessageComponentTypes.TEXT_INPUT,
+  style: TextInputStyleTypes.SHORT,
+  ...input,
+})
+
+/**
+ * Helper to create a poll
+ */
+export const poll = (
+  input: Omit<PollCreateRequest, "answers"> & {
+    readonly answers: ReadonlyArray<PollMediaCreateRequest>
+  },
+): PollCreateRequest => ({
+  ...input,
+  answers: input.answers.map(
+    poll_media => ({ poll_media }) as PollAnswerCreateRequest,
+  ),
+})
+
+/**
+ * Helper to create a media gallery
+ */
+export const mediaGallery = (
+  options: Omit<MediaGalleryComponentForMessageRequest, "type">,
+): MediaGalleryComponentForMessageRequest => ({
+  type: MessageComponentTypes.MEDIA_GALLERY,
+  ...options,
+})
+
+/**
+ * Helper to create a file component
+ */
+export const file = (
+  options: Omit<FileComponentForMessageRequest, "type">,
+): FileComponentForMessageRequest => ({
+  type: MessageComponentTypes.FILE,
+  ...options,
+})
+
+/**
+ * Helper to create a container component
+ */
+export const container = (
+  options: Omit<ContainerComponentForMessageRequest, "type">,
+): ContainerComponentForMessageRequest => ({
+  type: MessageComponentTypes.CONTAINER,
+  ...options,
+})
+
+/**
+ * Helper to create a section component
+ */
+export const section = (
+  options: Omit<SectionComponentForMessageRequest, "type">,
+): SectionComponentForMessageRequest => ({
+  type: MessageComponentTypes.SECTION,
+  ...options,
+})
+
+/**
+ * Helper to create a thumbnail component
+ */
+export const thumbnail = (options: {
+  readonly url: string
+  readonly description?: string | undefined
+  readonly spoiler?: boolean | undefined
+}): ThumbnailComponentForMessageRequest => ({
+  type: MessageComponentTypes.THUMBNAIL,
+  description: options.description,
+  spoiler: options.spoiler,
+  media: { url: options.url },
+})
+
+/**
+ * Helper to create a separator component
+ */
+export const seperator = (
+  options?: Omit<SeparatorComponentForMessageRequest, "type">,
+): SeparatorComponentForMessageRequest => ({
+  type: MessageComponentTypes.SEPARATOR,
+  ...options,
+})
+
+/**
+ * Helper to create a text display component
+ */
+export const textDisplay = (
+  content: string,
+): TextDisplayComponentForMessageRequest => ({
+  type: MessageComponentTypes.TEXT_DISPLAY,
+  content,
+})
+
+type MessageComponents = NonNullable<MessageCreateRequest["components"]>[number]
+
+/**
+ * Create a components v2 message
+ */
+export const components = <const C extends ReadonlyArray<MessageComponents>>(
+  items: C,
+  options?: {
+    readonly ephemeral?: boolean | undefined
+  },
+): {
+  readonly flags: MessageFlags
+  readonly components: C
+} => ({
+  flags: options?.ephemeral
+    ? MessageFlags.Ephemeral | MessageFlags.IsComponentsV2
+    : MessageFlags.IsComponentsV2,
+  components: items,
+})

package/dist/src/Interactions/builder.ts

@@ -0,0 +1,171 @@
+import * as Chunk from "effect/Chunk"
+import { identity } from "effect/Function"
+import type * as Cause from "effect/Cause"
+import * as Effect from "effect/Effect"
+import { catchTag } from "effect/Effect"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
+import type * as D from "./definitions.ts"
+import type * as Discord from "../types.ts"
+
+type ExtractTag<A> = A extends { _tag: infer Tag }
+  ? Tag extends string
+    ? Tag
+    : never
+  : never
+
+export class InteractionBuilder<R, E, TE> {
+  constructor(
+    readonly definitions: Chunk.Chunk<
+      readonly [
+        handler: D.InteractionDefinition<R, E>,
+        transform: (
+          self: Effect.Effect<any, any, any>,
+        ) => Effect.Effect<void, TE, R>,
+      ]
+    >,
+    readonly transform: (
+      self: Effect.Effect<any, any, any>,
+    ) => Effect.Effect<void, TE, R>,
+  ) {}
+
+  add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
+    return new InteractionBuilder<R | R1, E | E1, TE | E1>(
+      Chunk.append(this.definitions, [definition, this.transform] as const),
+      this.transform,
+    )
+  }
+
+  concat<R1, E1, TE1>(builder: InteractionBuilder<R1, E1, TE1>) {
+    return new InteractionBuilder<R | R1, E | E1, TE | TE1>(
+      Chunk.appendAll(this.definitions, builder.definitions),
+      this.transform,
+    )
+  }
+
+  private transformTransform<R1, E1>(
+    f: (selr: Effect.Effect<void, TE, R>) => Effect.Effect<void, E1, R1>,
+  ) {
+    return new InteractionBuilder<R1, E, E1>(
+      Chunk.map(this.definitions, ([d, t]) => [d as any, _ => f(t(_)) as any]),
+      _ => f(this.transform(_)) as any,
+    )
+  }
+
+  private transformHandlers<R1, E1>(
+    f: (
+      self: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
+  ) {
+    return new InteractionBuilder<
+      R1,
+      E1,
+      Exclude<TE, Exclude<E, E1>> | Exclude<E1, E>
+    >(
+      Chunk.map(this.definitions, ([d, t]) => [
+        {
+          ...d,
+          handle: Effect.isEffect(d.handle)
+            ? f(d.handle)
+            : (_: any) => f((d.handle as any)(_)),
+        } as any,
+        t as any,
+      ]),
+      this.transform as any,
+    )
+  }
+
+  catchAllCause<R1, E1>(
+    f: (cause: Cause.Cause<TE>) => Effect.Effect<void, E1, R1>,
+  ) {
+    return this.transformTransform<R | R1, E1>(Effect.catchCause(f))
+  }
+
+  catchAllCauseRespond<R1, E1>(
+    f: (
+      cause: Cause.Cause<E>,
+    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
+  ) {
+    return this.transformHandlers<R | R1, E1>(Effect.catchCause(f))
+  }
+
+  catchAll<R1, E1>(f: (error: TE) => Effect.Effect<void, E1, R1>) {
+    return this.transformTransform<R | R1, E1>(Effect.catch(f))
+  }
+
+  catchAllRespond<R1, E1>(
+    f: (
+      error: E,
+    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
+  ) {
+    return this.transformHandlers<R | R1, E1>(Effect.catch(f))
+  }
+
+  catchTag<T extends ExtractTag<E>, R1, E1>(
+    tag: T,
+    f: (error: Extract<TE, { _tag: T }>) => Effect.Effect<void, E1, R1>,
+  ) {
+    return this.transformTransform<R | R1, Exclude<TE, { _tag: T }> | E1>(
+      _ => catchTag(_ as any, tag, f as any) as any,
+    )
+  }
+
+  catchTagRespond<T extends ExtractTag<E>, R1, E1>(
+    tag: T,
+    f: (
+      error: Extract<E, { _tag: T }>,
+    ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
+  ) {
+    return this.transformHandlers<R | R1, Exclude<E, { _tag: T }> | E1>(
+      _ => catchTag(_ as any, tag, f as any) as any,
+    )
+  }
+
+  get syncGlobal() {
+    const commands = this.definitions.pipe(
+      Chunk.map(([d, _]) => d),
+      Chunk.filter(
+        (c): c is D.GlobalApplicationCommand<R, E> =>
+          c._tag === "GlobalApplicationCommand",
+      ),
+      Chunk.map(c => c.command),
+    )
+
+    return DiscordREST.use(rest =>
+      rest
+        .getMyApplication()
+        .pipe(
+          Effect.flatMap(app =>
+            rest.bulkSetApplicationCommands(
+              app.id,
+              Chunk.toReadonlyArray(commands),
+            ),
+          ),
+        ),
+    )
+  }
+
+  syncGuild(appId: Discord.Snowflake, guildId: Discord.Snowflake) {
+    const commands = this.definitions.pipe(
+      Chunk.map(([d, _]) => d),
+      Chunk.filter(
+        (c): c is D.GuildApplicationCommand<R, E> =>
+          c._tag === "GuildApplicationCommand",
+      ),
+      Chunk.map(c => c.command),
+    )
+
+    return DiscordREST.use(rest =>
+      rest.bulkSetGuildApplicationCommands(
+        appId,
+        guildId,
+        Chunk.toReadonlyArray(commands),
+      ),
+    )
+  }
+}
+
+export const builder = new InteractionBuilder<never, never, DiscordRESTError>(
+  Chunk.empty(),
+  identity as any,
+)

package/dist/src/Interactions/commandHelper.ts

@@ -0,0 +1,231 @@
+import * as Option from "effect/Option"
+import * as Effect from "effect/Effect"
+import {
+  type DiscordSubCommand,
+  SubCommandContext,
+  SubCommandNotFound,
+  type DiscordApplicationCommand,
+  type DiscordInteraction,
+} from "./context.ts"
+import type * as Discord from "../types.ts"
+import * as Helpers from "../Helpers/interactions.ts"
+import * as Arr from "effect/Array"
+import type { HashMap } from "effect/HashMap"
+
+export class CommandHelper<A> {
+  constructor(readonly interaction: Discord.APIInteraction) {
+    this.target = Helpers.target(interaction.data as any) as any
+    this.data = interaction.data as any
+  }
+  readonly data: Discord.APIApplicationCommandInteraction["data"]
+  readonly target: CommandTypeMap<
+    A,
+    {
+      [Discord.ApplicationCommandType
+        .CHAT]: Discord.APIChatInputApplicationCommandGuildInteraction["data"]
+      [Discord.ApplicationCommandType.MESSAGE]: Discord.MessageResponse
+      [Discord.ApplicationCommandType.USER]: Discord.UserResponse
+      [Discord.ApplicationCommandType.PRIMARY_ENTRY_POINT]: undefined
+    }
+  >
+
+  resolve<T>(
+    name: AllResolvables<A>["name"],
+    f: (
+      id: Discord.Snowflake,
+      data: Discord.InteractionDataResolved,
+    ) => T | undefined,
+  ): Option.Option<T> {
+    return Helpers.resolveOptionValue(name, f)(this.interaction)
+  }
+
+  resolvedValues<T>(
+    f: (
+      id: Discord.Snowflake,
+      data: Discord.InteractionDataResolved,
+    ) => T | undefined,
+  ): Option.Option<ReadonlyArray<T>> {
+    return Helpers.resolveValues(f)(this.interaction)
+  }
+
+  option(
+    name: AllCommandOptions<A>["name"],
+  ): Option.Option<Discord.APIApplicationCommandInteractionDataOption> {
+    return Helpers.getOption(name)(this.data as any)
+  }
+
+  optionValue<N extends AllRequiredCommandOptions<A>["name"]>(
+    name: N,
+  ): CommandValue<A, N> {
+    return Option.getOrThrow(this.optionValueOptional(name))
+  }
+
+  optionValueOptional<N extends AllCommandOptions<A>["name"]>(
+    name: N,
+  ): Option.Option<CommandValue<A, N>> {
+    return Option.map(this.option(name), _ => (_ as any).value) as any
+  }
+
+  optionValueOrElse<N extends AllCommandOptions<A>["name"], const OrElse>(
+    name: N,
+    orElse: () => OrElse,
+  ): CommandValue<A, N> {
+    return Option.getOrElse(this.optionValueOptional(name), orElse) as any
+  }
+
+  subCommands<
+    NER extends SubCommandNames<A> extends never
+      ? never
+      : Record<
+          SubCommandNames<A>,
+          Effect.Effect<Discord.CreateInteractionResponseRequest, any, any>
+        >,
+  >(
+    commands: NER,
+  ): Effect.Effect<
+    Effect.Success<NER[keyof NER]>,
+    Effect.Error<NER[keyof NER]>,
+    | Exclude<Effect.Services<NER[keyof NER]>, DiscordSubCommand>
+    | DiscordInteraction
+    | DiscordApplicationCommand
+  > {
+    const commands_ = commands as Record<string, any>
+    const matchedCommand = Arr.findFirst(
+      Helpers.allSubCommands(this.data),
+      _ => !!commands_[_.name],
+    )
+
+    return Option.match(matchedCommand, {
+      onNone: () => Effect.fail(new SubCommandNotFound({ data: this.data })),
+      onSome: subCommand =>
+        Effect.provideService(commands_[subCommand.name], SubCommandContext, {
+          command: subCommand,
+        }),
+    }) as any
+  }
+
+  get optionsMap(): HashMap<string, string | undefined> {
+    return Helpers.optionsMap(this.data as any)
+  }
+}
+
+export type CommandHandlerFn<R, E, A> = (
+  i: CommandHelper<A>,
+) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>
+
+interface CommandOption {
+  readonly type: any
+  readonly name: string
+  readonly options?: ReadonlyArray<CommandOption>
+}
+
+type CommandTypeMap<
+  A,
+  Options extends Record<Discord.ApplicationCommandType, any>,
+> = A extends { readonly type: infer T }
+  ? T extends keyof Options
+    ? Options[T]
+    : never
+  : Options[typeof Discord.ApplicationCommandType.CHAT]
+
+// == Sub commands
+type SubCommands<A> = A extends {
+  readonly type: typeof Discord.ApplicationCommandOptionType.SUB_COMMAND
+  readonly options?: ReadonlyArray<CommandOption>
+}
+  ? A
+  : A extends { readonly options: ReadonlyArray<CommandOption> }
+    ? SubCommands<A["options"][number]>
+    : never
+
+type SubCommandNames<A> = Option<SubCommands<A>>["name"]
+
+// == Command options
+type CommandOptionType = Exclude<
+  Discord.ApplicationCommandOptionType,
+  | typeof Discord.ApplicationCommandOptionType.SUB_COMMAND
+  | typeof Discord.ApplicationCommandOptionType.SUB_COMMAND_GROUP
+>
+
+type CommandOptions<A> = OptionsWithLiteral<
+  A,
+  {
+    readonly type: CommandOptionType
+  }
+>
+
+type SubCommandOptions<A> = Extract<
+  Option<Exclude<SubCommands<A>["options"], undefined>[number]>,
+  {
+    readonly type: CommandOptionType
+  }
+>
+
+type AllCommandOptions<A> = CommandOptions<A> | SubCommandOptions<A>
+
+type CommandWithName<A, N> = Extract<AllCommandOptions<A>, { readonly name: N }>
+
+type OptionTypeValue = {
+  [Discord.ApplicationCommandOptionType.BOOLEAN]: boolean
+  [Discord.ApplicationCommandOptionType.INTEGER]: number
+  [Discord.ApplicationCommandOptionType.NUMBER]: number
+}
+type CommandValue<A, N> = CommandWithName<
+  A,
+  N
+>["type"] extends keyof OptionTypeValue
+  ? OptionTypeValue[CommandWithName<A, N>["type"]]
+  : string
+
+// == Required options
+type RequiredCommandOptions<A> = OptionsWithLiteral<
+  A,
+  {
+    readonly type: CommandOptionType
+    readonly required: true
+  }
+>
+
+type RequiredSubCommandOptions<A> = Extract<
+  SubCommandOptions<A>,
+  { readonly required: true }
+>
+
+type AllRequiredCommandOptions<A> =
+  | RequiredCommandOptions<A>
+  | RequiredSubCommandOptions<A>
+
+// == Resolveables
+type ResolvableType =
+  | typeof Discord.ApplicationCommandOptionType.ROLE
+  | typeof Discord.ApplicationCommandOptionType.USER
+  | typeof Discord.ApplicationCommandOptionType.MENTIONABLE
+  | typeof Discord.ApplicationCommandOptionType.CHANNEL
+
+type Resolvables<A> = OptionsWithLiteral<A, { readonly type: ResolvableType }>
+type SubCommandResolvables<A> = Extract<
+  Option<Exclude<SubCommands<A>["options"], undefined>[number]>,
+  {
+    readonly type: ResolvableType
+  }
+>
+type AllResolvables<A> = Resolvables<A> | SubCommandResolvables<A>
+
+// == Utilities
+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
+  : never
+
+type OptionsWithLiteral<A, T> = A extends {
+  readonly options: ReadonlyArray<CommandOption>
+}
+  ? Extract<A["options"][number], Option<A["options"][number]> & T>
+  : never