dfx 0.44.0 → 0.45.1

package/src/Interactions/index.ts

@@ -1,10 +1,7 @@
-import * as Http from "@effect-http/client"
-import { catchTag } from "@effect/io/Effect"
-import { DiscordREST } from "dfx"
 import { Discord, Effect } from "dfx/_common"
-import * as D from "./definitions.js"
 
 export { response } from "../Helpers/interactions.js"
+export * from "./builder.js"
 export * from "./context.js"
 export {
   InteractionDefinition,
@@ -15,144 +12,6 @@ export {
   modalSubmit,
 } from "./definitions.js"
 
-type ExtractTag<A> = A extends { _tag: infer Tag }
-  ? Tag extends string
-    ? Tag
-    : never
-  : never
-
-/**
- * @tsplus type dfx/InteractionBuilder
- */
-export class InteractionBuilder<R, E> {
-  constructor(
-    readonly definitions: D.InteractionDefinition<R, E>[],
-    readonly transform: (self: Effect<any, any, any>) => Effect<R, E, void>,
-    readonly transformRespond: (
-      self: Effect<any, any, Discord.InteractionResponse>,
-    ) => Effect<R, E, Discord.InteractionResponse>,
-  ) {}
-
-  add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
-    return new InteractionBuilder<R | R1, E | E1>(
-      [...this.definitions, definition],
-      this.transform,
-      this.transformRespond,
-    )
-  }
-
-  concat<R1, E1>(builder: InteractionBuilder<R1, E1>) {
-    return new InteractionBuilder<R | R1, E | E1>(
-      [...this.definitions, ...builder.definitions],
-      this.transform,
-      this.transformRespond,
-    )
-  }
-
-  catchAllCause<R1, E1>(f: (cause: Cause<E>) => Effect<R1, E1, void>) {
-    return new InteractionBuilder<R | R1, E1>(
-      this.definitions as any,
-      _ => this.transform(_).catchAllCause(f),
-      this.transformRespond as any,
-    )
-  }
-
-  catchAllCauseRespond<R1, E1>(
-    f: (cause: Cause<E>) => Effect<R1, E1, Discord.InteractionResponse>,
-  ) {
-    return new InteractionBuilder<R | R1, E1>(
-      this.definitions as any,
-      this.transform as any,
-      _ => this.transformRespond(_).catchAllCause(f),
-    )
-  }
-
-  catchAll<R1, E1>(f: (error: E) => Effect<R1, E1, void>) {
-    return new InteractionBuilder<R | R1, E1>(
-      this.definitions as any,
-      _ => this.transform(_).catchAll(f),
-      this.transformRespond as any,
-    )
-  }
-
-  catchAllRespond<R1, E1>(
-    f: (error: E) => Effect<R1, E1, Discord.InteractionResponse>,
-  ) {
-    return new InteractionBuilder<R | R1, E1>(
-      this.definitions as any,
-      this.transform as any,
-      _ => this.transformRespond(_).catchAll(f),
-    )
-  }
-
-  catchTag<T extends ExtractTag<E>, R1, E1>(
-    tag: T,
-    f: (error: Extract<E, { _tag: T }>) => Effect<R1, E1, void>,
-  ) {
-    return new InteractionBuilder<R | R1, Exclude<E, { _tag: T }> | E1>(
-      this.definitions as any,
-      _ => catchTag(this.transform(_) as any, tag, f as any) as any,
-      this.transformRespond as any,
-    )
-  }
-
-  catchTagRespond<T extends ExtractTag<E>, R1, E1>(
-    tag: T,
-    f: (
-      error: Extract<E, { _tag: T }>,
-    ) => Effect<R1, E1, Discord.InteractionResponse>,
-  ) {
-    return new InteractionBuilder<R | R1, Exclude<E, { _tag: T }> | E1>(
-      this.definitions as any,
-      this.transform as any,
-      _ => catchTag(this.transformRespond(_) as any, tag, f as any) as any,
-    )
-  }
-
-  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>(
-  [],
-  identity as any,
-  identity as any,
-)
-
 // Filters
 export const id = (query: string) => (customId: string) =>
   Effect.succeed(query === customId)

package/src/Interactions/utils.ts

@@ -1,39 +1,82 @@
 import * as D from "./definitions.js"
+import * as Ctx from "./context.js"
 
-export const splitDefinitions = <R, E>(
-  definitions: D.InteractionDefinition<R, E>[],
+export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
+  R,
+  E
+> extends infer D
+  ? {
+      [K in keyof D]: K extends "handle"
+        ? (_: Discord.Interaction) => Effect<R, TE, A>
+        : D[K]
+    }
+  : never
+
+export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
+  DefinitionFlattened<R, E, TE, A>,
+  { _tag: "GlobalApplicationCommand" | "GuildApplicationCommand" }
+>
+
+const context: D.CommandHelper<any> = {
+  resolve: Ctx.resolved,
+  option: Ctx.option,
+  optionValue: Ctx.optionValue,
+  optionValueOptional: Ctx.optionValueOptional,
+  subCommands: Ctx.handleSubCommands,
+} as any
+
+export const flattenDefinitions = <R, E, TE, A, B>(
+  definitions: Chunk<
+    readonly [
+      handler: D.InteractionDefinition<R, E>,
+      transform: (self: Effect<R, E, A>) => Effect<R, TE, B>,
+    ]
+  >,
+  handleResponse: (
+    ix: Discord.Interaction,
+    _: Discord.InteractionResponse,
+  ) => Effect<R, E, A>,
+) =>
+  definitions.map(([definition, transform]) => ({
+    ...definition,
+    handle: (i: Discord.Interaction) =>
+      Effect.isEffect(definition.handle)
+        ? transform(definition.handle.flatMap(_ => handleResponse(i, _)))
+        : transform(
+            definition.handle(context).flatMap(_ => handleResponse(i, _)),
+          ),
+  }))
+
+export const splitDefinitions = <R, E, TE, A>(
+  definitions: Chunk<DefinitionFlattened<R, E, TE, A>>,
 ) => {
-  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],
-    }),
+  const grouped = definitions.reduce(
     {
-      Autocomplete: [],
-      GlobalApplicationCommand: [],
-      GuildApplicationCommand: [],
-      MessageComponent: [],
-      ModalSubmit: [],
+      Autocomplete: Chunk.empty(),
+      GlobalApplicationCommand: Chunk.empty(),
+      GuildApplicationCommand: Chunk.empty(),
+      MessageComponent: Chunk.empty(),
+      ModalSubmit: Chunk.empty(),
+    } as {
+      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk<
+        Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
+      >
     },
-  )
-
-  const Commands = [
-    ...grouped.GlobalApplicationCommand,
-    ...grouped.GuildApplicationCommand,
-  ].reduce(
-    (acc, a) => ({
+    (acc, d) => ({
       ...acc,
-      [a.command.name]: a,
+      [d._tag]: (acc[d._tag] as Chunk<any>).append(d),
     }),
-    {} as Record<
-      string,
-      D.GlobalApplicationCommand<R, E> | D.GuildApplicationCommand<R, E>
-    >,
+  )
+
+  const Commands = grouped.GlobalApplicationCommand.concat(
+    grouped.GuildApplicationCommand,
+  ).reduce(
+    {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
+    (acc, d) =>
+      ({
+        ...acc,
+        [d.command.name]: d,
+      } as any),
   )
 
   return {

package/src/Interactions/webhook.ts

@@ -62,8 +62,21 @@ const fromHeadersAndBody = (headers: Headers, body: string) =>
     )
   })
 
-const run = <R, E>(definitions: D.InteractionDefinition<R, E>[]) => {
-  const handler = handlers(definitions)
+const run = <R, E>(
+  definitions: Chunk<
+    readonly [
+      handler: D.InteractionDefinition<R, E>,
+      transform: (
+        self: Effect<R, E, Discord.InteractionResponse>,
+      ) => Effect<R, E, Discord.InteractionResponse>,
+    ]
+  >,
+  handleResponse: (
+    ix: Discord.Interaction,
+    _: Discord.InteractionResponse,
+  ) => Effect<R, E, Discord.InteractionResponse>,
+) => {
+  const handler = handlers(definitions, handleResponse)
   return (headers: Headers, body: string) =>
     Do($ => {
       const interaction = $(fromHeadersAndBody(headers, body))
@@ -86,8 +99,11 @@ export interface HandleWebhookOpts<E> {
 /**
  * @tsplus getter dfx/InteractionBuilder webhookHandler
  */
-export const makeHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
-  const handle = run(ix.definitions)
+export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
+  const handle = run(
+    ix.definitions.map(([d]) => [d, identity] as any),
+    (_i, r) => Effect.succeed(r),
+  )
 
   return ({
     headers,
@@ -96,17 +112,19 @@ export const makeHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
     error,
   }: HandleWebhookOpts<
     E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
-  >) =>
-    ix
-      .transform(ix.transformRespond(handle(headers, body)).flatMap(success))
-      .catchAllCause(error)
+  >) => handle(headers, body).flatMap(success).catchAllCause(error)
 }
 
 /**
  * @tsplus getter dfx/InteractionBuilder simpleWebhookHandler
  */
-export const makeSimpleHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
-  const handle = run(ix.definitions)
+export const makeSimpleHandler = <R, E, TE>(
+  ix: InteractionBuilder<R, E, TE>,
+) => {
+  const handle = run(
+    ix.definitions.map(([d]) => [d, identity] as any),
+    (_i, r) => Effect.succeed(r),
+  )
 
   return ({ headers, body }: { headers: Headers; body: string }) =>
     handle(headers, body)