dfx 0.51.0 → 0.51.2

package/src/Interactions/builder.ts

@@ -1,9 +1,12 @@
 import * as Http from "@effect-http/client"
+import * as Chunk from "@effect/data/Chunk"
+import { identity } from "@effect/data/Function"
+import type * as Cause from "@effect/io/Cause"
+import * as Effect from "@effect/io/Effect"
 import { catchTag } from "@effect/io/Effect"
-import { DiscordREST } from "dfx"
-import { Discord, Effect } from "dfx/_common"
-import * as D from "./definitions.js"
-import { DiscordRESTError } from "dfx/DiscordREST"
+import { DiscordREST, type DiscordRESTError } from "dfx/DiscordREST"
+import type * as Discord from "dfx/types"
+import type * as D from "dfx/Interactions/definitions"
 
 type ExtractTag<A> = A extends { _tag: infer Tag }
   ? Tag extends string
@@ -16,49 +19,53 @@ type ExtractTag<A> = A extends { _tag: infer Tag }
  */
 export class InteractionBuilder<R, E, TE> {
   constructor(
-    readonly definitions: Chunk<
+    readonly definitions: Chunk.Chunk<
       readonly [
         handler: D.InteractionDefinition<R, E>,
-        transform: (self: Effect<any, any, any>) => Effect<R, TE, void>,
+        transform: (
+          self: Effect.Effect<any, any, any>,
+        ) => Effect.Effect<R, TE, void>,
       ]
     >,
-    readonly transform: (self: Effect<any, any, any>) => Effect<R, TE, void>,
+    readonly transform: (
+      self: Effect.Effect<any, any, any>,
+    ) => Effect.Effect<R, TE, void>,
   ) {}
 
   add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
     return new InteractionBuilder<R | R1, E | E1, TE | E1>(
-      this.definitions.append([definition, this.transform] as const),
+      Chunk.append(this.definitions, [definition, this.transform] as const),
       this.transform,
     )
   }
 
   concat<R1, E1, TE1>(builder: InteractionBuilder<R1, E1, TE1>) {
     return new InteractionBuilder<R | R1, E | E1, TE | TE1>(
-      this.definitions.appendAll(builder.definitions),
+      Chunk.appendAll(this.definitions, builder.definitions),
       this.transform,
     )
   }
 
   private transformTransform<R1, E1>(
-    f: (selr: Effect<R, TE, void>) => Effect<R1, E1, void>,
+    f: (selr: Effect.Effect<R, TE, void>) => Effect.Effect<R1, E1, void>,
   ) {
     return new InteractionBuilder<R1, E, E1>(
-      this.definitions.map(([d, t]) => [d as any, _ => f(t(_)) as any]),
+      Chunk.map(this.definitions, ([d, t]) => [d as any, _ => f(t(_)) as any]),
       _ => f(this.transform(_)) as any,
     )
   }
 
   private transformHandlers<R1, E1>(
     f: (
-      selr: Effect<R, E, Discord.InteractionResponse>,
-    ) => Effect<R1, E1, Discord.InteractionResponse>,
+      selr: Effect.Effect<R, E, Discord.InteractionResponse>,
+    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
   ) {
     return new InteractionBuilder<
       R1,
       E1,
       Exclude<TE, Exclude<E, E1>> | Exclude<E1, E>
     >(
-      this.definitions.map(([d, t]) => [
+      Chunk.map(this.definitions, ([d, t]) => [
         {
           ...d,
           handle: Effect.isEffect(d.handle)
@@ -71,29 +78,33 @@ export class InteractionBuilder<R, E, TE> {
     )
   }
 
-  catchAllCause<R1, E1>(f: (cause: Cause<TE>) => Effect<R1, E1, void>) {
-    return this.transformTransform<R | R1, E1>(_ => _.catchAllCause(f))
+  catchAllCause<R1, E1>(
+    f: (cause: Cause.Cause<TE>) => Effect.Effect<R1, E1, void>,
+  ) {
+    return this.transformTransform<R | R1, E1>(Effect.catchAllCause(f))
   }
 
   catchAllCauseRespond<R1, E1>(
-    f: (cause: Cause<E>) => Effect<R1, E1, Discord.InteractionResponse>,
+    f: (
+      cause: Cause.Cause<E>,
+    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
   ) {
-    return this.transformHandlers<R | R1, E1>(_ => _.catchAllCause(f))
+    return this.transformHandlers<R | R1, E1>(Effect.catchAllCause(f))
   }
 
-  catchAll<R1, E1>(f: (error: TE) => Effect<R1, E1, void>) {
-    return this.transformTransform<R | R1, E1>(_ => _.catchAll(f))
+  catchAll<R1, E1>(f: (error: TE) => Effect.Effect<R1, E1, void>) {
+    return this.transformTransform<R | R1, E1>(Effect.catchAll(f))
   }
 
   catchAllRespond<R1, E1>(
-    f: (error: E) => Effect<R1, E1, Discord.InteractionResponse>,
+    f: (error: E) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
   ) {
-    return this.transformHandlers<R | R1, E1>(_ => _.catchAll(f))
+    return this.transformHandlers<R | R1, E1>(Effect.catchAll(f))
   }
 
   catchTag<T extends ExtractTag<E>, R1, E1>(
     tag: T,
-    f: (error: Extract<TE, { _tag: T }>) => Effect<R1, E1, void>,
+    f: (error: Extract<TE, { _tag: T }>) => Effect.Effect<R1, E1, void>,
   ) {
     return this.transformTransform<R | R1, Exclude<TE, { _tag: T }> | E1>(
       _ => catchTag(_ as any, tag, f as any) as any,
@@ -104,7 +115,7 @@ export class InteractionBuilder<R, E, TE> {
     tag: T,
     f: (
       error: Extract<E, { _tag: T }>,
-    ) => Effect<R1, E1, Discord.InteractionResponse>,
+    ) => Effect.Effect<R1, E1, Discord.InteractionResponse>,
   ) {
     return this.transformHandlers<R | R1, Exclude<E, { _tag: T }> | E1>(
       _ => catchTag(_ as any, tag, f as any) as any,
@@ -112,40 +123,42 @@ export class InteractionBuilder<R, E, TE> {
   }
 
   get syncGlobal() {
-    const commands = this.definitions
-      .map(([d, _]) => d)
-      .filter(
+    const commands = this.definitions.pipe(
+      Chunk.map(([d, _]) => d),
+      Chunk.filter(
         (c): c is D.GlobalApplicationCommand<R, E> =>
           c._tag === "GlobalApplicationCommand",
-      )
-      .map(c => c.command)
-
-    return DiscordREST.accessWithEffect(rest =>
-      rest
-        .getCurrentBotApplicationInformation()
-        .flatMap(r => r.json)
-        .flatMap(app =>
+      ),
+      Chunk.map(c => c.command),
+    )
+
+    return Effect.flatMap(DiscordREST, rest =>
+      rest.getCurrentBotApplicationInformation().pipe(
+        Effect.flatMap(r => r.json),
+        Effect.flatMap(app =>
           rest.bulkOverwriteGlobalApplicationCommands(app.id, {
-            body: Http.body.json(commands.toReadonlyArray),
+            body: Http.body.json(Chunk.toReadonlyArray(commands)),
           }),
         ),
+      ),
     )
   }
 
   syncGuild(appId: Discord.Snowflake, guildId: Discord.Snowflake) {
-    const commands = this.definitions
-      .map(([d, _]) => d)
-      .filter(
+    const commands = this.definitions.pipe(
+      Chunk.map(([d, _]) => d),
+      Chunk.filter(
         (c): c is D.GuildApplicationCommand<R, E> =>
           c._tag === "GuildApplicationCommand",
-      )
-      .map(c => c.command)
+      ),
+      Chunk.map(c => c.command),
+    )
 
-    return DiscordREST.accessWithEffect(rest =>
+    return Effect.flatMap(DiscordREST, rest =>
       rest.bulkOverwriteGuildApplicationCommands(
         appId,
         guildId,
-        commands.toReadonlyArray as any,
+        Chunk.toReadonlyArray(commands) as any,
       ),
     )
   }

package/src/Interactions/context.ts

@@ -1,6 +1,10 @@
+import { Tag } from "@effect/data/Context"
+import * as HashMap from "@effect/data/HashMap"
+import * as Option from "@effect/data/Option"
 import * as Arr from "@effect/data/ReadonlyArray"
-import { Effect, EffectTypeId } from "@effect/io/Effect"
+import * as Effect from "@effect/io/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
+import * as Discord from "dfx/types"
 import { ModalSubmitDatum } from "dfx/types"
 
 export const Interaction = Tag<Discord.Interaction>()
@@ -25,23 +29,27 @@ export class ResolvedDataNotFound {
 
 export const resolvedValues = <A>(
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-) =>
-  Interaction.accessWithEffect(ix =>
-    IxHelpers.resolveValues(f)(ix).mapError(() => new ResolvedDataNotFound(ix)),
+): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, readonly A[]> =>
+  Effect.flatMap(Interaction, ix =>
+    Effect.mapError(
+      IxHelpers.resolveValues(f)(ix),
+      () => new ResolvedDataNotFound(ix),
+    ),
   )
 
 export const resolved = <A>(
   name: string,
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
-) =>
-  Interaction.accessWithEffect(ix =>
-    IxHelpers.resolveOptionValue(
-      name,
-      f,
-    )(ix).mapError(() => new ResolvedDataNotFound(ix, name)),
+): Effect.Effect<Discord.Interaction, ResolvedDataNotFound, A> =>
+  Effect.flatMap(Interaction, ix =>
+    Effect.mapError(
+      IxHelpers.resolveOptionValue(name, f)(ix),
+      () => new ResolvedDataNotFound(ix, name),
+    ),
   )
 
-export const focusedOptionValue = FocusedOptionContext.accessWith(
+export const focusedOptionValue = Effect.map(
+  FocusedOptionContext,
   _ => _.focusedOption.value ?? "",
 )
 
@@ -51,13 +59,16 @@ export class SubCommandNotFound {
 }
 
 export const handleSubCommands = <
-  NER extends Record<string, Effect<any, any, Discord.InteractionResponse>>,
+  NER extends Record<
+    string,
+    Effect.Effect<any, any, Discord.InteractionResponse>
+  >,
 >(
   commands: NER,
-): Effect<
+): Effect.Effect<
   | Exclude<
       [NER[keyof NER]] extends [
-        { [EffectTypeId]: { _R: (_: never) => infer R } },
+        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
       ]
         ? R
         : never,
@@ -66,26 +77,38 @@ export const handleSubCommands = <
   | Discord.Interaction
   | Discord.ApplicationCommandDatum,
   | ([NER[keyof NER]] extends [
-      { [EffectTypeId]: { _E: (_: never) => infer E } },
+      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
     ]
       ? E
       : never)
   | SubCommandNotFound,
   Discord.InteractionResponse
 > =>
-  ApplicationCommand.accessWithEffect(data =>
-    Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name])
-      .mapError(() => new SubCommandNotFound(data))
-      .flatMap(command =>
-        commands[command.name].provideService(SubCommandContext, {
-          command,
-        }),
+  ApplicationCommand.pipe(
+    Effect.flatMap(data =>
+      Effect.mapError(
+        Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name]),
+        () => new SubCommandNotFound(data),
       ),
+    ),
+    Effect.flatMap(command =>
+      Effect.provideService(commands[command.name], SubCommandContext, {
+        command,
+      }),
+    ),
   )
 
-export const currentSubCommand = SubCommandContext.accessWith(_ => _.command)
+export const currentSubCommand: Effect.Effect<
+  SubCommandContext,
+  never,
+  Discord.ApplicationCommandInteractionDataOption
+> = Effect.map(SubCommandContext, _ => _.command)
 
-export const optionsMap = ApplicationCommand.accessWith(IxHelpers.optionsMap)
+export const optionsMap: Effect.Effect<
+  Discord.ApplicationCommandDatum,
+  never,
+  HashMap.HashMap<string, string | undefined>
+> = Effect.map(ApplicationCommand, IxHelpers.optionsMap)
 
 export class RequiredOptionNotFound {
   readonly _tag = "RequiredOptionNotFound"
@@ -98,26 +121,32 @@ export class RequiredOptionNotFound {
 }
 
 export const option = (name: string) =>
-  ApplicationCommand.accessWith(IxHelpers.getOption(name))
+  Effect.map(ApplicationCommand, IxHelpers.getOption(name))
 
 export const optionValue = (name: string) =>
-  option(name).flatMap(_ =>
-    _.flatMapNullable(a => a.value).match({
-      onNone: () =>
-        ApplicationCommand.accessWithEffect(data =>
-          Effect.fail(new RequiredOptionNotFound(data, name)),
-        ),
-      onSome: Effect.succeed,
-    }),
+  Effect.flatMap(option(name), _ =>
+    Option.match(
+      Option.flatMapNullable(_, a => a.value),
+      {
+        onNone: () =>
+          Effect.flatMap(ApplicationCommand, data =>
+            Effect.fail(new RequiredOptionNotFound(data, name)),
+          ),
+        onSome: Effect.succeed,
+      },
+    ),
   )
 
 export const optionValueOptional = (name: string) =>
-  option(name).map(o => o.flatMapNullable(o => o.value))
+  Effect.map(
+    option(name),
+    Option.flatMapNullable(o => o.value),
+  )
 
-export const modalValues = ModalSubmitData.accessWith(IxHelpers.componentsMap)
+export const modalValues = Effect.map(ModalSubmitData, IxHelpers.componentsMap)
 
 export const modalValueOption = (name: string) =>
-  ModalSubmitData.accessWith(IxHelpers.componentValue(name))
+  Effect.map(ModalSubmitData, IxHelpers.componentValue(name))
 
 export class ModalValueNotFound {
   readonly _tag = "ModalValueNotFound"
@@ -125,8 +154,9 @@ export class ModalValueNotFound {
 }
 
 export const modalValue = (name: string) =>
-  ModalSubmitData.accessWithEffect(data =>
-    IxHelpers.componentValue(name)(data).mapError(
+  Effect.flatMap(ModalSubmitData, data =>
+    Effect.mapError(
+      IxHelpers.componentValue(name)(data),
       () => new ModalValueNotFound(data, name),
     ),
   )

package/src/Interactions/definitions.ts

@@ -1,9 +1,11 @@
-import { Effect, EffectTypeId } from "@effect/io/Effect"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 import {
   FocusedOptionContext,
   ResolvedDataNotFound,
   SubCommandContext,
-} from "./context.js"
+} from "dfx/Interactions/context"
+import * as Discord from "dfx/types"
 
 export type InteractionDefinition<R, E> =
   | GlobalApplicationCommand<R, E>
@@ -57,13 +59,13 @@ export const guild = <
 export class MessageComponent<R, E> {
   readonly _tag = "MessageComponent"
   constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
+    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
   ) {}
 }
 
 export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect<R1, E1, boolean>,
+  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
   handle: CommandHandler<R2, E2, Discord.InteractionResponse>,
 ) =>
   new MessageComponent<
@@ -74,14 +76,14 @@ export const messageComponent = <R1, R2, E1, E2>(
 export class ModalSubmit<R, E> {
   readonly _tag = "ModalSubmit"
   constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+    readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>,
+    readonly handle: Effect.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>,
+  pred: (customId: string) => Effect.Effect<R1, E1, boolean>,
+  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
 ) =>
   new ModalSubmit<
     Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
@@ -94,8 +96,8 @@ export class Autocomplete<R, E> {
     readonly predicate: (
       data: Discord.ApplicationCommandDatum,
       focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Discord.InteractionResponse>,
+    ) => Effect.Effect<R, E, boolean>,
+    readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>,
   ) {}
 }
 
@@ -103,8 +105,8 @@ export const autocomplete = <R1, R2, E1, E2>(
   pred: (
     data: Discord.ApplicationCommandDatum,
     focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Discord.InteractionResponse>,
+  ) => Effect.Effect<R1, E1, boolean>,
+  handle: Effect.Effect<R2, E2, Discord.InteractionResponse>,
 ) =>
   new Autocomplete<
     Exclude<
@@ -129,44 +131,48 @@ type DeepReadonlyObject<T> = {
 }
 
 export type CommandHandler<R, E, A = any> =
-  | Effect<R, E, Discord.InteractionResponse>
+  | Effect.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>
+  ) => Effect.Effect<Discord.Interaction, ResolvedDataNotFound, T>
 
   option: (
     name: AllCommandOptions<A>["name"],
-  ) => Effect<
+  ) => Effect.Effect<
     Discord.ApplicationCommandDatum,
     never,
-    Maybe<Discord.ApplicationCommandInteractionDataOption>
+    Option.Option<Discord.ApplicationCommandInteractionDataOption>
   >
 
   optionValue: <N extends AllRequiredCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect<Discord.ApplicationCommandDatum, never, CommandValue<A, N>>
+  ) => Effect.Effect<Discord.ApplicationCommandDatum, never, CommandValue<A, N>>
 
   optionValueOptional: <N extends AllCommandOptions<A>["name"]>(
     name: N,
-  ) => Effect<Discord.ApplicationCommandDatum, never, Maybe<CommandValue<A, N>>>
+  ) => Effect.Effect<
+    Discord.ApplicationCommandDatum,
+    never,
+    Option.Option<CommandValue<A, N>>
+  >
 
   subCommands: <
     NER extends SubCommandNames<A> extends never
       ? never
       : Record<
           SubCommandNames<A>,
-          Effect<any, any, Discord.InteractionResponse>
+          Effect.Effect<any, any, Discord.InteractionResponse>
         >,
   >(
     commands: NER,
-  ) => Effect<
+  ) => Effect.Effect<
     | Exclude<
         [NER[keyof NER]] extends [
-          { [EffectTypeId]: { _R: (_: never) => infer R } },
+          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
         ]
           ? R
           : never,
@@ -174,7 +180,9 @@ export interface CommandHelper<A> {
       >
     | Discord.Interaction
     | Discord.ApplicationCommandDatum,
-    [NER[keyof NER]] extends [{ [EffectTypeId]: { _E: (_: never) => infer E } }]
+    [NER[keyof NER]] extends [
+      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+    ]
       ? E
       : never,
     Discord.InteractionResponse
@@ -183,7 +191,7 @@ export interface CommandHelper<A> {
 
 export type CommandHandlerFn<R, E, A> = (
   i: CommandHelper<A>,
-) => Effect<R, E, Discord.InteractionResponse>
+) => Effect.Effect<R, E, Discord.InteractionResponse>
 
 interface CommandOption {
   readonly type: any