dfx 0.91.2 → 0.92.0

package/src/Interactions/definitions.ts

@@ -10,6 +10,7 @@ import type {
 } from "dfx/Interactions/context"
 import type * as Discord from "dfx/types"
 import type { NoSuchElementException } from "effect/Cause"
+import type { Scope } from "effect/Scope"
 
 export type InteractionDefinition<R, E> =
   | GlobalApplicationCommand<R, E>
@@ -29,14 +30,13 @@ export class GlobalApplicationCommand<R, E> {
 export const global = <
   R,
   E,
-  const A extends
-    DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>,
+  const A extends Discord.CreateGlobalApplicationCommandParams,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
 ) =>
   new GlobalApplicationCommand<
-    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
+    Exclude<R, DiscordInteraction | DiscordApplicationCommand | Scope>,
     E
   >(command as any, handle as any)
 
@@ -51,50 +51,49 @@ export class GuildApplicationCommand<R, E> {
 export const guild = <
   R,
   E,
-  const A extends
-    DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>,
+  const A extends Discord.CreateGuildApplicationCommandParams,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
 ) =>
   new GuildApplicationCommand<
-    Exclude<R, DiscordInteraction | DiscordApplicationCommand>,
+    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) => Effect.Effect<boolean, E, R>,
+    readonly predicate: (customId: string) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
-  handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
+export const messageComponent = <R, E>(
+  pred: (customId: string) => boolean,
+  handle: CommandHandler<R, E, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
-    Exclude<R1 | R2, DiscordInteraction | DiscordMessageComponent>,
-    E1 | E2
-  >(pred as any, handle as any)
+    Exclude<R, DiscordInteraction | DiscordMessageComponent | Scope>,
+    E
+  >(pred, handle as any)
 
 export class ModalSubmit<R, E> {
   readonly _tag = "ModalSubmit"
   constructor(
-    readonly predicate: (customId: string) => Effect.Effect<boolean, E, R>,
+    readonly predicate: (customId: string) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect.Effect<boolean, E1, R1>,
-  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
+export const modalSubmit = <R, E>(
+  pred: (customId: string) => boolean,
+  handle: Effect.Effect<Discord.InteractionResponse, E, R>,
 ) =>
   new ModalSubmit<
-    Exclude<R1 | R2, DiscordInteraction | DiscordModalSubmit>,
-    E1 | E2
-  >(pred as any, handle as any)
+    Exclude<R, DiscordInteraction | DiscordModalSubmit | Scope>,
+    E
+  >(pred, handle as any)
 
 export class Autocomplete<R, E> {
   readonly _tag = "Autocomplete"
@@ -102,39 +101,30 @@ export class Autocomplete<R, E> {
     readonly predicate: (
       data: Discord.ApplicationCommandDatum,
       focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect.Effect<boolean, E, R>,
+    ) => boolean,
     readonly handle: Effect.Effect<Discord.InteractionResponse, E, R>,
   ) {}
 }
 
-export const autocomplete = <R1, R2, E1, E2>(
+export const autocomplete = <R, E>(
   pred: (
     data: Discord.ApplicationCommandDatum,
     focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect.Effect<boolean, E1, R1>,
-  handle: Effect.Effect<Discord.InteractionResponse, E2, R2>,
+  ) => boolean,
+  handle: Effect.Effect<Discord.InteractionResponse, E, R>,
 ) =>
   new Autocomplete<
     Exclude<
-      R1 | R2,
-      DiscordInteraction | DiscordApplicationCommand | DiscordFocusedOption
+      R,
+      | DiscordInteraction
+      | DiscordApplicationCommand
+      | DiscordFocusedOption
+      | Scope
     >,
-    E1 | E2
-  >(pred as any, handle as any)
+    E
+  >(pred, handle as any)
 
 // ==== Command handler helpers
-type DeepReadonly<T> =
-  T extends Array<infer R>
-    ? ReadonlyArray<DeepReadonly<R>>
-    : T extends Function
-      ? T
-      : T extends object
-        ? DeepReadonlyObject<T>
-        : T
-type DeepReadonlyObject<T> = {
-  readonly [P in keyof T]: DeepReadonly<T[P]>
-}
-
 export type CommandHandler<R, E, A = any> =
   | Effect.Effect<Discord.InteractionResponse, E, R>
   | CommandHandlerFn<R, E, A>

package/src/Interactions/gateway.ts

@@ -95,12 +95,17 @@ export const run =
           )
         : Effect.never
 
-      const handle = handlers(ix.definitions, (i, r) =>
-        rest.createInteractionResponse(i.id, i.token, r).pipe(Effect.scoped),
+      const handle = handlers(
+        ix.definitions,
+        (i, r) => rest.createInteractionResponse(i.id, i.token, r).effect,
       )
 
       const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
+        Effect.withSpan(
+          Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
+          "dfx.Interaction",
+          { attributes: { interactionId: i.id } },
+        ),
       )
 
       const sync = yield* _(FiberRef.get(interactionsSync))

package/src/Interactions/handlers.ts

@@ -1,11 +1,11 @@
 import type * as Chunk from "effect/Chunk"
-import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
 import * as Ctx from "dfx/Interactions/context"
 import type * as D from "dfx/Interactions/definitions"
 import { flattenDefinitions, splitDefinitions } from "dfx/Interactions/utils"
 import * as Discord from "dfx/types"
+import type { Scope } from "effect/Scope"
 
 export class DefinitionNotFound {
   readonly _tag = "DefinitionNotFound"
@@ -31,7 +31,7 @@ export const handlers = <R, E, TE, A, B>(
   ) => Effect.Effect<A, E, R>,
 ): Record<
   Discord.InteractionType,
-  (i: Discord.Interaction) => Handler<R, E, B>
+  (i: Discord.Interaction) => Handler<Exclude<R, Scope>, E, B>
 > => {
   const flattened = flattenDefinitions(definitions, handleResponse)
 
@@ -39,91 +39,66 @@ export const handlers = <R, E, TE, A, B>(
     splitDefinitions(flattened)
 
   return {
-    [Discord.InteractionType.PING]: () =>
+    [Discord.InteractionType.PING]: _ =>
       Effect.succeed({
         type: Discord.InteractionCallbackType.PONG,
       } as any),
 
     [Discord.InteractionType.APPLICATION_COMMAND]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
-
-      return Option.match(Option.fromNullable(Commands[data.name]), {
-        onNone: () => Effect.fail(new DefinitionNotFound(i)),
-        onSome: command =>
-          Effect.provideService(
-            command.handle(i),
-            Ctx.ApplicationCommand,
-            data,
-          ) as Handler<R, E, B>,
-      })
+      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.InteractionType.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.ModalSubmitDatum
-
-      return Effect.findFirst(ModalSubmit, _ =>
-        _.predicate(data.custom_id),
-      ).pipe(
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.fail(new DefinitionNotFound(i)),
-            onSome: match =>
-              Effect.provideService(
-                match.handle(i),
-                Ctx.ModalSubmitData,
-                data,
-              ) as Handler<R, E, B>,
-          }),
-        ),
-      )
+      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.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
-
-      return Effect.findFirst(MessageComponent, _ =>
-        _.predicate(data.custom_id),
-      ).pipe(
-        Effect.flatMap(
-          Option.match({
-            onNone: () => Effect.fail(new DefinitionNotFound(i)),
-            onSome: match =>
-              Effect.provideService(
-                match.handle(i),
-                Ctx.MessageComponentData,
-                data,
-              ) as Handler<R, E, B>,
-          }),
-        ),
-      )
+      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.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
-
-      return Option.match(IxHelpers.focusedOption(data), {
-        onNone: () => Effect.fail(new DefinitionNotFound(i)),
-        onSome: focusedOption =>
-          Effect.findFirst(Autocomplete, _ =>
-            _.predicate(data, focusedOption),
-          ).pipe(
-            Effect.flatMap(
-              Option.match({
-                onNone: () => Effect.fail(new DefinitionNotFound(i)),
-                onSome: match =>
-                  Effect.provideService(
-                    match.handle(i),
-                    Ctx.ApplicationCommand,
-                    data,
-                  ).pipe(
-                    Effect.provideService(Ctx.FocusedOptionContext, {
-                      focusedOption,
-                    }),
-                  ) as Handler<R, E, B>,
-              }),
-            ),
-          ),
-      })
+      const option = IxHelpers.focusedOption(data)
+      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/src/Interactions/index.ts

@@ -1,4 +1,3 @@
-import * as Effect from "effect/Effect"
 import type * as Discord from "dfx/types"
 
 export { response } from "dfx/Helpers/interactions"
@@ -14,14 +13,13 @@ export {
 } from "dfx/Interactions/definitions"
 
 // Filters
-export const id = (query: string) => (customId: string) =>
-  Effect.succeed(query === customId)
+export const id = (query: string) => (customId: string) => query === customId
 
 export const idStartsWith = (query: string) => (customId: string) =>
-  Effect.succeed(customId.startsWith(query))
+  customId.startsWith(query)
 
 export const idRegex = (query: RegExp) => (customId: string) =>
-  Effect.succeed(query.test(customId))
+  query.test(customId)
 
 export const option =
   (command: string, optionName: string) =>
@@ -32,7 +30,7 @@ export const option =
       "name"
     >,
   ) =>
-    Effect.succeed(data.name === command && focusedOption.name === optionName)
+    data.name === command && focusedOption.name === optionName
 
 export const optionOnly =
   (optionName: string) =>
@@ -43,4 +41,4 @@ export const optionOnly =
       "name"
     >,
   ) =>
-    Effect.succeed(focusedOption.name === optionName)
+    focusedOption.name === optionName

package/src/Interactions/utils.ts

@@ -3,6 +3,7 @@ import * as Effect from "effect/Effect"
 import * as Ctx from "dfx/Interactions/context"
 import type * as D from "dfx/Interactions/definitions"
 import type * as Discord from "dfx/types"
+import * as ReadonlyArray from "effect/ReadonlyArray"
 
 export type DefinitionFlattened<R, E, TE, A> =
   D.InteractionDefinition<R, E> extends infer D
@@ -38,58 +39,66 @@ export const flattenDefinitions = <R, E, TE, A, B>(
     _: Discord.InteractionResponse,
   ) => Effect.Effect<A, E, R>,
 ) =>
-  Chunk.map(definitions, ([definition, transform]) => ({
-    ...definition,
-    handle: (i: Discord.Interaction) =>
-      Effect.isEffect(definition.handle)
-        ? transform(
-            Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
-          )
-        : transform(
-            Effect.flatMap(definition.handle(context), _ =>
-              handleResponse(i, _),
+  ReadonlyArray.map(
+    Chunk.toReadonlyArray(definitions),
+    ([definition, transform]) => ({
+      ...definition,
+      handle: Effect.isEffect(definition.handle)
+        ? (i: Discord.Interaction) =>
+            Effect.scoped(
+              transform(
+                Effect.flatMap(
+                  definition.handle as Effect.Effect<Discord.InteractionResponse>,
+                  _ => handleResponse(i, _),
+                ),
+              ),
+            )
+        : (i: Discord.Interaction) =>
+            Effect.scoped(
+              transform(
+                Effect.flatMap(
+                  (
+                    definition.handle as (
+                      _: any,
+                    ) => Effect.Effect<Discord.InteractionResponse>
+                  )(context),
+                  _ => handleResponse(i, _),
+                ),
+              ),
             ),
-          ),
-  }))
+    }),
+  )
 
 export const splitDefinitions = <R, E, TE, A>(
-  definitions: Chunk.Chunk<DefinitionFlattened<R, E, TE, A>>,
+  definitions: ReadonlyArray<DefinitionFlattened<R, E, TE, A>>,
 ) => {
-  const grouped = Chunk.reduce(
+  const grouped = ReadonlyArray.reduce(
     definitions,
     {
-      Autocomplete: Chunk.empty(),
-      GlobalApplicationCommand: Chunk.empty(),
-      GuildApplicationCommand: Chunk.empty(),
-      MessageComponent: Chunk.empty(),
-      ModalSubmit: Chunk.empty(),
+      Autocomplete: [],
+      GlobalApplicationCommand: [],
+      GuildApplicationCommand: [],
+      MessageComponent: [],
+      ModalSubmit: [],
+      Commands: {},
     } as {
-      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk.Chunk<
+      [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
     },
-    (acc, d) => ({
-      ...acc,
-      [d._tag]: Chunk.append(acc[d._tag] as Chunk.Chunk<any>, d),
-    }),
-  )
-
-  const Commands = Chunk.appendAll(
-    grouped.GlobalApplicationCommand,
-    grouped.GuildApplicationCommand,
-  ).pipe(
-    Chunk.reduce(
-      {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
-      (acc, d) =>
-        (({
-          ...acc,
-          [d.command.name]: d
-        }) as any),
-    ),
   )
 
-  return {
-    ...grouped,
-    Commands,
-  }
+  return grouped
 }

package/src/Interactions/webhook.ts

@@ -131,10 +131,14 @@ const run = <R, E>(
     WebhookConfig | Exclude<R, DiscordInteraction>
   > =>
     Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
-      Effect.provideService(
-        handler[interaction.type](interaction),
-        Interaction,
-        interaction,
+      Effect.withSpan(
+        Effect.provideService(
+          handler[interaction.type](interaction),
+          Interaction,
+          interaction,
+        ),
+        "dfx.Interaction",
+        { attributes: { interactionId: interaction.id } },
       ),
     )
 }

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.91.2";
+export const LIB_VERSION = "0.92.0";

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.91.2";
+export declare const LIB_VERSION = "0.92.0";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,5 +4,5 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = exports.LIB_VERSION = "0.91.2";
+const LIB_VERSION = exports.LIB_VERSION = "0.92.0";
 //# sourceMappingURL=version.js.map