dfx 0.42.1 → 0.42.3

package/src/Interactions/definitions.ts

@@ -0,0 +1,309 @@
+import { Effect, EffectTypeId } from "@effect/io/Effect"
+import {
+  FocusedOptionContext,
+  ResolvedDataNotFound,
+  SubCommandContext,
+} from "./context.js"
+
+type DescriptionMissing<A> = A extends {
+  type: Exclude<Discord.ApplicationCommandType, 1>
+}
+  ? false
+  : A extends { readonly description: string }
+  ? false
+  : true
+
+export type InteractionDefinition<R, E> =
+  | GlobalApplicationCommand<R, E>
+  | GuildApplicationCommand<R, E>
+  | MessageComponent<R, E>
+  | ModalSubmit<R, E>
+  | Autocomplete<R, E>
+
+export class GlobalApplicationCommand<R, E> {
+  readonly _tag = "GlobalApplicationCommand"
+  constructor(
+    readonly command: Discord.CreateGlobalApplicationCommandParams,
+    readonly handle: CommandHandler<R, E>,
+  ) {}
+}
+
+export const global = <
+  R,
+  E,
+  const A extends DeepReadonly<Discord.CreateGlobalApplicationCommandParams>,
+>(
+  command: A,
+  handle: DescriptionMissing<A> extends true
+    ? "command description is missing"
+    : CommandHandler<R, E, A>,
+) =>
+  new GlobalApplicationCommand<
+    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    E
+  >(command as any, handle as any)
+
+export class GuildApplicationCommand<R, E> {
+  readonly _tag = "GuildApplicationCommand"
+  constructor(
+    readonly command: Discord.CreateGuildApplicationCommandParams,
+    readonly handle: CommandHandler<R, E>,
+  ) {}
+}
+
+export const guild = <
+  R,
+  E,
+  const A extends DeepReadonly<Discord.CreateGuildApplicationCommandParams>,
+>(
+  command: A,
+  handle: DescriptionMissing<A> extends true
+    ? "command description is missing"
+    : CommandHandler<R, E, A>,
+) =>
+  new GuildApplicationCommand<
+    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
+    E
+  >(command as any, handle as any)
+
+export class MessageComponent<R, E> {
+  readonly _tag = "MessageComponent"
+  constructor(
+    readonly predicate: (customId: string) => Effect<R, E, boolean>,
+    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+  ) {}
+}
+
+export const messageComponent = <R1, R2, E1, E2>(
+  pred: (customId: string) => Effect<R1, E1, boolean>,
+  handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
+) =>
+  new MessageComponent<
+    Exclude<R1 | R2, Discord.Interaction | Discord.MessageComponentDatum>,
+    E1 | E2
+  >(pred as any, handle as any)
+
+export class ModalSubmit<R, E> {
+  readonly _tag = "ModalSubmit"
+  constructor(
+    readonly predicate: (customId: string) => Effect<R, E, boolean>,
+    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+  ) {}
+}
+
+export const modalSubmit = <R1, R2, E1, E2>(
+  pred: (customId: string) => Effect<R1, E1, boolean>,
+  handle: Effect<R2, E2, Discord.InteractionResponse>,
+) =>
+  new ModalSubmit<
+    Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
+    E1 | E2
+  >(pred as any, handle as any)
+
+export class Autocomplete<R, E> {
+  readonly _tag = "Autocomplete"
+  constructor(
+    readonly predicate: (
+      data: Discord.ApplicationCommandDatum,
+      focusedOption: Discord.ApplicationCommandInteractionDataOption,
+    ) => Effect<R, E, boolean>,
+    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+  ) {}
+}
+
+export const autocomplete = <R1, R2, E1, E2>(
+  pred: (
+    data: Discord.ApplicationCommandDatum,
+    focusedOption: Discord.ApplicationCommandInteractionDataOption,
+  ) => Effect<R1, E1, boolean>,
+  handle: Effect<R2, E2, Discord.InteractionResponse>,
+) =>
+  new Autocomplete<
+    Exclude<
+      R1 | R2,
+      | Discord.Interaction
+      | Discord.ApplicationCommandDatum
+      | FocusedOptionContext
+    >,
+    E1 | E2
+  >(pred as any, handle as any)
+
+// ==== Command handler helpers
+type DeepReadonly<T> = T extends (infer R)[]
+  ? DeepReadonlyArray<R>
+  : T extends Function
+  ? T
+  : T extends object
+  ? DeepReadonlyObject<T>
+  : T
+
+interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {}
+
+type DeepReadonlyObject<T> = {
+  readonly [P in keyof T]: DeepReadonly<T[P]>
+}
+
+type CommandHandler<R, E, A = any> =
+  | Effect<R, E, Discord.InteractionResponse>
+  | CommandHandlerFn<R, E, A>
+
+export interface CommandHelper<A> {
+  resolve: <T>(
+    name: AllResolvables<A>["name"],
+    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+  ) => Effect<Discord.Interaction, ResolvedDataNotFound, T>
+
+  option: (
+    name: AllCommandOptions<A>["name"],
+  ) => Effect<
+    Discord.ApplicationCommandDatum,
+    never,
+    Maybe<Discord.ApplicationCommandInteractionDataOption>
+  >
+
+  optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
+    name: N,
+  ) => Effect<Discord.ApplicationCommandDatum, never, CommandValue<A, N>>
+
+  optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
+    name: N,
+  ) => Effect<Discord.ApplicationCommandDatum, never, Maybe<CommandValue<A, N>>>
+
+  subCommands: <
+    NER extends SubCommandNames<A> extends never
+      ? never
+      : Record<
+          SubCommandNames<A>,
+          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,
+    Discord.InteractionResponse
+  >
+}
+
+type CommandHandlerFn<R, E, A> = (
+  i: CommandHelper<A>,
+) => Effect<R, E, Discord.InteractionResponse>
+
+interface CommandOption {
+  readonly type: any
+  readonly name: string
+  readonly options?: ReadonlyArray<CommandOption>
+}
+
+// == Sub commands
+type SubCommands<A> = A extends {
+  readonly type: 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,
+  | Discord.ApplicationCommandOptionType.SUB_COMMAND
+  | 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 =
+  | Discord.ApplicationCommandOptionType.ROLE
+  | Discord.ApplicationCommandOptionType.USER
+  | Discord.ApplicationCommandOptionType.MENTIONABLE
+  | 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

package/src/Interactions/gateway.ts

@@ -0,0 +1,71 @@
+import * as Http from "@effect-http/client"
+import { DiscordGateway } from "dfx/DiscordGateway"
+import { DiscordREST, DiscordRESTError } from "dfx/DiscordREST"
+import { DefinitionNotFound, handlers } from "./handlers.js"
+import { Interaction, InteractionBuilder } from "./index.js"
+import { splitDefinitions } from "./utils.js"
+
+export interface RunOpts {
+  sync?: boolean
+}
+
+/**
+ * @tsplus pipeable dfx/InteractionBuilder runGateway
+ */
+export const run =
+  <R, R2, E, E2>(
+    postHandler: (
+      effect: Effect<
+        R | DiscordREST | Discord.Interaction,
+        E | DiscordRESTError | DefinitionNotFound,
+        void
+      >,
+    ) => Effect<R2, E2, void>,
+    { sync = true }: RunOpts = {},
+  ) =>
+  (
+    ix: InteractionBuilder<R, E>,
+  ): Effect<
+    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+    E2 | DiscordRESTError | Http.ResponseDecodeError,
+    never
+  > =>
+    Do($ => {
+      const { GlobalApplicationCommand, GuildApplicationCommand } =
+        splitDefinitions(ix.definitions)
+
+      const gateway = $(DiscordGateway)
+      const rest = $(DiscordREST)
+
+      const application = $(
+        rest.getCurrentBotApplicationInformation().flatMap(a => a.json),
+      )
+
+      const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
+        application.id,
+        { body: Http.body.json(GlobalApplicationCommand.map(a => a.command)) },
+      )
+
+      const guildSync = GuildApplicationCommand.length
+        ? gateway.handleDispatch("GUILD_CREATE", a =>
+            rest.bulkOverwriteGuildApplicationCommands(
+              application.id,
+              a.id,
+              GuildApplicationCommand.map(a => a.command) as any,
+            ),
+          )
+        : Effect.never()
+
+      const handle = handlers(ix.definitions)
+
+      const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
+        pipe(
+          handle[i.type](i).tap(r =>
+            rest.createInteractionResponse(i.id, i.token, r),
+          ),
+          postHandler,
+        ).provideService(Interaction, i),
+      )
+
+      return $(sync ? run.zipParRight(globalSync).zipParRight(guildSync) : run)
+    })

package/src/Interactions/handlers.ts

@@ -0,0 +1,130 @@
+import * as Arr from "@effect/data/ReadonlyArray"
+import * as IxHelpers from "dfx/Helpers/interactions"
+import * as Ctx from "./context.js"
+import * as D from "./definitions.js"
+import { splitDefinitions } from "./utils.js"
+
+export class DefinitionNotFound {
+  readonly _tag = "DefinitionNotFound"
+  constructor(readonly interaction: Discord.Interaction) {}
+}
+
+type Handler<R, E> = Effect<
+  R | Discord.Interaction,
+  E | DefinitionNotFound,
+  Discord.InteractionResponse
+>
+
+const context: D.CommandHelper<any> = {
+  resolve: Ctx.resolved,
+  option: Ctx.option,
+  optionValue: Ctx.optionValue,
+  optionValueOptional: Ctx.optionValueOptional,
+  subCommands: Ctx.handleSubCommands,
+} as any
+
+export const handlers = <R, E>(
+  definitions: D.InteractionDefinition<R, E>[],
+): Record<
+  Discord.InteractionType,
+  (i: Discord.Interaction) => Handler<R, E>
+> => {
+  const { Commands, Autocomplete, MessageComponent, ModalSubmit } =
+    splitDefinitions(definitions)
+
+  return {
+    [Discord.InteractionType.PING]: () =>
+      Effect.succeed({
+        type: Discord.InteractionCallbackType.PONG,
+      } as any),
+
+    [Discord.InteractionType.APPLICATION_COMMAND]: i => {
+      const data = i.data as Discord.ApplicationCommandDatum
+
+      return Maybe.fromNullable(Commands[data.name])
+        .match(
+          () => Effect.fail(new DefinitionNotFound(i)) as Handler<R, E>,
+          command =>
+            Effect.isEffect(command.handle)
+              ? command.handle
+              : command.handle(context),
+        )
+        .provideService(Ctx.ApplicationCommand, data)
+    },
+
+    [Discord.InteractionType.MODAL_SUBMIT]: (i: Discord.Interaction) => {
+      const data = i.data as Discord.ModalSubmitDatum
+
+      return pipe(
+        ModalSubmit,
+        Arr.map(a =>
+          Effect.all({
+            command: Effect.succeed(a),
+            match: a.predicate(data.custom_id),
+          }),
+        ),
+        _ =>
+          Effect.allPar(_)
+            .flatMap(_ =>
+              Arr.findFirst(_, _ => _.match).match(
+                () => Effect.fail(new DefinitionNotFound(i)) as Handler<R, E>,
+                a => a.command.handle,
+              ),
+            )
+            .provideService(Ctx.ModalSubmitData, data),
+      )
+    },
+
+    [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
+      const data = i.data as Discord.MessageComponentDatum
+
+      return pipe(
+        MessageComponent,
+        Arr.map(a =>
+          Effect.all({
+            command: Effect.succeed(a),
+            match: a.predicate(data.custom_id),
+          }),
+        ),
+        _ =>
+          Effect.allPar(_)
+            .flatMap(commands =>
+              Arr.findFirst(commands, _ => _.match).match(
+                () => Effect.fail(new DefinitionNotFound(i)) as Handler<R, E>,
+                _ => _.command.handle,
+              ),
+            )
+            .provideService(Ctx.MessageComponentData, data),
+      )
+    },
+
+    [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
+      const data = i.data as Discord.ApplicationCommandDatum
+
+      return IxHelpers.focusedOption(data)
+        .map(focusedOption =>
+          pipe(
+            Autocomplete,
+            Arr.map(_ =>
+              Effect.all({
+                command: Effect.succeed(_),
+                match: _.predicate(data, focusedOption),
+              }),
+            ),
+            _ =>
+              Effect.allPar(_)
+                .flatMap(_ =>
+                  Arr.findFirst(_, _ => _.match).match(
+                    () =>
+                      Effect.fail(new DefinitionNotFound(i)) as Handler<R, E>,
+                    _ => _.command.handle,
+                  ),
+                )
+                .provideService(Ctx.ApplicationCommand, data)
+                .provideService(Ctx.FocusedOptionContext, { focusedOption }),
+          ),
+        )
+        .getOrElse(() => Effect.fail(new DefinitionNotFound(i)))
+    },
+  }
+}

package/src/Interactions/index.ts

@@ -0,0 +1,108 @@
+import { DiscordREST } from "dfx"
+import { Discord, Effect } from "dfx/_common"
+import * as D from "./definitions.js"
+import * as Http from "@effect-http/client"
+
+export { response } from "../Helpers/interactions.js"
+export * as helpers from "../Helpers/interactions.js"
+export * from "./context.js"
+export {
+  autocomplete,
+  global,
+  guild,
+  InteractionDefinition,
+  messageComponent,
+  modalSubmit,
+} from "./definitions.js"
+
+/**
+ * @tsplus type dfx/InteractionBuilder
+ */
+export class InteractionBuilder<R, E> {
+  constructor(readonly definitions: D.InteractionDefinition<R, E>[]) {}
+
+  add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
+    return new InteractionBuilder<R | R1, E | E1>([
+      ...this.definitions,
+      definition,
+    ])
+  }
+
+  concat<R1, E1>(builder: InteractionBuilder<R1, E1>) {
+    return new InteractionBuilder<R | R1, E | E1>([
+      ...this.definitions,
+      ...builder.definitions,
+    ])
+  }
+
+  get syncGlobal() {
+    const commands = this.definitions
+      .filter(
+        (c): c is D.GlobalApplicationCommand<R, E> =>
+          c._tag === "GlobalApplicationCommand",
+      )
+      .map(c => c.command)
+
+    return DiscordREST.flatMap(rest =>
+      rest
+        .getCurrentBotApplicationInformation()
+        .flatMap(r => r.json)
+        .flatMap(app =>
+          rest.bulkOverwriteGlobalApplicationCommands(app.id, {
+            body: Http.body.json(commands),
+          }),
+        ),
+    )
+  }
+
+  syncGuild(appId: Discord.Snowflake, guildId: Discord.Snowflake) {
+    const commands = this.definitions
+      .filter(
+        (c): c is D.GuildApplicationCommand<R, E> =>
+          c._tag === "GuildApplicationCommand",
+      )
+      .map(c => c.command)
+
+    return DiscordREST.flatMap(rest =>
+      rest.bulkOverwriteGuildApplicationCommands(
+        appId,
+        guildId,
+        commands as any,
+      ),
+    )
+  }
+}
+
+export const builder = new InteractionBuilder<never, never>([])
+
+// Filters
+export const id = (query: string) => (customId: string) =>
+  Effect.succeed(query === customId)
+
+export const idStartsWith = (query: string) => (customId: string) =>
+  Effect.succeed(customId.startsWith(query))
+
+export const idRegex = (query: RegExp) => (customId: string) =>
+  Effect.succeed(query.test(customId))
+
+export const option =
+  (command: string, optionName: string) =>
+  (
+    data: Pick<Discord.ApplicationCommandDatum, "name">,
+    focusedOption: Pick<
+      Discord.ApplicationCommandInteractionDataOption,
+      "name"
+    >,
+  ) =>
+    Effect.succeed(data.name === command && focusedOption.name === optionName)
+
+export const optionOnly =
+  (optionName: string) =>
+  (
+    _: unknown,
+    focusedOption: Pick<
+      Discord.ApplicationCommandInteractionDataOption,
+      "name"
+    >,
+  ) =>
+    Effect.succeed(focusedOption.name === optionName)

package/src/Interactions/utils.ts

@@ -0,0 +1,81 @@
+import * as D from "./definitions.js"
+
+export const splitDefinitions = <R, E>(
+  definitions: D.InteractionDefinition<R, E>[],
+) => {
+  const grouped = definitions.reduce<{
+    [K in D.InteractionDefinition<R, E>["_tag"]]: Extract<
+      D.InteractionDefinition<R, E>,
+      { _tag: K }
+    >[]
+  }>(
+    (acc, a) => ({
+      ...acc,
+      [a._tag]: [...(acc[a._tag] ?? []), a],
+    }),
+    {
+      Autocomplete: [],
+      GlobalApplicationCommand: [],
+      GuildApplicationCommand: [],
+      MessageComponent: [],
+      ModalSubmit: [],
+    },
+  )
+
+  const Commands = [
+    ...grouped.GlobalApplicationCommand,
+    ...grouped.GuildApplicationCommand,
+  ].reduce(
+    (acc, a) => ({
+      ...acc,
+      [a.command.name]: a,
+    }),
+    {} as Record<
+      string,
+      D.GlobalApplicationCommand<R, E> | D.GuildApplicationCommand<R, E>
+    >,
+  )
+
+  return {
+    ...grouped,
+    Commands,
+  }
+}
+const MAP_HEX: Record<string, number> = {
+  0: 0,
+  1: 1,
+  2: 2,
+  3: 3,
+  4: 4,
+  5: 5,
+  6: 6,
+  7: 7,
+  8: 8,
+  9: 9,
+  a: 10,
+  b: 11,
+  c: 12,
+  d: 13,
+  e: 14,
+  f: 15,
+  A: 10,
+  B: 11,
+  C: 12,
+  D: 13,
+  E: 14,
+  F: 15,
+}
+
+export function fromHex(hexString: string) {
+  const bytes = new Uint8Array(Math.floor((hexString || "").length / 2))
+  let i
+  for (i = 0; i < bytes.length; i++) {
+    const a = MAP_HEX[hexString[i * 2]]
+    const b = MAP_HEX[hexString[i * 2 + 1]]
+    if (a === undefined || b === undefined) {
+      break
+    }
+    bytes[i] = (a << 4) | b
+  }
+  return i === bytes.length ? bytes : bytes.slice(0, i)
+}