dfx 0.60.0 → 0.61.1

package/src/DiscordREST.ts

@@ -1,4 +1,3 @@
-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"
@@ -9,6 +8,7 @@ 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 * as Http from "@effect/platform/HttpClient"
 import { DiscordConfig } from "dfx/DiscordConfig"
 import type { ResponseWithData, RestResponse } from "dfx/DiscordREST/types"
 import {
@@ -17,21 +17,22 @@ import {
   routeFromConfig,
 } from "dfx/DiscordREST/utils"
 import { Log } from "dfx/Log"
-import { LiveRateLimiter, RateLimitStore, RateLimiter } from "dfx/RateLimit"
+import { LiveRateLimiter, RateLimiter, RateLimitStore } from "dfx/RateLimit"
 import * as Discord from "dfx/types"
 import { LIB_VERSION } from "dfx/version"
 
 export class DiscordRESTError {
   readonly _tag = "DiscordRESTError"
-  constructor(readonly error: Http.HttpClientError, readonly body?: unknown) {}
+  constructor(
+    readonly error: Http.error.HttpClientError,
+    readonly body?: unknown,
+  ) {}
 }
 
-export { ResponseDecodeError } from "@effect-http/client"
-
-const make = Effect.gen(function* (_) {
+const make = Effect.gen(function*(_) {
   const { rest, token } = yield* _(DiscordConfig)
 
-  const http = yield* _(Http.HttpRequestExecutor)
+  const http = yield* _(Http.client.Client)
   const log = yield* _(Log)
   const store = yield* _(RateLimitStore)
   const { maybeWait } = yield* _(RateLimiter)
@@ -64,13 +65,16 @@ const make = Effect.gen(function* (_) {
       Effect.tap(invalid =>
         invalid
           ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
-          : Effect.unit,
+          : Effect.unit
       ),
       Effect.asUnit,
     )
 
   // Request rate limiting
-  const requestRateLimit = (path: string, request: Http.Request) =>
+  const requestRateLimit = (
+    path: string,
+    request: Http.request.ClientRequest,
+  ) =>
     Effect.Do.pipe(
       Effect.let("route", () => routeFromConfig(path, request.method)),
       Effect.bind("maybeBucket", ({ route }) => store.getBucketForRoute(route)),
@@ -86,17 +90,21 @@ const make = Effect.gen(function* (_) {
                 bucket.limit,
               ),
             ),
-        }),
+        })
       ),
     )
 
   // Update rate limit buckets
-  const updateBuckets = (request: Http.Request, response: Http.Response) =>
+  const updateBuckets = (
+    request: Http.request.ClientRequest,
+    response: Http.response.ClientResponse,
+  ) =>
     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.bind(
+        "hasBucket",
+        ({ rateLimit }) => store.hasBucket(rateLimit.bucket),
       ),
       Effect.flatMap(({ hasBucket, rateLimit, route }) => {
         const effectsToRun = [
@@ -110,10 +118,9 @@ const make = Effect.gen(function* (_) {
             store.putBucket({
               key: rateLimit.bucket,
               resetAfter: Duration.toMillis(rateLimit.retryAfter),
-              limit:
-                !hasBucket && rateLimit.remaining > 0
-                  ? rateLimit.remaining
-                  : rateLimit.limit,
+              limit: !hasBucket && rateLimit.remaining > 0
+                ? rateLimit.remaining
+                : rateLimit.limit,
             }),
           )
         }
@@ -127,31 +134,31 @@ const make = Effect.gen(function* (_) {
     )
 
   const httpExecutor = pipe(
-    http.execute,
-    Http.executor.filterStatusOk,
-    Http.executor.contramap(req =>
+    Http.client.filterStatusOk(http),
+    Http.client.mapRequest(req =>
       pipe(
-        Http.updateUrl(req, _ => `${rest.baseUrl}${_}`),
-        Http.setHeaders({
+        Http.request.prependUrl(req, rest.baseUrl),
+        Http.request.setHeaders({
           Authorization: `Bot ${ConfigSecret.value(token)}`,
-          "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
+          "User-Agent":
+            `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
         }),
-      ),
+      )
     ),
-    Http.executor.catchAll(error =>
-      error._tag === "StatusCodeError"
+    Http.client.catchAll(error =>
+      error.reason === "StatusCode"
         ? error.response.json.pipe(
-            Effect.mapError(_ => new DiscordRESTError(_)),
-            Effect.flatMap(body =>
-              Effect.fail(new DiscordRESTError(error, body)),
-            ),
-          )
-        : Effect.fail(new DiscordRESTError(error)),
+          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,
+    request: Http.request.ClientRequest,
   ): Effect.Effect<never, DiscordRESTError, ResponseWithData<A>> =>
     requestRateLimit(request.url, request).pipe(
       Effect.zipLeft(globalRateLimit),
@@ -164,13 +171,13 @@ const make = Effect.gen(function* (_) {
       ),
       Effect.tap(response => updateBuckets(request, response)),
       Effect.catchTag("DiscordRESTError", e => {
-        if (e.error._tag !== "StatusCodeError") {
+        if (e.error.reason !== "StatusCode") {
           return Effect.fail(e)
         }
 
         const response = e.error.response
 
-        switch (e.error.status) {
+        switch (response.status) {
           case 403:
             return Effect.zipRight(
               Effect.all(
@@ -194,8 +201,9 @@ const make = Effect.gen(function* (_) {
                 Effect.zipRight(updateBuckets(request, response)),
                 Effect.zipRight(
                   Effect.sleep(
-                    Option.getOrElse(retryAfter(response.headers), () =>
-                      Duration.seconds(5),
+                    Option.getOrElse(
+                      retryAfter(response.headers),
+                      () => Duration.seconds(5),
                     ),
                   ),
                 ),
@@ -207,28 +215,26 @@ const make = Effect.gen(function* (_) {
       }),
     )
 
-  const routes = Discord.createRoutes<Partial<Http.MakeOptions>>(
+  const routes = Discord.createRoutes<Partial<Http.request.Options.NoUrl>>(
     <R, P>({
       method,
       options = {},
       params,
       url,
-    }: Discord.Route<P, Partial<Http.MakeOptions>>): RestResponse<R> => {
+    }: Discord.Route<P, Partial<Http.request.Options.NoUrl>>): RestResponse<
+      R
+    > => {
       const hasBody = method !== "GET" && method !== "DELETE"
-      let request = Http.make(method as any)(url, options)
+      let request = Http.request.make(method as any)(url, options)
 
       if (!hasBody) {
         if (params) {
-          request = Http.appendParams(request, params as any)
+          request = Http.request.appendUrlParams(request, params as any)
         }
-      } else if (
-        params &&
-        request.body._tag === "Some" &&
-        request.body.value._tag === "FormDataBody"
-      ) {
-        request.body.value.value.append("payload_json", JSON.stringify(params))
+      } else if (params && request.body._tag === "FormData") {
+        request.body.formData.append("payload_json", JSON.stringify(params))
       } else if (params) {
-        request = Http.jsonBody(request, params)
+        request = Http.request.jsonBody(request, params)
       }
 
       return executor(request)
@@ -242,14 +248,15 @@ const make = Effect.gen(function* (_) {
 })
 
 export interface DiscordREST
-  extends Discord.Endpoints<Partial<Http.MakeOptions>> {
+  extends Discord.Endpoints<Partial<Http.request.Options.NoUrl>>
+{
   readonly executor: <A = unknown>(
-    request: Http.Request,
+    request: Http.request.ClientRequest,
   ) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>
 }
 
 export const DiscordREST = Tag<DiscordREST>()
-export const LiveDiscordREST = Layer.provide(
-  LiveRateLimiter,
-  Layer.effect(DiscordREST, make),
+export const LiveDiscordREST = Layer.effect(DiscordREST, make).pipe(
+  Layer.use(LiveRateLimiter),
+  Layer.use(Http.client.fetchLayer),
 )

package/src/Helpers/flags.ts

@@ -33,16 +33,14 @@ export function toList<T extends Flags<any>>(
  * Returns a function that converts a list of flags names to a bigint bitfield.
  */
 export const fromListBigint =
-  <T extends Flags<bigint>>(flags: T) =>
-  (list: Array<keyof T>) =>
+  <T extends Flags<bigint>>(flags: T) => (list: Array<keyof T>) =>
     list.reduce((acc, key) => acc | flags[key], BigInt(0))
 
 /**
  * Returns a function that converts a list of flags names to a bitfield.
  */
 export const fromList =
-  <T extends Flags<number>>(flags: T) =>
-  (list: Array<keyof T>) =>
+  <T extends Flags<number>>(flags: T) => (list: Array<keyof T>) =>
     list.reduce((acc, key) => acc | flags[key], 0)
 
 /**

package/src/Helpers/intents.ts

@@ -9,10 +9,9 @@ export const ALL = Flags.all(Discord.GatewayIntents)
 /**
  * Privileged intents
  */
-export const PRIVILEGED =
-  Discord.GatewayIntents.GUILD_PRESENCES |
-  Discord.GatewayIntents.GUILD_MEMBERS |
-  Discord.GatewayIntents.MESSAGE_CONTENT
+export const PRIVILEGED = Discord.GatewayIntents.GUILD_PRESENCES
+  | Discord.GatewayIntents.GUILD_MEMBERS
+  | Discord.GatewayIntents.MESSAGE_CONTENT
 
 /**
  * Un-privileged intents

package/src/Helpers/interactions.ts

@@ -1,8 +1,8 @@
+import { identity, pipe } from "@effect/data/Function"
+import * as HashMap from "@effect/data/HashMap"
 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"
 
 /**
  * Option find a sub-command within the interaction options.
@@ -24,8 +24,8 @@ export const findSubCommand =
       optionsWithNested(interaction),
       Arr.findFirst(
         o =>
-          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND &&
-          o.name === name,
+          o.type === Discord.ApplicationCommandOptionType.SUB_COMMAND
+          && o.name === name,
       ),
     )
 
@@ -114,46 +114,42 @@ export const resolved = (data: Discord.Interaction) =>
 /**
  * Try find a matching option value from the interaction.
  */
-export const resolveOptionValue =
-  <T>(
-    name: string,
-    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) =>
-  (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,
-        ),
-      ),
-      Option.bind("r", () => resolved(a)),
-      Option.flatMapNullable(({ id, r }) => f(id, r)),
-    )
+export const resolveOptionValue = <T>(
+  name: string,
+  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+) =>
+(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,
+      )),
+    Option.bind("r", () => resolved(a)),
+    Option.flatMapNullable(({ id, r }) => f(id, r)),
+  )
 
 /**
  * Try find matching option values from the interaction.
  */
-export const resolveValues =
-  <T>(
-    f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
-  ) =>
-  (a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
-    Option.Do.pipe(
-      Option.bind("values", () =>
-        Option.flatMapNullable(
-          Option.fromNullable(a.data as Discord.MessageComponentDatum),
-          a => a.values as unknown as Array<string>,
-        ),
-      ),
-      Option.bind("r", () => resolved(a)),
-      Option.map(({ r, values }) =>
-        Arr.compact(values.map(a => Option.fromNullable(f(a as any, r)))),
-      ),
-    )
+export const resolveValues = <T>(
+  f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => T | undefined,
+) =>
+(a: Discord.Interaction): Option.Option<ReadonlyArray<T>> =>
+  Option.Do.pipe(
+    Option.bind("values", () =>
+      Option.flatMapNullable(
+        Option.fromNullable(a.data as Discord.MessageComponentDatum),
+        a => a.values as unknown as Array<string>,
+      )),
+    Option.bind("r", () => resolved(a)),
+    Option.map(({ r, values }) =>
+      Arr.compact(values.map(a => Option.fromNullable(f(a as any, r))))
+    ),
+  )
 
 const extractComponents = (c: Discord.Component): Array<Discord.Component> => {
   if ("components" in c) {
@@ -215,26 +211,27 @@ export const componentValue =
 
 export type InteractionResponse =
   | {
-      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
-      data: Discord.InteractionCallbackMessage
-    }
+    type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
+    data: Discord.InteractionCallbackMessage
+  }
   | {
-      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
-      data: Discord.InteractionCallbackMessage
-    }
+    type: Discord.InteractionCallbackType.UPDATE_MESSAGE
+    data: Discord.InteractionCallbackMessage
+  }
   | {
-      type: Discord.InteractionCallbackType.MODAL
-      data: Discord.InteractionCallbackModal
-    }
+    type: Discord.InteractionCallbackType.MODAL
+    data: Discord.InteractionCallbackModal
+  }
   | {
-      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
-    }
+    type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
+  }
   | {
-      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-    }
+    type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
+  }
   | {
-      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-      data: Discord.InteractionCallbackAutocomplete
-    }
+    type:
+      Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
+    data: Discord.InteractionCallbackAutocomplete
+  }
 
 export const response = (r: InteractionResponse) => r

package/src/Helpers/members.ts

@@ -13,5 +13,5 @@ export const roles =
  * Type-guard function for checking if the object is a guild member
  */
 export const is = (thing: unknown): thing is Discord.GuildMember =>
-  Object.prototype.hasOwnProperty.call(thing, "roles") &&
-  Object.prototype.hasOwnProperty.call(thing, "joined_at")
+  Object.prototype.hasOwnProperty.call(thing, "roles")
+  && Object.prototype.hasOwnProperty.call(thing, "joined_at")

package/src/Helpers/permissions.ts

@@ -84,8 +84,8 @@ export const forChannel =
     } else {
       const everyone = roles.find(role => role.name === "@everyone")
 
-      basePermissions =
-        BigInt(everyone?.permissions || "0") | BigInt(memberOrRole.permissions)
+      basePermissions = BigInt(everyone?.permissions || "0")
+        | BigInt(memberOrRole.permissions)
       filteredOverwrites = overwrites.filter(
         overwriteIsForRole(guild_id)(memberOrRole),
       )

package/src/Interactions/builder.ts

@@ -1,17 +1,15 @@
-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 * as Http from "@effect/platform/HttpClient"
 import { DiscordREST, type DiscordRESTError } from "dfx/DiscordREST"
-import type * as Discord from "dfx/types"
 import type * as D from "dfx/Interactions/definitions"
+import type * as Discord from "dfx/types"
 
-type ExtractTag<A> = A extends { _tag: infer Tag }
-  ? Tag extends string
-    ? Tag
-    : never
+type ExtractTag<A> = A extends { _tag: infer Tag } ? Tag extends string ? Tag
+  : never
   : never
 
 /**
@@ -132,15 +130,17 @@ export class InteractionBuilder<R, E, TE> {
       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(Chunk.toReadonlyArray(commands)),
-          }),
+    return Effect.flatMap(
+      DiscordREST,
+      rest =>
+        rest.getCurrentBotApplicationInformation().pipe(
+          Effect.flatMap(r => r.json),
+          Effect.flatMap(app =>
+            rest.bulkOverwriteGlobalApplicationCommands(app.id, {
+              body: Http.body.json(Chunk.toReadonlyArray(commands)),
+            })
+          ),
         ),
-      ),
     )
   }
 
@@ -154,12 +154,14 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(DiscordREST, rest =>
-      rest.bulkOverwriteGuildApplicationCommands(
-        appId,
-        guildId,
-        Chunk.toReadonlyArray(commands) as any,
-      ),
+    return Effect.flatMap(
+      DiscordREST,
+      rest =>
+        rest.bulkOverwriteGuildApplicationCommands(
+          appId,
+          guildId,
+          Chunk.toReadonlyArray(commands) as any,
+        ),
     )
   }
 }

package/src/Interactions/context.ts

@@ -33,8 +33,7 @@ export const resolvedValues = <A>(
     Effect.mapError(
       IxHelpers.resolveValues(f)(ix),
       () => new ResolvedDataNotFound(ix),
-    ),
-  )
+    ))
 
 export const resolved = <A>(
   name: string,
@@ -44,8 +43,7 @@ export const resolved = <A>(
     Effect.mapError(
       IxHelpers.resolveOptionValue(name, f)(ix),
       () => new ResolvedDataNotFound(ix, name),
-    ),
-  )
+    ))
 
 export const focusedOptionValue = Effect.map(
   FocusedOptionContext,
@@ -66,20 +64,18 @@ export const handleSubCommands = <
   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
-      : never)
+    { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
+  ] ? E
+    : never)
   | SubCommandNotFound,
   Discord.InteractionResponse
 > =>
@@ -88,12 +84,12 @@ export const handleSubCommands = <
       Effect.mapError(
         Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name]),
         () => new SubCommandNotFound(data),
-      ),
+      )
     ),
     Effect.flatMap(command =>
       Effect.provideService(commands[command.name], SubCommandContext, {
         command,
-      }),
+      })
     ),
   )
 
@@ -129,12 +125,10 @@ export const optionValue = (name: string) =>
       {
         onNone: () =>
           Effect.flatMap(ApplicationCommand, data =>
-            Effect.fail(new RequiredOptionNotFound(data, name)),
-          ),
+            Effect.fail(new RequiredOptionNotFound(data, name))),
         onSome: Effect.succeed,
       },
-    ),
-  )
+    ))
 
 export const optionValueOptional = (name: string) =>
   Effect.map(
@@ -157,5 +151,4 @@ export const modalValue = (name: string) =>
     Effect.mapError(
       IxHelpers.componentValue(name)(data),
       () => new ModalValueNotFound(data, name),
-    ),
-  )
+    ))