dfx 0.50.1 → 0.51.1

package/src/Interactions/gateway.ts

@@ -1,12 +1,26 @@
 import * as Http from "@effect-http/client"
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import { pipe } from "@effect/data/Function"
+import type { Cause } from "@effect/io/Cause"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Queue from "@effect/io/Queue"
+import * as Ref from "@effect/io/Ref"
 import { DiscordGateway } from "dfx/DiscordGateway"
-import { DiscordREST, DiscordRESTError } from "dfx/DiscordREST"
-import { DefinitionNotFound, handlers } from "./handlers.js"
-import { Interaction, InteractionBuilder, builder } from "./index.js"
+import type { DiscordRESTError } from "dfx/DiscordREST"
+import { DiscordREST } from "dfx/DiscordREST"
 import type {
   GlobalApplicationCommand,
   GuildApplicationCommand,
-} from "./definitions.js"
+} from "dfx/Interactions/definitions"
+import type { DefinitionNotFound } from "dfx/Interactions/handlers"
+import { handlers } from "dfx/Interactions/handlers"
+import type { InteractionBuilder } from "dfx/Interactions/index"
+import { Interaction, builder } from "dfx/Interactions/index"
+import type * as Discord from "dfx/types"
+import * as EffectUtils from "dfx/utils/Effect"
 
 export interface RunOpts {
   sync?: boolean
@@ -18,47 +32,50 @@ export interface RunOpts {
 export const run =
   <R, R2, E, TE, E2>(
     postHandler: (
-      effect: Effect<
+      effect: Effect.Effect<
         R | DiscordREST | Discord.Interaction,
         TE | DiscordRESTError | DefinitionNotFound,
         void
       >,
-    ) => Effect<R2, E2, void>,
+    ) => Effect.Effect<R2, E2, void>,
     { sync = true }: RunOpts = {},
   ) =>
   (
     ix: InteractionBuilder<R, E, TE>,
-  ): Effect<
+  ): Effect.Effect<
     DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
     E2 | DiscordRESTError | Http.ResponseDecodeError,
     never
   > =>
-    Do($ => {
-      const GlobalApplicationCommand = ix.definitions
-        .map(_ => _[0])
-        .filter(
+    Effect.gen(function* (_) {
+      const GlobalApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
           (_): _ is GlobalApplicationCommand<R, E> =>
             _._tag === "GlobalApplicationCommand",
-        ).toReadonlyArray
-      const GuildApplicationCommand = ix.definitions
-        .map(_ => _[0])
-        .filter(
+        ),
+        Chunk.toReadonlyArray,
+      )
+      const GuildApplicationCommand = ix.definitions.pipe(
+        Chunk.map(_ => _[0]),
+        Chunk.filter(
           (_): _ is GuildApplicationCommand<R, E> =>
             _._tag === "GuildApplicationCommand",
-        ).toReadonlyArray
+        ),
+        Chunk.toReadonlyArray,
+      )
 
-      const gateway = $(DiscordGateway)
-      const rest = $(DiscordREST)
+      const gateway = yield* _(DiscordGateway)
+      const rest = yield* _(DiscordREST)
 
-      const application = $(
-        rest.getCurrentBotApplicationInformation().flatMap(a => a.json),
+      const application = yield* _(
+        rest.getCurrentBotApplicationInformation(),
+        Effect.flatMap(a => a.json),
       )
 
       const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
         application.id,
-        {
-          body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)),
-        },
+        { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
       )
 
       const guildSync = GuildApplicationCommand.length
@@ -69,54 +86,69 @@ export const run =
               GuildApplicationCommand.map(_ => _.command) as any,
             ),
           )
-        : Effect.never()
+        : Effect.never
 
       const handle = handlers(ix.definitions, (i, r) =>
         rest.createInteractionResponse(i.id, i.token, r),
       )
 
       const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        postHandler(handle[i.type](i)).provideService(Interaction, i),
+        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
       )
 
-      return $(sync ? run.zipParRight(globalSync).zipParRight(guildSync) : run)
+      return yield* _(
+        sync
+          ? Effect.forever(
+              Effect.all(run, globalSync, guildSync, {
+                concurrency: "unbounded",
+                discard: true,
+              }),
+            )
+          : run,
+      )
     })
 
-const makeRegistry = Do($ => {
-  const ref = $(Ref.make(builder as InteractionBuilder<never, never, never>))
-  const queue = $(Queue.sliding<InteractionBuilder<never, never, never>>(1))
+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>) =>
-    ref.updateAndGet(_ => _.concat(ix as any)).flatMap(_ => queue.offer(_))
+    Effect.flatMap(
+      Ref.updateAndGet(ref, _ => _.concat(ix as any)),
+      _ => Queue.offer(queue, _),
+    )
 
-  const run = <R, E>(
+  const run_ = <R, E>(
     onError: (
       _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect<R, E, void>,
+    ) => Effect.Effect<R, E, void>,
     opts?: RunOpts,
   ) =>
-    queue
-      .take()
-      .foreverSwitch(ix =>
-        ix
-          .runGateway(_ => _.catchAllCause(onError), opts)
-          .delay(Duration.seconds(0.1)),
-      )
-
-  return { register, run } as const
+    EffectUtils.foreverSwitch(Queue.take(queue), ix =>
+      Effect.delay(
+        pipe(ix, run(Effect.catchAllCause(onError), opts)),
+        Duration.seconds(0.1),
+      ),
+    )
+
+  return { register, run: run_ } as const
 })
 
 export interface InteractionsRegistry {
   readonly register: <E>(
     ix: InteractionBuilder<never, E, never>,
-  ) => Effect<never, never, void>
+  ) => Effect.Effect<never, never, void>
 
   readonly run: <R, E>(
     onError: (
       _: Cause<DiscordRESTError | DefinitionNotFound>,
-    ) => Effect<R, E, void>,
+    ) => Effect.Effect<R, E, void>,
     opts?: RunOpts,
-  ) => Effect<
+  ) => Effect.Effect<
     DiscordREST | DiscordGateway | Exclude<R, Discord.Interaction>,
     DiscordRESTError | Http.ResponseDecodeError | E,
     never
@@ -124,5 +156,7 @@ export interface InteractionsRegistry {
 }
 
 export const InteractionsRegistry = Tag<InteractionsRegistry>()
-export const InteractionsRegistryLive =
-  makeRegistry.toLayer(InteractionsRegistry)
+export const InteractionsRegistryLive = Layer.effect(
+  InteractionsRegistry,
+  makeRegistry,
+)

package/src/Interactions/handlers.ts

@@ -1,30 +1,34 @@
+import * as Chunk from "@effect/data/Chunk"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 import * as IxHelpers from "dfx/Helpers/interactions"
-import * as Ctx from "./context.js"
-import * as D from "./definitions.js"
-import { flattenDefinitions, splitDefinitions } from "./utils.js"
+import * as Ctx from "dfx/Interactions/context"
+import * as D from "dfx/Interactions/definitions"
+import { flattenDefinitions, splitDefinitions } from "dfx/Interactions/utils"
+import * as Discord from "dfx/types"
 
 export class DefinitionNotFound {
   readonly _tag = "DefinitionNotFound"
   constructor(readonly interaction: Discord.Interaction) {}
 }
 
-type Handler<R, E, A> = Effect<
+type Handler<R, E, A> = Effect.Effect<
   R | Discord.Interaction,
   E | DefinitionNotFound,
   A
 >
 
 export const handlers = <R, E, TE, A, B>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect<R, E, A>) => Effect<R, TE, B>,
+      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect<R, E, A>,
+  ) => Effect.Effect<R, E, A>,
 ): Record<
   Discord.InteractionType,
   (i: Discord.Interaction) => Handler<R, E, B>
@@ -43,25 +47,33 @@ export const handlers = <R, E, TE, A, B>(
     [Discord.InteractionType.APPLICATION_COMMAND]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return Maybe.fromNullable(Commands[data.name]).match(
-        () => Effect.fail(new DefinitionNotFound(i)),
-        command =>
-          command
-            .handle(i)
-            .provideService(Ctx.ApplicationCommand, data) as Handler<R, E, B>,
-      )
+      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>,
+      })
     },
 
     [Discord.InteractionType.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.ModalSubmitDatum
 
-      return ModalSubmit.find(_ => _.predicate(data.custom_id)).flatMap(_ =>
-        _.match(
-          () => Effect.fail(new DefinitionNotFound(i)),
-          match =>
-            match
-              .handle(i)
-              .provideService(Ctx.ModalSubmitData, data) as Handler<R, E, B>,
+      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>,
+          }),
         ),
       )
     },
@@ -69,41 +81,49 @@ export const handlers = <R, E, TE, A, B>(
     [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
 
-      return MessageComponent.find(_ => _.predicate(data.custom_id)).flatMap(
-        _ =>
-          _.match(
-            () => Effect.fail(new DefinitionNotFound(i)),
-            match =>
-              match
-                .handle(i)
-                .provideService(Ctx.MessageComponentData, data) as Handler<
-                R,
-                E,
-                B
-              >,
-          ),
+      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>,
+          }),
+        ),
       )
     },
 
     [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return IxHelpers.focusedOption(data).match(
-        () => Effect.fail(new DefinitionNotFound(i)),
-        focusedOption =>
-          Autocomplete.find(_ => _.predicate(data, focusedOption)).flatMap(_ =>
-            _.match(
-              () => Effect.fail(new DefinitionNotFound(i)),
-              match =>
-                match
-                  .handle(i)
-                  .provideService(Ctx.ApplicationCommand, data)
-                  .provideService(Ctx.FocusedOptionContext, {
-                    focusedOption,
-                  }) as Handler<R, E, B>,
+      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>,
+              }),
             ),
           ),
-      )
+      })
     },
   }
 }

package/src/Interactions/index.ts

@@ -1,8 +1,9 @@
-import { Discord, Effect } from "dfx/_common"
+import * as Effect from "@effect/io/Effect"
+import type * as Discord from "dfx/types"
 
-export { response } from "../Helpers/interactions.js"
-export * from "./builder.js"
-export * from "./context.js"
+export { response } from "dfx/Helpers/interactions"
+export * from "dfx/Interactions/builder"
+export * from "dfx/Interactions/context"
 export {
   InteractionDefinition,
   autocomplete,
@@ -10,7 +11,7 @@ export {
   guild,
   messageComponent,
   modalSubmit,
-} from "./definitions.js"
+} from "dfx/Interactions/definitions"
 
 // Filters
 export const id = (query: string) => (customId: string) =>

package/src/Interactions/utils.ts

@@ -1,5 +1,8 @@
-import * as D from "./definitions.js"
-import * as Ctx from "./context.js"
+import * as Chunk from "@effect/data/Chunk"
+import * as Effect from "@effect/io/Effect"
+import * as Ctx from "dfx/Interactions/context"
+import * as D from "dfx/Interactions/definitions"
+import * as Discord from "dfx/types"
 
 export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
   R,
@@ -7,7 +10,7 @@ export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
 > extends infer D
   ? {
       [K in keyof D]: K extends "handle"
-        ? (_: Discord.Interaction) => Effect<R, TE, A>
+        ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
         : D[K]
     }
   : never
@@ -26,31 +29,36 @@ const context: D.CommandHelper<any> = {
 } as any
 
 export const flattenDefinitions = <R, E, TE, A, B>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     readonly [
       handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect<R, E, A>) => Effect<R, TE, B>,
+      transform: (self: Effect.Effect<R, E, A>) => Effect.Effect<R, TE, B>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect<R, E, A>,
+  ) => Effect.Effect<R, E, A>,
 ) =>
-  definitions.map(([definition, transform]) => ({
+  Chunk.map(definitions, ([definition, transform]) => ({
     ...definition,
     handle: (i: Discord.Interaction) =>
       Effect.isEffect(definition.handle)
-        ? transform(definition.handle.flatMap(_ => handleResponse(i, _)))
+        ? transform(
+            Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
+          )
         : transform(
-            definition.handle(context).flatMap(_ => handleResponse(i, _)),
+            Effect.flatMap(definition.handle(context), _ =>
+              handleResponse(i, _),
+            ),
           ),
   }))
 
 export const splitDefinitions = <R, E, TE, A>(
-  definitions: Chunk<DefinitionFlattened<R, E, TE, A>>,
+  definitions: Chunk.Chunk<DefinitionFlattened<R, E, TE, A>>,
 ) => {
-  const grouped = definitions.reduce(
+  const grouped = Chunk.reduce(
+    definitions,
     {
       Autocomplete: Chunk.empty(),
       GlobalApplicationCommand: Chunk.empty(),
@@ -58,25 +66,28 @@ export const splitDefinitions = <R, E, TE, A>(
       MessageComponent: Chunk.empty(),
       ModalSubmit: Chunk.empty(),
     } as {
-      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk<
+      [K in D.InteractionDefinition<R, E>["_tag"]]: Chunk.Chunk<
         Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
       >
     },
     (acc, d) => ({
       ...acc,
-      [d._tag]: (acc[d._tag] as Chunk<any>).append(d),
+      [d._tag]: Chunk.append(acc[d._tag] as Chunk.Chunk<any>, d),
     }),
   )
 
-  const Commands = grouped.GlobalApplicationCommand.concat(
+  const Commands = Chunk.appendAll(
+    grouped.GlobalApplicationCommand,
     grouped.GuildApplicationCommand,
-  ).reduce(
-    {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
-    (acc, d) =>
-      ({
-        ...acc,
-        [d.command.name]: d,
-      } as any),
+  ).pipe(
+    Chunk.reduce(
+      {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
+      (acc, d) =>
+        ({
+          ...acc,
+          [d.command.name]: d,
+        } as any),
+    ),
   )
 
   return {