dfx 0.60.0 → 0.61.1

package/src/Interactions/definitions.ts

@@ -25,7 +25,9 @@ export class GlobalApplicationCommand<R, E> {
 export const global = <
   R,
   E,
-  const A extends DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>,
+  const A extends DeepReadonlyObject<
+    Discord.CreateGlobalApplicationCommandParams
+  >,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -46,7 +48,9 @@ export class GuildApplicationCommand<R, E> {
 export const guild = <
   R,
   E,
-  const A extends DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>,
+  const A extends DeepReadonlyObject<
+    Discord.CreateGuildApplicationCommandParams
+  >,
 >(
   command: A,
   handle: CommandHandler<R, E, A>,
@@ -119,12 +123,9 @@ export const autocomplete = <R1, R2, E1, E2>(
   >(pred as any, 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>
+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]>
@@ -161,29 +162,26 @@ export interface CommandHelper<A> {
   >
 
   subCommands: <
-    NER extends SubCommandNames<A> extends never
-      ? never
+    NER extends SubCommandNames<A> extends never ? never
       : Record<
-          SubCommandNames<A>,
-          Effect.Effect<any, any, Discord.InteractionResponse>
-        >,
+        SubCommandNames<A>,
+        Effect.Effect<any, any, Discord.InteractionResponse>
+      >,
   >(
     commands: NER,
   ) => Effect.Effect<
     | Exclude<
-        [NER[keyof NER]] extends [
-          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-        ]
-          ? R
-          : never,
-        SubCommandContext
-      >
+      [NER[keyof NER]] extends [
+        { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
+      ] ? R
+        : never,
+      SubCommandContext
+    >
     | Discord.Interaction
     | Discord.ApplicationCommandDatum,
     [NER[keyof NER]] extends [
       { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
+    ] ? E
       : never,
     Discord.InteractionResponse
   >
@@ -203,10 +201,9 @@ interface CommandOption {
 type SubCommands<A> = A extends {
   readonly type: Discord.ApplicationCommandOptionType.SUB_COMMAND
   readonly options?: ReadonlyArray<CommandOption>
-}
-  ? A
+} ? A
   : A extends { readonly options: ReadonlyArray<CommandOption> }
-  ? SubCommands<A["options"][number]>
+    ? SubCommands<A["options"][number]>
   : never
 
 type SubCommandNames<A> = Option<SubCommands<A>>["name"]
@@ -283,20 +280,16 @@ type SubCommandResolvables<A> = Extract<
 type AllResolvables<A> = Resolvables<A> | SubCommandResolvables<A>
 
 // == Utilities
-type StringLiteral<T> = T extends string
-  ? string extends T
-    ? never
-    : T
+type StringLiteral<T> = T extends string ? string extends T ? never
+  : T
   : never
 
 type Option<A> = A extends { readonly name: infer N }
-  ? N extends StringLiteral<N>
-    ? A
-    : never
+  ? N extends StringLiteral<N> ? A
+  : never
   : never
 
 type OptionsWithLiteral<A, T> = A extends {
   readonly options: ReadonlyArray<CommandOption>
-}
-  ? Extract<A["options"][number], Option<A["options"][number]> & T>
+} ? Extract<A["options"][number], Option<A["options"][number]> & T>
   : never

package/src/Interactions/gateway.ts

@@ -1,4 +1,3 @@
-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"
@@ -8,6 +7,7 @@ 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 * as Http from "@effect/platform/HttpClient"
 import { DiscordGateway } from "dfx/DiscordGateway"
 import type { DiscordRESTError } from "dfx/DiscordREST"
 import { DiscordREST } from "dfx/DiscordREST"
@@ -18,7 +18,7 @@ import type {
 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 { builder, Interaction } from "dfx/Interactions/index"
 import type * as Discord from "dfx/types"
 import * as EffectUtils from "dfx/utils/Effect"
 
@@ -29,86 +29,84 @@ export interface RunOpts {
 /**
  * @tsplus pipeable dfx/InteractionBuilder runGateway
  */
-export const run =
-  <R, R2, E, TE, E2>(
-    postHandler: (
-      effect: Effect.Effect<
-        R | DiscordREST | Discord.Interaction,
-        TE | DiscordRESTError | DefinitionNotFound,
-        void
-      >,
-    ) => Effect.Effect<R2, E2, void>,
-    { sync = true }: RunOpts = {},
-  ) =>
-  (
-    ix: InteractionBuilder<R, E, TE>,
-  ): Effect.Effect<
-    DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
-    E2 | DiscordRESTError | Http.ResponseDecodeError,
-    never
-  > =>
-    Effect.gen(function* (_) {
-      const GlobalApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GlobalApplicationCommand<R, E> =>
-            _._tag === "GlobalApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-      const GuildApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GuildApplicationCommand<R, E> =>
-            _._tag === "GuildApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-
-      const gateway = yield* _(DiscordGateway)
-      const rest = yield* _(DiscordREST)
-
-      const application = yield* _(
-        rest.getCurrentBotApplicationInformation(),
-        Effect.flatMap(a => a.json),
-      )
-
-      const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
-        application.id,
-        { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
-      )
-
-      const guildSync = GuildApplicationCommand.length
-        ? gateway.handleDispatch("GUILD_CREATE", a =>
-            rest.bulkOverwriteGuildApplicationCommands(
-              application.id,
-              a.id,
-              GuildApplicationCommand.map(_ => _.command) as any,
-            ),
-          )
-        : Effect.never
-
-      const handle = handlers(ix.definitions, (i, r) =>
-        rest.createInteractionResponse(i.id, i.token, r),
-      )
-
-      const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
-      )
-
-      return yield* _(
-        sync
-          ? Effect.forever(
-              Effect.all([run, globalSync, guildSync], {
-                concurrency: "unbounded",
-                discard: true,
-              }),
-            )
-          : run,
-      )
-    })
-
-const makeRegistry = Effect.gen(function* (_) {
+export const run = <R, R2, E, TE, E2>(
+  postHandler: (
+    effect: Effect.Effect<
+      R | DiscordREST | Discord.Interaction,
+      TE | DiscordRESTError | DefinitionNotFound,
+      void
+    >,
+  ) => Effect.Effect<R2, E2, void>,
+  { sync = true }: RunOpts = {},
+) =>
+(
+  ix: InteractionBuilder<R, E, TE>,
+): Effect.Effect<
+  DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>,
+  E2 | DiscordRESTError | Http.error.ResponseError,
+  never
+> =>
+  Effect.gen(function*(_) {
+    const GlobalApplicationCommand = ix.definitions.pipe(
+      Chunk.map(_ => _[0]),
+      Chunk.filter(
+        (_): _ is GlobalApplicationCommand<R, E> =>
+          _._tag === "GlobalApplicationCommand",
+      ),
+      Chunk.toReadonlyArray,
+    )
+    const GuildApplicationCommand = ix.definitions.pipe(
+      Chunk.map(_ => _[0]),
+      Chunk.filter(
+        (_): _ is GuildApplicationCommand<R, E> =>
+          _._tag === "GuildApplicationCommand",
+      ),
+      Chunk.toReadonlyArray,
+    )
+
+    const gateway = yield* _(DiscordGateway)
+    const rest = yield* _(DiscordREST)
+
+    const application = yield* _(
+      rest.getCurrentBotApplicationInformation(),
+      Effect.flatMap(a => a.json),
+    )
+
+    const globalSync = rest.bulkOverwriteGlobalApplicationCommands(
+      application.id,
+      { body: Http.body.json(GlobalApplicationCommand.map(_ => _.command)) },
+    )
+
+    const guildSync = GuildApplicationCommand.length
+      ? gateway.handleDispatch("GUILD_CREATE", a =>
+        rest.bulkOverwriteGuildApplicationCommands(
+          application.id,
+          a.id,
+          GuildApplicationCommand.map(_ =>
+            _.command
+          ) as any,
+        ))
+      : Effect.never
+
+    const handle = handlers(ix.definitions, (i, r) =>
+      rest.createInteractionResponse(i.id, i.token, r))
+
+    const run = gateway.handleDispatch("INTERACTION_CREATE", i =>
+      Effect.provideService(postHandler(handle[i.type](i)), Interaction, i))
+
+    return yield* _(
+      sync
+        ? Effect.forever(
+          Effect.all([run, globalSync, guildSync], {
+            concurrency: "unbounded",
+            discard: true,
+          }),
+        )
+        : run,
+    )
+  })
+
+const makeRegistry = Effect.gen(function*(_) {
   const ref = yield* _(
     Ref.make(builder as InteractionBuilder<never, never, never>),
   )
@@ -132,8 +130,7 @@ const makeRegistry = Effect.gen(function* (_) {
       Effect.delay(
         pipe(ix, run(Effect.catchAllCause(onError), opts)),
         Duration.seconds(0.1),
-      ),
-    )
+      ))
 
   return { register, run: run_ } as const
 })
@@ -150,7 +147,7 @@ export interface InteractionsRegistry {
     opts?: RunOpts,
   ) => Effect.Effect<
     DiscordREST | DiscordGateway | Exclude<R, Discord.Interaction>,
-    DiscordRESTError | Http.ResponseDecodeError | E,
+    DiscordRESTError | Http.error.ResponseError | E,
     never
   >
 }

package/src/Interactions/handlers.ts

@@ -61,28 +61,28 @@ export const handlers = <R, E, TE, A, 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>,
-          }),
-        ),
-      )
+      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>,
+            }),
+          ),
+        )
     },
 
     [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
 
-      return Effect.findFirst(MessageComponent, _ =>
-        _.predicate(data.custom_id),
+      return Effect.findFirst(
+        MessageComponent,
+        _ => _.predicate(data.custom_id),
       ).pipe(
         Effect.flatMap(
           Option.match({
@@ -104,25 +104,24 @@ export const handlers = <R, E, TE, A, 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>,
-              }),
+          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

@@ -5,10 +5,10 @@ export { response } from "dfx/Helpers/interactions"
 export * from "dfx/Interactions/builder"
 export * from "dfx/Interactions/context"
 export {
-  InteractionDefinition,
   autocomplete,
   global,
   guild,
+  InteractionDefinition,
   messageComponent,
   modalSubmit,
 } from "dfx/Interactions/definitions"
@@ -23,24 +23,20 @@ export const idStartsWith = (query: string) => (customId: string) =>
 export const idRegex = (query: RegExp) => (customId: string) =>
   Effect.succeed(query.test(customId))
 
-export const option =
-  (command: string, optionName: string) =>
-  (
-    data: Pick<Discord.ApplicationCommandDatum, "name">,
-    focusedOption: Pick<
-      Discord.ApplicationCommandInteractionDataOption,
-      "name"
-    >,
-  ) =>
-    Effect.succeed(data.name === command && focusedOption.name === optionName)
+export const option = (command: string, optionName: string) =>
+(
+  data: Pick<Discord.ApplicationCommandDatum, "name">,
+  focusedOption: Pick<
+    Discord.ApplicationCommandInteractionDataOption,
+    "name"
+  >,
+) => Effect.succeed(data.name === command && focusedOption.name === optionName)
 
-export const optionOnly =
-  (optionName: string) =>
-  (
-    _: unknown,
-    focusedOption: Pick<
-      Discord.ApplicationCommandInteractionDataOption,
-      "name"
-    >,
-  ) =>
-    Effect.succeed(focusedOption.name === optionName)
+export const optionOnly = (optionName: string) =>
+(
+  _: unknown,
+  focusedOption: Pick<
+    Discord.ApplicationCommandInteractionDataOption,
+    "name"
+  >,
+) => Effect.succeed(focusedOption.name === optionName)

package/src/Interactions/utils.ts

@@ -7,12 +7,11 @@ import type * as Discord from "dfx/types"
 export type DefinitionFlattened<R, E, TE, A> = D.InteractionDefinition<
   R,
   E
-> extends infer D
-  ? {
-      [K in keyof D]: K extends "handle"
-        ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
-        : D[K]
-    }
+> extends infer D ? {
+    [K in keyof D]: K extends "handle"
+      ? (_: Discord.Interaction) => Effect.Effect<R, TE, A>
+      : D[K]
+  }
   : never
 
 export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
@@ -45,13 +44,11 @@ export const flattenDefinitions = <R, E, TE, A, B>(
     handle: (i: Discord.Interaction) =>
       Effect.isEffect(definition.handle)
         ? transform(
-            Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
-          )
+          Effect.flatMap(definition.handle, _ => handleResponse(i, _)),
+        )
         : transform(
-            Effect.flatMap(definition.handle(context), _ =>
-              handleResponse(i, _),
-            ),
-          ),
+          Effect.flatMap(definition.handle(context), _ => handleResponse(i, _)),
+        ),
   }))
 
 export const splitDefinitions = <R, E, TE, A>(
@@ -82,11 +79,10 @@ export const splitDefinitions = <R, E, TE, A>(
   ).pipe(
     Chunk.reduce(
       {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,
-      (acc, d) =>
-        ({
-          ...acc,
-          [d.command.name]: d,
-        } as any),
+      (acc, d) => ({
+        ...acc,
+        [d.command.name]: d,
+      } as any),
     ),
   )
 

package/src/Interactions/webhook.ts

@@ -42,8 +42,8 @@ const checkSignature = (
           publicKey,
           crypto,
           algorithm,
-        ),
-      ),
+        )
+      )
     ),
     Effect.filterOrFail(identity, () => new BadWebhookSignature()),
     Effect.catchAllCause(() => Effect.fail(new BadWebhookSignature())),
@@ -86,14 +86,16 @@ export class WebhookParseError {
 }
 
 const fromHeadersAndBody = (headers: Headers, body: string) =>
-  Effect.tap(WebhookConfig, ({ algorithm, crypto, publicKey }) =>
-    checkSignature(publicKey, headers, body, crypto, algorithm),
+  Effect.tap(
+    WebhookConfig,
+    ({ algorithm, crypto, publicKey }) =>
+      checkSignature(publicKey, headers, body, crypto, algorithm),
   ).pipe(
     Effect.flatMap(() =>
       Effect.try({
         try: () => JSON.parse(body) as Discord.Interaction,
         catch: reason => new WebhookParseError(reason),
-      }),
+      })
     ),
   )
 
@@ -113,12 +115,14 @@ const run = <R, E>(
 ) => {
   const handler = handlers(definitions, handleResponse)
   return (headers: Headers, body: string) =>
-    Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
-      Effect.provideService(
-        handler[interaction.type](interaction),
-        Interaction,
-        interaction,
-      ),
+    Effect.flatMap(
+      fromHeadersAndBody(headers, body),
+      interaction =>
+        Effect.provideService(
+          handler[interaction.type](interaction),
+          Interaction,
+          interaction,
+        ),
     )
 }
 
@@ -134,14 +138,14 @@ export interface HandleWebhookOpts<E> {
  */
 export const makeHandler = <R, E, TE>(
   ix: InteractionBuilder<R, E, TE>,
-): (({
+): ({
   body,
   error,
   headers,
   success,
 }: HandleWebhookOpts<
   E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
->) => Effect.Effect<WebhookConfig, never, void>) => {
+>) => Effect.Effect<WebhookConfig, never, void> => {
   const handle = run(
     Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
@@ -166,7 +170,7 @@ export const makeHandler = <R, E, TE>(
  */
 export const makeSimpleHandler = <R, E, TE>(
   ix: InteractionBuilder<R, E, TE>,
-): (({
+): ({
   body,
   headers,
 }: {
@@ -176,7 +180,7 @@ export const makeSimpleHandler = <R, E, TE>(
   WebhookConfig,
   BadWebhookSignature | WebhookParseError | DefinitionNotFound,
   Discord.InteractionResponse
->) => {
+> => {
   const handle = run(
     Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),

package/src/Log.ts

@@ -1,6 +1,6 @@
+import { Tag } from "@effect/data/Context"
 import * as Effect from "@effect/io/Effect"
 import * as Layer from "@effect/io/Layer"
-import { Tag } from "@effect/data/Context"
 
 const make = (debug = false) => ({
   info: (...args: Array<any>) =>
@@ -10,8 +10,8 @@ const make = (debug = false) => ({
   debug: (...args: Array<any>) =>
     debug
       ? Effect.sync(() => {
-          console.error("DEBUG", ...args)
-        })
+        console.error("DEBUG", ...args)
+      })
       : Effect.unit,
 })
 

package/src/RateLimit.ts

@@ -43,7 +43,7 @@ export interface RateLimitStore {
 export const RateLimitStore = Tag<RateLimitStore>()
 export const LiveMemoryRateLimitStore = Layer.sync(RateLimitStore, Memory.make)
 
-const makeLimiter = Effect.gen(function* (_) {
+const makeLimiter = Effect.gen(function*(_) {
   const store = yield* _(RateLimitStore)
   const log = yield* _(Log)
 
@@ -64,10 +64,10 @@ const makeLimiter = Effect.gen(function* (_) {
           windowMs,
           limit,
           delay: Duration.toMillis(d),
-        }),
+        })
       ),
       Effect.tap(_ =>
-        Duration.toMillis(_) === 0 ? Effect.unit : Effect.sleep(_),
+        Duration.toMillis(_) === 0 ? Effect.unit : Effect.sleep(_)
       ),
       Effect.asUnit,
     )
@@ -77,6 +77,7 @@ const makeLimiter = Effect.gen(function* (_) {
 })
 
 export interface RateLimiter
-  extends Effect.Effect.Success<typeof makeLimiter> {}
+  extends Effect.Effect.Success<typeof makeLimiter>
+{}
 export const RateLimiter = Tag<RateLimiter>()
 export const LiveRateLimiter = Layer.effect(RateLimiter, makeLimiter)