dfx 0.61.4 → 0.61.6

package/src/Interactions/definitions.ts

@@ -25,9 +25,8 @@ 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>,
@@ -48,9 +47,8 @@ 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>,
@@ -123,9 +121,12 @@ 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]>
@@ -162,26 +163,29 @@ 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
   >
@@ -201,9 +205,10 @@ 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"]
@@ -280,16 +285,20 @@ 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

@@ -29,84 +29,90 @@ 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.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*(_) {
+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.unsafeJson(
+            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>),
   )
@@ -130,7 +136,8 @@ const makeRegistry = Effect.gen(function*(_) {
       Effect.delay(
         pipe(ix, run(Effect.catchAllCause(onError), opts)),
         Duration.seconds(0.1),
-      ))
+      ),
+    )
 
   return { register, run: run_ } as const
 })

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,24 +104,25 @@ 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

@@ -23,20 +23,24 @@ 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,11 +7,12 @@ 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<
@@ -44,11 +45,13 @@ 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>(
@@ -79,10 +82,11 @@ 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,16 +86,14 @@ 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),
-      })
+      }),
     ),
   )
 
@@ -115,14 +113,12 @@ 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,
+      ),
     )
 }
 
@@ -138,14 +134,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),
@@ -170,7 +166,7 @@ export const makeHandler = <R, E, TE>(
  */
 export const makeSimpleHandler = <R, E, TE>(
   ix: InteractionBuilder<R, E, TE>,
-): ({
+): (({
   body,
   headers,
 }: {
@@ -180,7 +176,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

@@ -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,7 +77,6 @@ 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)