dfx 0.43.1 → 0.45.0

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,
@@ -102,8 +118,13 @@ export const makeHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
 /**
  * @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)

package/src/gateway.ts

@@ -11,7 +11,11 @@ export * as DiscordWS from "./DiscordGateway/DiscordWS.js"
 export * as Shard from "./DiscordGateway/Shard.js"
 export * as ShardStore from "./DiscordGateway/ShardStore.js"
 export * as WS from "./DiscordGateway/WS.js"
-export { run as runIx } from "./Interactions/gateway.js"
+export {
+  InteractionsRegistry,
+  InteractionsRegistryLive,
+  run as runIx,
+} from "./Interactions/gateway.js"
 
 export const MemoryRateLimit = LiveMemoryRateLimitStore >> LiveRateLimiter
 

package/src/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dfx",
-  "version": "0.43.1",
+  "version": "0.45.0",
   "type": "module",
   "publishConfig": {
     "access": "public",
@@ -48,5 +48,5 @@
     "ws": "^8.13.0"
   },
   "sideEffects": false,
-  "gitHead": "2f76a8860ec37c8a44b227557fa472b30c832819"
+  "gitHead": "1120664f76fc34a00312d277c22007b37d623a30"
 }