dfx 1.0.4 → 1.0.5

package/dist/src/Interactions/context.ts

@@ -0,0 +1,104 @@
+import * as IxHelpers from "../Helpers/interactions.ts"
+import type * as Discord from "../types.ts"
+import type { NoSuchElementError } from "effect/Cause"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as ServiceMap from "effect/ServiceMap"
+
+export class Interaction extends ServiceMap.Service<
+  Interaction,
+  Discord.APIInteraction
+>()("dfx/Interactions/Interaction") {}
+export type DiscordInteraction = Interaction
+
+export class ApplicationCommand extends ServiceMap.Service<
+  ApplicationCommand,
+  Discord.APIApplicationCommandInteraction["data"]
+>()("dfx/Interactions/ApplicationCommand") {}
+export type DiscordApplicationCommand = ApplicationCommand
+
+export class MessageComponentData extends ServiceMap.Service<
+  MessageComponentData,
+  Discord.APIMessageComponentInteractionData
+>()("dfx/Interactions/MessageComponentData") {}
+export type DiscordMessageComponent = MessageComponentData
+
+export class ModalSubmitData extends ServiceMap.Service<
+  ModalSubmitData,
+  Discord.APIModalSubmission
+>()("dfx/Interactions/ModalSubmitData") {}
+export type DiscordModalSubmit = ModalSubmitData
+
+export class FocusedOptionContext extends ServiceMap.Service<
+  FocusedOptionContext,
+  Discord.APIApplicationCommandInteractionDataOption
+>()("dfx/Interactions/FocusedOptionContext") {}
+export type DiscordFocusedOption = FocusedOptionContext
+
+export interface SubCommandContextData {
+  readonly command: Discord.APIApplicationCommandInteractionDataSubcommandOption
+}
+export class SubCommandContext extends ServiceMap.Service<
+  SubCommandContext,
+  SubCommandContextData
+>()("dfx/Interactions/SubCommandContext") {}
+export type DiscordSubCommand = SubCommandContext
+
+export const resolvedValues = <A>(
+  f: (
+    id: Discord.Snowflake,
+    data: Discord.InteractionDataResolved,
+  ) => A | undefined,
+): Effect.Effect<ReadonlyArray<A>, NoSuchElementError, DiscordInteraction> =>
+  Interaction.use(ix => Effect.fromOption(IxHelpers.resolveValues(f)(ix)))
+
+export const resolved = <A>(
+  name: string,
+  f: (
+    id: Discord.Snowflake,
+    data: Discord.InteractionDataResolved,
+  ) => A | undefined,
+): Effect.Effect<A, NoSuchElementError, DiscordInteraction> =>
+  Interaction.use(ix =>
+    Effect.fromOption(IxHelpers.resolveOptionValue(name, f)(ix)),
+  )
+
+export const focusedOptionValue = FocusedOptionContext.use(_ =>
+  Effect.succeed("value" in _ ? _.value : ""),
+)
+
+export class SubCommandNotFound extends Data.TaggedError("SubCommandNotFound")<{
+  data: Discord.APIApplicationCommandInteraction["data"]
+}> {}
+
+export const currentSubCommand: Effect.Effect<
+  Discord.APIApplicationCommandInteractionDataSubcommandOption,
+  never,
+  DiscordSubCommand
+> = SubCommandContext.use(_ => Effect.succeed(_.command))
+
+export class RequiredOptionNotFound {
+  readonly _tag = "RequiredOptionNotFound"
+  constructor(
+    readonly data:
+      | Discord.APIApplicationCommandInteraction["data"]
+      | Discord.APIApplicationCommandSubcommandOption,
+    readonly name: string,
+  ) {}
+}
+
+export const modalValues = ModalSubmitData.use(data =>
+  Effect.succeed(IxHelpers.componentsMap(data)),
+)
+
+export const modalValueOption = (name: string) =>
+  ModalSubmitData.use(data =>
+    Effect.succeed(IxHelpers.componentValue(name)(data)),
+  )
+
+export const modalValue = (
+  name: string,
+): Effect.Effect<string, NoSuchElementError, DiscordModalSubmit> =>
+  ModalSubmitData.use(data =>
+    Effect.fromOption(IxHelpers.componentValue(name)(data)),
+  )

package/dist/src/Interactions/definitions.ts

@@ -0,0 +1,144 @@
+import type * as Effect from "effect/Effect"
+import type {
+  DiscordApplicationCommand,
+  DiscordFocusedOption,
+  DiscordInteraction,
+  DiscordMessageComponent,
+  DiscordModalSubmit,
+} from "./context.ts"
+import type * as Discord from "../types.ts"
+import type { Scope } from "effect/Scope"
+import type { CommandHelper } from "./commandHelper.ts"
+
+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.ApplicationCommandCreateRequest,
+    readonly handle: CommandHandler<R, E>,
+  ) {}
+}
+
+export const global = <
+  R,
+  E,
+  const A extends Discord.ApplicationCommandCreateRequest,
+>(
+  command: A,
+  handle: CommandHandler<R, E, A>,
+) =>
+  new GlobalApplicationCommand<
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand | Scope>,
+    E
+  >(command as any, handle as any)
+
+export class GuildApplicationCommand<R, E> {
+  readonly _tag = "GuildApplicationCommand"
+  constructor(
+    readonly command: Discord.ApplicationCommandCreateRequest,
+    readonly handle: CommandHandler<R, E>,
+  ) {}
+}
+
+export const guild = <
+  R,
+  E,
+  const A extends Discord.ApplicationCommandCreateRequest,
+>(
+  command: A,
+  handle: CommandHandler<R, E, A>,
+) =>
+  new GuildApplicationCommand<
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand | Scope>,
+    E
+  >(command as any, handle as any)
+
+export class MessageComponent<R, E> {
+  readonly _tag = "MessageComponent"
+  constructor(
+    readonly predicate: (customId: string) => boolean,
+    readonly handle: Effect.Effect<
+      Discord.CreateInteractionResponseRequest,
+      E,
+      R
+    >,
+  ) {}
+}
+
+export const messageComponent = <E, R>(
+  pred: (customId: string) => boolean,
+  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+) =>
+  new MessageComponent<
+    Exclude<R, DiscordInteraction | DiscordMessageComponent | Scope>,
+    E
+  >(pred, handle as any)
+
+export class ModalSubmit<R, E> {
+  readonly _tag = "ModalSubmit"
+  constructor(
+    readonly predicate: (customId: string) => boolean,
+    readonly handle: Effect.Effect<
+      Discord.CreateInteractionResponseRequest,
+      E,
+      R
+    >,
+  ) {}
+}
+
+export const modalSubmit = <R, E>(
+  pred: (customId: string) => boolean,
+  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+) =>
+  new ModalSubmit<
+    Exclude<R, DiscordInteraction | DiscordModalSubmit | Scope>,
+    E
+  >(pred, handle as any)
+
+export class Autocomplete<R, E> {
+  readonly _tag = "Autocomplete"
+  constructor(
+    readonly predicate: (
+      data: Discord.APIApplicationCommandInteraction["data"],
+      focusedOption: Discord.APIApplicationCommandInteractionDataOption,
+    ) => boolean,
+    readonly handle: Effect.Effect<
+      Discord.CreateInteractionResponseRequest,
+      E,
+      R
+    >,
+  ) {}
+}
+
+export const autocomplete = <R, E>(
+  pred: (
+    data: Discord.APIApplicationCommandInteraction["data"],
+    focusedOption: Discord.APIApplicationCommandInteractionDataOption,
+  ) => boolean,
+  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+) =>
+  new Autocomplete<
+    Exclude<
+      R,
+      | DiscordInteraction
+      | DiscordApplicationCommand
+      | DiscordFocusedOption
+      | Scope
+    >,
+    E
+  >(pred, handle as any)
+
+// ==== Command handler helpers
+export type CommandHandler<R, E, A = any> =
+  | Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>
+  | CommandHandlerFn<R, E, A>
+
+export type CommandHandlerFn<R, E, A> = (
+  i: CommandHelper<A>,
+) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>

package/dist/src/Interactions/error.ts

@@ -0,0 +1,3 @@
+export const InteractionsErrorTypeId = Symbol.for(
+  "dfx/Interactions/InteractionsError",
+)

package/dist/src/Interactions/gateway.ts

@@ -0,0 +1,193 @@
+import * as Arr from "effect/Array"
+import * as Chunk from "effect/Chunk"
+import * as Duration from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Ref from "effect/Ref"
+import * as Schedule from "effect/Schedule"
+import * as ServiceMap from "effect/ServiceMap"
+import { DiscordGateway } from "../DiscordGateway.ts"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
+import type { ListMyGuilds200, MyGuildResponse } from "../types.ts"
+import type {
+  GlobalApplicationCommand,
+  GuildApplicationCommand,
+} from "./definitions.ts"
+import type { DefinitionNotFound } from "./handlers.ts"
+import { handlers } from "./handlers.ts"
+import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
+import { builder, Interaction } from "./index.ts"
+import * as EffectUtils from "../utils/Effect.ts"
+
+export const interactionsSync = ServiceMap.Reference("dfx/Interactions/sync", {
+  defaultValue: () => true,
+})
+
+export const setInteractionsSync = (enabled: boolean) =>
+  Layer.provide(Layer.succeed(interactionsSync, enabled))
+
+const retryPolicy = Schedule.exponential("1 seconds").pipe(
+  Schedule.either(Schedule.spaced("20 seconds")),
+)
+
+export const run =
+  <R, R2, E, TE, E2>(
+    postHandler: (
+      effect: Effect.Effect<
+        void,
+        TE | DiscordRESTError | DefinitionNotFound,
+        R | DiscordREST | DiscordInteraction
+      >,
+    ) => Effect.Effect<void, E2, R2>,
+  ) =>
+  (
+    ix: InteractionBuilder<R, E, TE>,
+  ): Effect.Effect<
+    never,
+    E2 | DiscordRESTError,
+    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>
+  > =>
+    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.getMyApplication()
+
+      const globalSync = rest.bulkSetApplicationCommands(
+        application.id,
+        GlobalApplicationCommand.map(_ => _.command),
+      )
+
+      const runGuildSync = Effect.gen(function* () {
+        const commands = GuildApplicationCommand.map(_ => _.command)
+        let results: Arr.NonEmptyReadonlyArray<MyGuildResponse> | undefined =
+          undefined
+        while (true) {
+          const next: ListMyGuilds200 = yield* rest.listMyGuilds({
+            after: results && Arr.lastNonEmpty(results).id,
+          })
+          if (!Arr.isReadonlyArrayNonEmpty(next)) break
+          results = next
+          yield* Effect.forEach(
+            results!,
+            guild =>
+              rest.bulkSetGuildApplicationCommands(
+                application.id,
+                guild.id,
+                commands,
+              ),
+            { concurrency: "unbounded", discard: true },
+          )
+        }
+
+        return yield* gateway.handleDispatch("GUILD_CREATE", a =>
+          rest.bulkSetGuildApplicationCommands(
+            application.id,
+            a.id,
+            GuildApplicationCommand.map(_ => _.command),
+          ),
+        )
+      })
+
+      const guildSync = GuildApplicationCommand.length
+        ? runGuildSync
+        : Effect.never
+
+      const handle = handlers(ix.definitions, (i, r) => {
+        const hasFiles = "files" in r
+        const payload = hasFiles ? { ...r, files: undefined } : r
+        const effect = rest.createInteractionResponse(i.id, i.token, {
+          payload,
+        })
+        return hasFiles ? rest.withFiles(r.files as any)(effect) : effect
+      })
+
+      const interactionRun = gateway.handleDispatch("INTERACTION_CREATE", i =>
+        Effect.withSpan(
+          Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
+          "dfx.Interaction",
+          { attributes: { interactionId: i.id }, captureStackTrace: false },
+        ),
+      )
+
+      const sync = yield* interactionsSync
+
+      return yield* sync
+        ? Effect.forever(
+            Effect.all([interactionRun, globalSync, guildSync], {
+              concurrency: "unbounded",
+              discard: true,
+            }),
+          )
+        : interactionRun
+    })
+
+const makeRegistry = Effect.gen(function* () {
+  const ref = yield* Ref.make(
+    builder as InteractionBuilder<never, never, never>,
+  )
+  const queue = yield* Queue.sliding<InteractionBuilder<never, never, never>>(1)
+
+  const register = <E>(ix: InteractionBuilder<never, E, never>) =>
+    Effect.flatMap(
+      Ref.updateAndGet(ref, _ => _.concat(ix as any)),
+      _ => Queue.offer(queue, _),
+    )
+
+  yield* EffectUtils.foreverSwitch(Queue.take(queue), ix =>
+    pipe(
+      ix,
+      run(Effect.catchCause(_ => Effect.logError("unhandled error", _))),
+      Effect.delay(Duration.seconds(5)),
+    ),
+  ).pipe(
+    Effect.tapCause(_ => Effect.logError("registry error", _)),
+    Effect.retry(retryPolicy),
+    Effect.forkScoped,
+    Effect.interruptible,
+  )
+
+  return { register } as const
+}).pipe(
+  Effect.annotateLogs({
+    package: "dfx",
+    service: "InteractionsRegistry",
+  }),
+)
+
+export interface InteractionsRegistryService {
+  readonly register: <E>(
+    ix: InteractionBuilder<never, E, never>,
+  ) => Effect.Effect<void>
+}
+
+export class InteractionsRegistry extends ServiceMap.Service<
+  InteractionsRegistry,
+  InteractionsRegistryService
+>()("dfx/Interactions/InteractionsRegistry") {}
+
+export const InteractionsRegistryLive: Layer.Layer<
+  InteractionsRegistry,
+  never,
+  DiscordREST | DiscordGateway
+> = Layer.effect(InteractionsRegistry, makeRegistry)

package/dist/src/Interactions/handlers.ts

@@ -0,0 +1,108 @@
+import type * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import * as IxHelpers from "../Helpers/interactions.ts"
+import * as Ctx from "./context.ts"
+import type * as D from "./definitions.ts"
+import { flattenDefinitions, splitDefinitions } from "./utils.ts"
+import * as Discord from "../types.ts"
+import type { Scope } from "effect/Scope"
+
+export class DefinitionNotFound {
+  readonly _tag = "DefinitionNotFound"
+  constructor(readonly interaction: Discord.APIInteraction) {}
+}
+
+type Handler<R, E, A> = Effect.Effect<
+  A,
+  E | DefinitionNotFound,
+  R | Ctx.DiscordInteraction
+>
+
+export const handlers = <R, E, TE, A, B>(
+  definitions: Chunk.Chunk<
+    readonly [
+      handler: D.InteractionDefinition<R, E>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
+    ]
+  >,
+  handleResponse: (
+    ix: Discord.APIInteraction,
+    _: Discord.CreateInteractionResponseRequest,
+  ) => Effect.Effect<A, E, R>,
+): Record<
+  Discord.InteractionTypes,
+  (i: Discord.APIInteraction) => Handler<Exclude<R, Scope>, E, B>
+> => {
+  const flattened = flattenDefinitions(definitions, handleResponse)
+
+  const { Autocomplete, Commands, MessageComponent, ModalSubmit } =
+    splitDefinitions(flattened)
+
+  return {
+    [Discord.InteractionTypes.PING]: _ =>
+      Effect.succeed({
+        type: Discord.InteractionCallbackTypes.PONG,
+      } as any),
+
+    [Discord.InteractionTypes.APPLICATION_COMMAND]: i => {
+      const data =
+        i.data as Discord.APIChatInputApplicationCommandInteractionData
+      const command = Commands[data.name]
+      if (command === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        command.handle(i),
+        Ctx.ApplicationCommand,
+        data,
+      ) as Handler<Exclude<R, Scope>, E, B>
+    },
+
+    [Discord.InteractionTypes.SOCIAL_LAYER_SKU_PURCHASE_ELIGIBILITY]: i =>
+      Effect.fail(new DefinitionNotFound(i)),
+
+    [Discord.InteractionTypes.MODAL_SUBMIT]: i => {
+      const data = i.data as Discord.APIModalSubmission
+      const match = ModalSubmit.find(_ => _.predicate(data.custom_id))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        match.handle(i),
+        Ctx.ModalSubmitData,
+        data,
+      ) as Handler<Exclude<R, Scope>, E, B>
+    },
+
+    [Discord.InteractionTypes.MESSAGE_COMPONENT]: i => {
+      const data = i.data as Discord.APIMessageComponentInteractionData
+      const match = MessageComponent.find(_ => _.predicate(data.custom_id))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return Effect.provideService(
+        match.handle(i),
+        Ctx.MessageComponentData,
+        data,
+      ) as Handler<Exclude<R, Scope>, E, B>
+    },
+
+    [Discord.InteractionTypes.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
+      const data = i.data as Discord.APIApplicationCommandInteraction["data"]
+      const option = IxHelpers.focusedOption(data as any)
+      if (option._tag === "None") {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      const match = Autocomplete.find(_ => _.predicate(data, option.value))
+      if (match === undefined) {
+        return Effect.fail(new DefinitionNotFound(i))
+      }
+      return match
+        .handle(i)
+        .pipe(
+          Effect.provideService(Ctx.ApplicationCommand, data),
+          Effect.provideService(Ctx.FocusedOptionContext, option.value),
+        ) as Handler<Exclude<R, Scope>, E, B>
+    },
+  }
+}

package/dist/src/Interactions/index.ts

@@ -0,0 +1,30 @@
+export { response } from "../Helpers/interactions.ts"
+export * from "./builder.ts"
+export * from "./context.ts"
+export type { InteractionDefinition } from "./definitions.ts"
+export {
+  autocomplete,
+  global,
+  guild,
+  messageComponent,
+  modalSubmit,
+} from "./definitions.ts"
+
+// Filters
+export const id = (query: string) => (customId: string) => query === customId
+
+export const idStartsWith = (query: string) => (customId: string) =>
+  customId.startsWith(query)
+
+export const idRegex = (query: RegExp) => (customId: string) =>
+  query.test(customId)
+
+export const option =
+  (command: string, optionName: string) =>
+  (data: { readonly name: string }, focusedOption: { readonly name: string }) =>
+    data.name === command && focusedOption.name === optionName
+
+export const optionOnly =
+  (optionName: string) =>
+  (_: unknown, focusedOption: { readonly name: string }) =>
+    focusedOption.name === optionName

package/dist/src/Interactions/utils.ts

@@ -0,0 +1,93 @@
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import type * as D from "./definitions.ts"
+import type * as Discord from "../types.ts"
+import * as Array from "effect/Array"
+import { CommandHelper } from "./commandHelper.ts"
+
+export type DefinitionFlattened<R, E, TE, A> =
+  D.InteractionDefinition<R, E> extends infer Def
+    ? {
+        [K in keyof Def]: K extends "handle"
+          ? (_: Discord.APIInteraction) => Effect.Effect<A, TE, R>
+          : Def[K]
+      }
+    : never
+
+export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
+  DefinitionFlattened<R, E, TE, A>,
+  { _tag: "GlobalApplicationCommand" | "GuildApplicationCommand" }
+>
+
+export const flattenDefinitions = <R, E, TE, A, B>(
+  definitions: Chunk.Chunk<
+    readonly [
+      handler: D.InteractionDefinition<R, E>,
+      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
+    ]
+  >,
+  handleResponse: (
+    ix: Discord.APIInteraction,
+    _: Discord.CreateInteractionResponseRequest,
+  ) => Effect.Effect<A, E, R>,
+) =>
+  Array.map(Chunk.toReadonlyArray(definitions), ([definition, transform]) => ({
+    ...definition,
+    handle: Effect.isEffect(definition.handle)
+      ? (i: Discord.APIInteraction) =>
+          Effect.scoped(
+            transform(
+              Effect.flatMap(
+                definition.handle as Effect.Effect<Discord.CreateInteractionResponseRequest>,
+                _ => handleResponse(i, _),
+              ),
+            ),
+          )
+      : (i: Discord.APIInteraction) =>
+          Effect.scoped(
+            transform(
+              Effect.flatMap(
+                (
+                  definition.handle as (
+                    _: any,
+                  ) => Effect.Effect<Discord.CreateInteractionResponseRequest>
+                )(new CommandHelper(i)),
+                _ => handleResponse(i, _),
+              ),
+            ),
+          ),
+  }))
+
+export const splitDefinitions = <R, E, TE, A>(
+  definitions: ReadonlyArray<DefinitionFlattened<R, E, TE, A>>,
+) => {
+  const grouped = Array.reduce(
+    definitions,
+    {
+      Autocomplete: [],
+      GlobalApplicationCommand: [],
+      GuildApplicationCommand: [],
+      MessageComponent: [],
+      ModalSubmit: [],
+      Commands: {},
+    } as {
+      [K in D.InteractionDefinition<R, E>["_tag"]]: Array<
+        Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
+      >
+    } & {
+      readonly Commands: Record<string, DefinitionFlattenedCommand<R, E, TE, A>>
+    },
+    (acc, d) => {
+      acc[d._tag].push(d as any)
+      if (
+        d._tag === "GlobalApplicationCommand" ||
+        d._tag === "GuildApplicationCommand"
+      ) {
+        acc.Commands[d.command.name] = d as any
+      }
+      return acc
+    },
+  )
+
+  return grouped
+}