dfx 0.50.1 → 0.51.1

package/src/DiscordREST.ts

@@ -1,20 +1,25 @@
 import * as Http from "@effect-http/client"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
 import { millis } from "@effect/data/Duration"
-import { DiscordConfig } from "./DiscordConfig.js"
-import { ResponseWithData, RestResponse } from "./DiscordREST/types.js"
+import { pipe } from "@effect/data/Function"
+import * as HashSet from "@effect/data/HashSet"
+import * as Option from "@effect/data/Option"
+import * as ConfigSecret from "@effect/io/Config/Secret"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as Ref from "@effect/io/Ref"
+import { DiscordConfig } from "dfx/DiscordConfig"
+import type { ResponseWithData, RestResponse } from "dfx/DiscordREST/types"
 import {
   rateLimitFromHeaders,
   retryAfter,
   routeFromConfig,
-} from "./DiscordREST/utils.js"
-import { Log } from "./Log.js"
-import {
-  BucketDetails,
-  LiveRateLimiter,
-  RateLimitStore,
-  RateLimiter,
-} from "./RateLimit.js"
-import Pkg from "./package.json" assert { type: "json" }
+} from "dfx/DiscordREST/utils"
+import { Log } from "dfx/Log"
+import { LiveRateLimiter, RateLimitStore, RateLimiter } from "dfx/RateLimit"
+import * as Discord from "dfx/types"
+import { LIB_VERSION } from "dfx/version"
 
 export class DiscordRESTError {
   readonly _tag = "DiscordRESTError"
@@ -23,172 +28,194 @@ export class DiscordRESTError {
 
 export { ResponseDecodeError } from "@effect-http/client"
 
-const make = Do($ => {
-  const { token, rest } = $(DiscordConfig)
+const make = Effect.gen(function* (_) {
+  const { rest, token } = yield* _(DiscordConfig)
 
-  const http = $(Http.HttpRequestExecutor)
-  const log = $(Log)
-  const store = $(RateLimitStore)
-  const { maybeWait } = $(RateLimiter)
+  const http = yield* _(Http.HttpRequestExecutor)
+  const log = yield* _(Log)
+  const store = yield* _(RateLimitStore)
+  const { maybeWait } = yield* _(RateLimiter)
 
   const globalRateLimit = maybeWait(
     "dfx.rest.global",
-    rest.globalRateLimit.window,
+    Duration.decode(rest.globalRateLimit.window),
     rest.globalRateLimit.limit,
   )
 
   // Invalid route handling (40x)
-  const badRoutesRef = $(Ref.make(HashSet.empty<string>()))
+  const badRoutesRef = yield* _(Ref.make(HashSet.empty<string>()))
+  const tenMinutes = Duration.toMillis(Duration.minutes(10))
   const addBadRoute = (route: string) =>
-    Effect.allParDiscard([
+    Effect.all(
       log.info("DiscordREST", "addBadRoute", route),
-      badRoutesRef.update(s => s.add(route)),
-      store.incrementCounter(
-        "dfx.rest.invalid",
-        Duration.minutes(10).millis,
-        10000,
-      ),
-    ])
-  const isBadRoute = (route: string) => badRoutesRef.get.map(s => s.has(route))
+      Ref.update(badRoutesRef, HashSet.add(route)),
+      store.incrementCounter("dfx.rest.invalid", tenMinutes, 10000),
+      { discard: true, concurrency: "unbounded" },
+    )
+  const isBadRoute = (route: string) =>
+    Effect.map(Ref.get(badRoutesRef), HashSet.has(route))
   const removeBadRoute = (route: string) =>
-    badRoutesRef.update(s => s.remove(route))
+    Ref.update(badRoutesRef, HashSet.remove(route))
 
   const invalidRateLimit = (route: string) =>
-    isBadRoute(route).tap(invalid =>
-      invalid
-        ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
-        : Effect.unit(),
-    ).asUnit
+    isBadRoute(route).pipe(
+      Effect.tap(invalid =>
+        invalid
+          ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
+          : Effect.unit,
+      ),
+      Effect.asUnit,
+    )
 
   // Request rate limiting
   const requestRateLimit = (path: string, request: Http.Request) =>
-    Do($ => {
-      const route = routeFromConfig(path, request.method)
-      const maybeBucket = $(store.getBucketForRoute(route))
-
-      const effect = maybeBucket.match(
-        () => invalidRateLimit(route),
-        bucket =>
-          Do($ => {
-            $(invalidRateLimit(route))
-            const resetAfter = millis(bucket.resetAfter)
-
-            $(maybeWait(`dfx.rest.${bucket.key}`, resetAfter, bucket.limit))
-          }),
-      )
-
-      $(effect)
-    })
+    Effect.Do.pipe(
+      Effect.let("route", () => routeFromConfig(path, request.method)),
+      Effect.bind("maybeBucket", ({ route }) => store.getBucketForRoute(route)),
+      Effect.flatMap(({ maybeBucket, route }) =>
+        Option.match(maybeBucket, {
+          onNone: () => invalidRateLimit(route),
+          onSome: bucket =>
+            Effect.zipRight(
+              invalidRateLimit(route),
+              maybeWait(
+                `dfx.rest.${bucket.key}`,
+                millis(bucket.resetAfter),
+                bucket.limit,
+              ),
+            ),
+        }),
+      ),
+    )
 
   // Update rate limit buckets
   const updateBuckets = (request: Http.Request, response: Http.Response) =>
-    Do($ => {
-      const route = routeFromConfig(request.url, request.method)
-      const { bucket, retryAfter, limit, remaining } = $(
-        rateLimitFromHeaders(response.headers),
-      )
-
-      const effectsToRun = [
-        removeBadRoute(route),
-        store.putBucketRoute(route, bucket),
-      ]
-
-      const hasBucket = $(store.hasBucket(bucket))
-      if (!hasBucket || limit - 1 === remaining) {
-        effectsToRun.push(
-          store.removeCounter(`dfx.rest.?.${route}`),
-          store.putBucket({
-            key: bucket,
-            resetAfter: retryAfter.millis,
-            limit: !hasBucket && remaining > 0 ? remaining : limit,
-          }),
-        )
-      }
-
-      $(Effect.allParDiscard(effectsToRun))
-    }).ignore
+    Effect.Do.pipe(
+      Effect.let("route", () => routeFromConfig(request.url, request.method)),
+      Effect.bind("rateLimit", () => rateLimitFromHeaders(response.headers)),
+      Effect.bind("hasBucket", ({ rateLimit }) =>
+        store.hasBucket(rateLimit.bucket),
+      ),
+      Effect.flatMap(({ hasBucket, rateLimit, route }) => {
+        const effectsToRun = [
+          removeBadRoute(route),
+          store.putBucketRoute(route, rateLimit.bucket),
+        ]
+
+        if (!hasBucket || rateLimit.limit - 1 === rateLimit.remaining) {
+          effectsToRun.push(
+            store.removeCounter(`dfx.rest.?.${route}`),
+            store.putBucket({
+              key: rateLimit.bucket,
+              resetAfter: Duration.toMillis(rateLimit.retryAfter),
+              limit:
+                !hasBucket && rateLimit.remaining > 0
+                  ? rateLimit.remaining
+                  : rateLimit.limit,
+            }),
+          )
+        }
 
-  const httpExecutor = http.execute.filterStatusOk
-    .contramap(_ =>
-      _.updateUrl(_ => `${rest.baseUrl}${_}`).setHeaders({
-        Authorization: `Bot ${token.value}`,
-        "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${Pkg.version})`,
+        return Effect.all(effectsToRun, {
+          concurrency: "unbounded",
+          discard: true,
+        })
       }),
+      Effect.ignore,
     )
-    .catchAll(error =>
+
+  const httpExecutor = pipe(
+    http.execute,
+    Http.executor.filterStatusOk,
+    Http.executor.contramap(req =>
+      pipe(
+        Http.updateUrl(req, _ => `${rest.baseUrl}${_}`),
+        Http.setHeaders({
+          Authorization: `Bot ${ConfigSecret.value(token)}`,
+          "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
+        }),
+      ),
+    ),
+    Http.executor.catchAll(error =>
       error._tag === "StatusCodeError"
-        ? error.response.json
-            .mapError(_ => new DiscordRESTError(_))
-            .flatMap(body => Effect.fail(new DiscordRESTError(error, body)))
+        ? error.response.json.pipe(
+            Effect.mapError(_ => new DiscordRESTError(_)),
+            Effect.flatMap(body =>
+              Effect.fail(new DiscordRESTError(error, body)),
+            ),
+          )
         : Effect.fail(new DiscordRESTError(error)),
-    )
+    ),
+  )
 
   const executor = <A = unknown>(
     request: Http.Request,
-  ): Effect<never, DiscordRESTError, ResponseWithData<A>> =>
-    Do($ => {
-      $(requestRateLimit(request.url, request))
-      $(globalRateLimit)
-
-      const response = $(httpExecutor(request))
-
-      $(updateBuckets(request, response))
-
-      return response as ResponseWithData<A>
-    }).catchTag("DiscordRESTError", e => {
-      if (e.error._tag !== "StatusCodeError") {
-        return Effect.fail(e)
-      }
-
-      const response = e.error.response
+  ): Effect.Effect<never, DiscordRESTError, ResponseWithData<A>> =>
+    requestRateLimit(request.url, request).pipe(
+      Effect.zipLeft(globalRateLimit),
+      Effect.zipRight(
+        httpExecutor(request) as Effect.Effect<
+          never,
+          DiscordRESTError,
+          ResponseWithData<A>
+        >,
+      ),
+      Effect.tap(response => updateBuckets(request, response)),
+      Effect.catchTag("DiscordRESTError", e => {
+        if (e.error._tag !== "StatusCodeError") {
+          return Effect.fail(e)
+        }
 
-      switch (e.error.status) {
-        case 403:
-          return Do($ => {
-            $(
-              Effect.allParDiscard([
-                log.info("DiscordREST", "403", request.url),
-                addBadRoute(routeFromConfig(request.url, request.method)),
-                updateBuckets(request, response),
-              ]),
+        const response = e.error.response
+
+        switch (e.error.status) {
+          case 403:
+            return Effect.zipRight(
+              Effect.all(
+                [
+                  log.info("DiscordREST", "403", request.url),
+                  addBadRoute(routeFromConfig(request.url, request.method)),
+                  updateBuckets(request, response),
+                ],
+                { concurrency: "unbounded", discard: true },
+              ),
+              Effect.fail(e),
             )
-            return $(Effect.fail(e))
-          })
 
-        case 429:
-          return Do($ => {
-            $(
-              Effect.allParDiscard([
+          case 429:
+            return Effect.zipRight(
+              Effect.all(
                 log.info("DiscordREST", "429", request.url),
                 addBadRoute(routeFromConfig(request.url, request.method)),
                 updateBuckets(request, response),
                 Effect.sleep(
-                  retryAfter(response.headers).getOrElse(() =>
+                  Option.getOrElse(retryAfter(response.headers), () =>
                     Duration.seconds(5),
                   ),
                 ),
-              ]),
+                { concurrency: "unbounded", discard: true },
+              ),
+              executor<A>(request),
             )
-            return $(executor<A>(request))
-          })
-      }
+        }
 
-      return Effect.fail(e)
-    })
+        return Effect.fail(e)
+      }),
+    )
 
   const routes = Discord.createRoutes<Partial<Http.MakeOptions>>(
     <R, P>({
       method,
-      url,
-      params,
       options = {},
+      params,
+      url,
     }: Discord.Route<P, Partial<Http.MakeOptions>>): RestResponse<R> => {
       const hasBody = method !== "GET" && method !== "DELETE"
       let request = Http.make(method as any)(url, options)
 
       if (!hasBody) {
         if (params) {
-          request = request.appendParams(params as any)
+          request = Http.appendParams(request, params as any)
         }
       } else if (
         params &&
@@ -197,7 +224,7 @@ const make = Do($ => {
       ) {
         request.body.value.value.append("payload_json", JSON.stringify(params))
       } else if (params) {
-        request = request.jsonBody(params)
+        request = Http.jsonBody(request, params)
       }
 
       return executor(request)
@@ -214,9 +241,11 @@ export interface DiscordREST
   extends Discord.Endpoints<Partial<Http.MakeOptions>> {
   readonly executor: <A = unknown>(
     request: Http.Request,
-  ) => Effect<never, DiscordRESTError, ResponseWithData<A>>
+  ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>
 }
 
 export const DiscordREST = Tag<DiscordREST>()
-export const LiveDiscordREST =
-  LiveRateLimiter >> Layer.effect(DiscordREST, make)
+export const LiveDiscordREST = Layer.provide(
+  LiveRateLimiter,
+  Layer.effect(DiscordREST, make),
+)

package/src/Helpers/intents.ts

@@ -1,4 +1,5 @@
 import * as Flags from "dfx/Helpers/flags"
+import * as Discord from "dfx/types"
 
 /**
  * All the intents

package/src/Helpers/interactions.ts

@@ -1,8 +1,11 @@
-import { Option as Maybe, Product } from "@effect/data/Option"
+import * as Option from "@effect/data/Option"
 import * as Arr from "@effect/data/ReadonlyArray"
+import * as Discord from "dfx/types"
+import { identity, pipe } from "@effect/data/Function"
+import * as HashMap from "@effect/data/HashMap"
 
 /**
- * Maybe find a sub-command within the interaction options.
+ * Option find a sub-command within the interaction options.
  */
 export const allSubCommands = (interaction: Discord.ApplicationCommandDatum) =>
   pipe(
@@ -13,7 +16,7 @@ export const allSubCommands = (interaction: Discord.ApplicationCommandDatum) =>
   )
 
 /**
- * Maybe find a sub-command within the interaction options.
+ * Option find a sub-command within the interaction options.
  */
 export const findSubCommand =
   (name: string) => (interaction: Discord.ApplicationCommandDatum) =>
@@ -29,14 +32,16 @@ export const findSubCommand =
 /**
  * If the sub-command exists return `true`, else `false`.
  */
-export const isSubCommand = (name: string) =>
-  flow(findSubCommand(name), o => o.isSome())
+export const isSubCommand =
+  (name: string) => (_: Discord.ApplicationCommandDatum) =>
+    Option.isSome(findSubCommand(name)(_))
 
 /**
- * Maybe get the options for a sub-command
+ * Option get the options for a sub-command
  */
-export const subCommandOptions = (name: string) =>
-  flow(findSubCommand(name), o => o.flatMapNullable(o => o.options))
+export const subCommandOptions =
+  (name: string) => (_: Discord.ApplicationCommandDatum) =>
+    Option.flatMapNullable(findSubCommand(name)(_), o => o.options)
 
 /**
  * A lens for accessing nested options in a interaction.
@@ -47,13 +52,15 @@ export const optionsWithNested = (
   const optsFromOption = (
     opt: Discord.ApplicationCommandInteractionDataOption,
   ): Discord.ApplicationCommandInteractionDataOption[] =>
-    Maybe.fromNullable(opt.options)
-      .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
-      .match(() => [], identity)
+    Option.fromNullable(opt.options).pipe(
+      Option.map(opts => [...opts, ...opts.flatMap(optsFromOption)]),
+      Option.match({ onNone: () => [], onSome: identity }),
+    )
 
-  return Maybe.fromNullable(data.options)
-    .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
-    .getOrElse(() => [])
+  return Option.fromNullable(data.options).pipe(
+    Option.map(opts => [...opts, ...opts.flatMap(optsFromOption)]),
+    Option.getOrElse(() => []),
+  )
 }
 
 /**
@@ -63,43 +70,44 @@ export const transformOptions = (
   options: Discord.ApplicationCommandInteractionDataOption[],
 ) =>
   options.reduce(
-    (map, option) => map.set(option.name, option.value),
+    (map, option) => HashMap.set(map, option.name, option.value),
     HashMap.empty<string, string | undefined>(),
   )
 
 /**
  * Return the interaction options as a name / value map.
  */
-export const optionsMap = flow(optionsWithNested, transformOptions)
+export const optionsMap = (
+  data: Pick<Discord.ApplicationCommandDatum, "options">,
+) => transformOptions(optionsWithNested(data))
 
 /**
  * Try find a matching option from the interaction.
  */
-export const getOption = (name: string) =>
-  flow(
-    optionsWithNested,
-    Arr.findFirst(o => o.name === name),
-  )
+export const getOption =
+  (name: string) => (data: Pick<Discord.ApplicationCommandDatum, "options">) =>
+    Arr.findFirst(optionsWithNested(data), o => o.name === name)
 
 /**
  * Try find a matching option from the interaction.
  */
-export const focusedOption = flow(
-  optionsWithNested,
-  Arr.findFirst(o => o.focused === true),
-)
+export const focusedOption = (
+  data: Pick<Discord.ApplicationCommandDatum, "options">,
+) => Arr.findFirst(optionsWithNested(data), o => o.focused === true)
 
 /**
  * Try find a matching option value from the interaction.
  */
-export const optionValue = (name: string) =>
-  flow(getOption(name), o => o.flatMapNullable(o => o.value))
+export const optionValue =
+  (name: string) => (data: Pick<Discord.ApplicationCommandDatum, "options">) =>
+    Option.flatMapNullable(getOption(name)(data), o => o.value)
 
 /**
  * Try extract resolved data
  */
 export const resolved = (data: Discord.Interaction) =>
-  Maybe.fromNullable(data.data).flatMapNullable(
+  Option.flatMapNullable(
+    Option.fromNullable(data.data),
     a => (a as Discord.ApplicationCommandDatum).resolved,
   )
 
@@ -111,19 +119,20 @@ export const resolveOptionValue =
     name: string,
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
   ) =>
-  (a: Discord.Interaction): Maybe<T> =>
-    Do($ => {
-      const data = $(
-        Maybe.fromNullable(a.data as Discord.ApplicationCommandDatum),
-      )
-      const id = $(
-        getOption(name)(data).flatMapNullable(
+  (a: Discord.Interaction): Option.Option<T> =>
+    Option.Do().pipe(
+      Option.bind("data", () =>
+        Option.fromNullable(a.data as Discord.ApplicationCommandDatum),
+      ),
+      Option.bind("id", ({ data }) =>
+        Option.flatMapNullable(
+          getOption(name)(data),
           ({ value }) => value as Discord.Snowflake,
         ),
-      )
-      const r = $(resolved(a))
-      return $(Maybe.fromNullable(f(id, r)))
-    })
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.flatMapNullable(({ id, r }) => f(id, r)),
+    )
 
 /**
  * Try find matching option values from the interaction.
@@ -132,18 +141,19 @@ export const resolveValues =
   <T>(
     f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
   ) =>
-  (a: Discord.Interaction): Maybe<readonly T[]> =>
-    Do($ => {
-      const values = $(
-        Maybe.fromNullable(
-          a.data as Discord.MessageComponentDatum,
-        ).flatMapNullable(a => a.values as unknown as string[]),
-      )
-      const r = $(resolved(a))
-      return $(
-        Product.productAll(values.map(a => Maybe.fromNullable(f(a as any, r)))),
-      )
-    })
+  (a: Discord.Interaction): Option.Option<readonly T[]> =>
+    Option.Do().pipe(
+      Option.bind("values", () =>
+        Option.flatMapNullable(
+          Option.fromNullable(a.data as Discord.MessageComponentDatum),
+          a => a.values as unknown as string[],
+        ),
+      ),
+      Option.bind("r", () => resolved(a)),
+      Option.map(({ values, r }) =>
+        Arr.compact(values.map(a => Option.fromNullable(f(a as any, r)))),
+      ),
+    )
 
 const extractComponents = (c: Discord.Component): Discord.Component[] => {
   if ("components" in c) {
@@ -166,41 +176,42 @@ export const components = (
 /**
  * A lens for accessing the components in a interaction.
  */
-export const componentsWithValue = flow(
-  components,
-  Arr.filter(c => "value" in c && c.value !== undefined),
-)
+export const componentsWithValue = (data: Discord.ModalSubmitDatum) =>
+  Arr.filter(components(data), c => "value" in c && c.value !== undefined)
 
 /**
  * Return the interaction components as an id / value map.
  */
 export const transformComponents = (options: Discord.Component[]) =>
   (options as Discord.TextInput[]).reduce(
-    (map, c) => (c.custom_id ? map.set(c.custom_id, c.value) : map),
+    (map, c) => (c.custom_id ? HashMap.set(map, c.custom_id, c.value) : map),
     HashMap.empty<string, string | undefined>(),
   )
 
 /**
  * Return the interaction components as an id / value map.
  */
-export const componentsMap = flow(components, transformComponents)
+export const componentsMap = (data: Discord.ModalSubmitDatum) =>
+  transformComponents(components(data))
 
 /**
  * Try find a matching component from the interaction.
  */
-export const getComponent = (id: string) =>
-  flow(
-    components,
-    Arr.findFirst(o => (o as Discord.TextInput).custom_id === id),
+export const getComponent = (id: string) => (data: Discord.ModalSubmitDatum) =>
+  Arr.findFirst(
+    components(data),
+    o => (o as Discord.TextInput).custom_id === id,
   )
 
 /**
  * Try find a matching component value from the interaction.
  */
-export const componentValue = (id: string) =>
-  flow(getComponent(id), o =>
-    o.flatMapNullable(o => (o as Discord.TextInput).value),
-  )
+export const componentValue =
+  (id: string) => (data: Discord.ModalSubmitDatum) =>
+    Option.flatMapNullable(
+      getComponent(id)(data),
+      o => (o as Discord.TextInput).value,
+    )
 
 export type InteractionResponse =
   | {

package/src/Helpers/members.ts

@@ -1,3 +1,5 @@
+import * as Discord from "dfx/types"
+
 /**
  * From a list of roles, filter out the ones the guild member has.
  */

package/src/Helpers/permissions.ts

@@ -1,5 +1,8 @@
+import { pipe } from "@effect/data/Function"
+import * as Effect from "@effect/io/Effect"
 import * as Flags from "dfx/Helpers/flags"
 import * as Members from "dfx/Helpers/members"
+import * as Discord from "dfx/types"
 
 /**
  * A constant of all the permissions
@@ -109,7 +112,7 @@ export const applyOverwrites =
 interface RolesCache<E> {
   getForParent: (
     parentId: string,
-  ) => Effect<never, E, ReadonlyMap<string, Discord.Role>>
+  ) => Effect.Effect<never, E, ReadonlyMap<string, Discord.Role>>
 }
 
 export const hasInChannel =
@@ -118,8 +121,7 @@ export const hasInChannel =
     channel: Discord.Channel,
     memberOrRole: Discord.GuildMember | Discord.Role,
   ) =>
-    Do($ => {
-      const roles = $(rolesCache.getForParent(channel.guild_id!))
+    Effect.map(rolesCache.getForParent(channel.guild_id!), roles => {
       const channelPerms = forChannel([...roles.values()])(channel)(
         memberOrRole,
       )
@@ -129,8 +131,7 @@ export const hasInChannel =
 export const hasInGuild =
   <E>(rolesCache: RolesCache<E>, permission: bigint) =>
   (guildId: Discord.Snowflake, member: Discord.GuildMember) =>
-    Do($ => {
-      const roles = $(rolesCache.getForParent(guildId))
+    Effect.map(rolesCache.getForParent(guildId), roles => {
       const hasPerm = has(permission)
 
       return member.roles.some(id => {