dfx 0.127.0 → 1.0.1

package/src/DiscordREST/utils.ts

@@ -1,6 +1,7 @@
 import * as Duration from "effect/Duration"
+import { pipe } from "effect/Function"
 import * as Option from "effect/Option"
-import * as Headers from "@effect/platform/Headers"
+import * as Headers from "effect/unstable/http/Headers"
 
 const majorResources = ["channels", "guilds", "webhooks"] as const
 
@@ -18,7 +19,9 @@ export const routeFromConfig = (path: string, method: string) => {
 }
 
 export const numberHeader = (headers: Headers.Headers) => (key: string) =>
-  Headers.get(headers, key).pipe(
+  pipe(
+    Headers.get(headers, key),
+    Option.fromUndefinedOr,
     Option.map(parseFloat),
     Option.filter(n => !isNaN(n)),
   )
@@ -31,7 +34,7 @@ export const retryAfter = (headers: Headers.Headers) =>
 
 export const rateLimitFromHeaders = (headers: Headers.Headers) =>
   Option.all({
-    bucket: Headers.get(headers, "x-ratelimit-bucket"),
+    bucket: Option.fromUndefinedOr(Headers.get(headers, "x-ratelimit-bucket")),
     retryAfter: retryAfter(headers),
     limit: numberHeader(headers)("x-ratelimit-limit"),
     remaining: numberHeader(headers)("x-ratelimit-remaining"),

package/src/DiscordREST.ts

@@ -1,19 +1,12 @@
-import * as HttpBody from "@effect/platform/HttpBody"
-import * as HttpClient from "@effect/platform/HttpClient"
-import type { HttpClientError } from "@effect/platform/HttpClientError"
-import * as HttpRequest from "@effect/platform/HttpClientRequest"
-import type * as HttpResponse from "@effect/platform/HttpClientResponse"
-import { DiscordConfig } from "dfx/DiscordConfig"
+import { DiscordConfig } from "./DiscordConfig.ts"
 import {
   rateLimitFromHeaders,
   retryAfter,
   routeFromConfig,
-} from "dfx/DiscordREST/utils"
-import { RateLimitStore, RateLimiter, RateLimiterLive } from "dfx/RateLimit"
-import * as Discord from "dfx/types"
-import { LIB_VERSION } from "dfx/version"
-import * as Context from "effect/Context"
-import { GenericTag } from "effect/Context"
+} from "./DiscordREST/utils.ts"
+import { RateLimitStore, RateLimiter, RateLimiterLive } from "./RateLimit.ts"
+import * as Discord from "./types.ts"
+import { LIB_VERSION } from "./version.ts"
 import * as Duration from "effect/Duration"
 import { millis } from "effect/Duration"
 import * as Effect from "effect/Effect"
@@ -22,6 +15,12 @@ import { flow } from "effect/Function"
 import * as Layer from "effect/Layer"
 import * as Option from "effect/Option"
 import * as Redacted from "effect/Redacted"
+import * as ServiceMap from "effect/ServiceMap"
+import * as HttpBody from "effect/unstable/http/HttpBody"
+import * as HttpClient from "effect/unstable/http/HttpClient"
+import type { HttpClientError } from "effect/unstable/http/HttpClientError"
+import * as HttpRequest from "effect/unstable/http/HttpClientRequest"
+import type * as HttpResponse from "effect/unstable/http/HttpClientResponse"
 
 const make = Effect.gen(function* () {
   const { rest, token } = yield* DiscordConfig
@@ -31,7 +30,7 @@ const make = Effect.gen(function* () {
 
   const globalRateLimit = maybeWait(
     "dfx.rest.global",
-    Duration.decode(rest.globalRateLimit.window),
+    Duration.fromInputUnsafe(rest.globalRateLimit.window),
     rest.globalRateLimit.limit,
   )
 
@@ -44,7 +43,7 @@ const make = Effect.gen(function* () {
       badRoutes.add(route)
       return Effect.log("bad route")
     }).pipe(
-      Effect.zipRight(
+      Effect.andThen(
         store.incrementCounter("dfx.rest.invalid", tenMinutesMillis, 10000),
       ),
       Effect.annotateLogs("route", route),
@@ -84,19 +83,19 @@ const make = Effect.gen(function* () {
     if (Option.isNone(rateLimitOption)) return
     const rateLimit = rateLimitOption.value
     const hasBucket = yield* store.hasBucket(rateLimit.bucket)
-    const fibers: Array<Fiber.RuntimeFiber<unknown, unknown>> = []
+    const fibers: Array<Fiber.Fiber<unknown, unknown>> = []
 
     badRoutes.delete(route)
     fibers.push(
-      yield* Effect.fork(store.putBucketRoute(route, rateLimit.bucket)),
+      yield* Effect.forkChild(store.putBucketRoute(route, rateLimit.bucket)),
     )
 
     if (!hasBucket || rateLimit.limit - 1 === rateLimit.remaining) {
       fibers.push(
-        yield* Effect.fork(store.removeCounter(`dfx.rest.?.${route}`)),
+        yield* Effect.forkChild(store.removeCounter(`dfx.rest.?.${route}`)),
       )
       fibers.push(
-        yield* Effect.fork(
+        yield* Effect.forkChild(
           store.putBucket({
             key: rateLimit.bucket,
             resetAfter: Duration.toMillis(rateLimit.retryAfter),
@@ -109,19 +108,17 @@ const make = Effect.gen(function* () {
       )
     }
 
-    for (const fiber of fibers) {
-      if (!fiber.unsafePoll()) {
-        yield* fiber.await
-      }
-    }
+    yield* Fiber.awaitAll(fibers)
   })
 
   const defaultClient = (yield* HttpClient.HttpClient).pipe(
-    HttpClient.withTracerPropagation(false),
+    HttpClient.transformResponse(
+      Effect.provideService(HttpClient.TracerPropagationEnabled, false),
+    ),
   )
   const rateLimitedClient: HttpClient.HttpClient = defaultClient.pipe(
     HttpClient.tapRequest(request =>
-      Effect.zipRight(requestRateLimit(request.url, request), globalRateLimit),
+      Effect.andThen(requestRateLimit(request.url, request), globalRateLimit),
     ),
     HttpClient.transformResponse(
       flow(
@@ -153,18 +150,18 @@ const make = Effect.gen(function* () {
                 "url",
                 request.url,
               ).pipe(
-                Effect.zipRight(
+                Effect.andThen(
                   addBadRoute(routeFromConfig(request.url, request.method)),
                 ),
-                Effect.zipRight(updateBuckets(request, response)),
-                Effect.zipRight(
+                Effect.andThen(updateBuckets(request, response)),
+                Effect.andThen(
                   Effect.sleep(
                     Option.getOrElse(retryAfter(response.headers), () =>
                       Duration.seconds(5),
                     ),
                   ),
                 ),
-                Effect.zipRight(rateLimitedClient.execute(request)),
+                Effect.andThen(rateLimitedClient.execute(request)),
               )
           }
 
@@ -180,7 +177,7 @@ const make = Effect.gen(function* () {
 
   const httpClient = HttpClient.mapRequestInputEffect(rateLimitedClient, req =>
     Effect.sync(() => {
-      const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
+      const fiber = Fiber.getCurrent()!
       let request = req.pipe(
         HttpRequest.prependUrl(rest.baseUrl),
         HttpRequest.setHeaders({
@@ -188,7 +185,7 @@ const make = Effect.gen(function* () {
           "User-Agent": `DiscordBot (https://github.com/tim-smart/dfx, ${LIB_VERSION})`,
         }),
       )
-      const formData = Context.getOption(fiber.currentContext, DiscordFormData)
+      const formData = ServiceMap.getOption(fiber.services, DiscordFormData)
       if (Option.isSome(formData)) {
         if (request.body._tag === "Uint8Array") {
           formData.value.set(
@@ -233,13 +230,10 @@ export type DiscordRESTError =
   | Discord.DiscordRestError<"RatelimitedResponse", Discord.RatelimitedResponse>
   | Discord.DiscordRestError<"ErrorResponse", Discord.ErrorResponse>
 
-export class DiscordFormData extends Context.Tag(
-  "dfx/DiscordREST/DiscordFormData",
-)<DiscordFormData, FormData>() {}
-
-export interface DiscordREST {
-  readonly _: unique symbol
-}
+export class DiscordFormData extends ServiceMap.Service<
+  DiscordFormData,
+  FormData
+>()("dfx/DiscordREST/DiscordFormData") {}
 
 export interface DiscordRestService extends Discord.DiscordRest {
   withFormData(
@@ -250,9 +244,11 @@ export interface DiscordRestService extends Discord.DiscordRest {
   ): <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
 }
 
-export const DiscordREST = GenericTag<DiscordREST, DiscordRestService>(
-  "dfx/DiscordREST",
-)
+export class DiscordREST extends ServiceMap.Service<
+  DiscordREST,
+  DiscordRestService
+>()("dfx/DiscordREST") {}
+
 export const DiscordRESTLive: Layer.Layer<
   DiscordREST,
   never,

package/src/Helpers/flags.ts

@@ -22,11 +22,16 @@ export function toList<T extends Flags<any>>(
   flags: T,
 ): (bitfield: any) => Array<keyof T> {
   const entries = Object.entries(flags)
-  return val =>
-    entries.reduce(
-      (acc, [key, flag]) => ((val & flag) === flag ? [...acc, key] : acc),
-      [] as Array<keyof T>,
-    )
+  return val => {
+    const out = []
+    for (let i = 0; i < entries.length; i++) {
+      const [key, flag] = entries[i]
+      if ((val & flag) === flag) {
+        out.push(key)
+      }
+    }
+    return out
+  }
 }
 
 /**

package/src/Helpers/intents.ts

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

package/src/Helpers/interactions.ts

@@ -1,4 +1,4 @@
-import * as Discord from "dfx/types"
+import * as Discord from "../types.ts"
 import * as Arr from "effect/Array"
 import { identity, pipe } from "effect/Function"
 import * as HashMap from "effect/HashMap"
@@ -73,7 +73,7 @@ export const isSubCommand =
  */
 export const subCommandOptions =
   (name: string) => (_: Discord.APIApplicationCommandInteraction["data"]) =>
-    Option.flatMapNullable(findSubCommand(name)(_), o => o.options)
+    Option.flatMapNullishOr(findSubCommand(name)(_), o => o.options)
 
 /**
  * A lens for accessing nested options in a interaction.
@@ -86,7 +86,7 @@ export const optionsWithNested = (data: {
   const optsFromOption = (opt: {
     readonly options?: ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
   }): Array<Discord.APIApplicationCommandInteractionDataOption> =>
-    Option.fromNullable(opt.options).pipe(
+    Option.fromNullishOr(opt.options).pipe(
       Option.map(opts => [
         ...opts,
         ...opts.flatMap(_ => optsFromOption(_ as any)),
@@ -94,7 +94,7 @@ export const optionsWithNested = (data: {
       Option.match({ onNone: () => [], onSome: identity }),
     )
 
-  return Option.fromNullable(data.options).pipe(
+  return Option.fromNullishOr(data.options).pipe(
     Option.map(opts => [
       ...opts,
       ...opts.flatMap(_ => optsFromOption(_ as any)),
@@ -158,7 +158,7 @@ export const optionValue =
       | ReadonlyArray<Discord.APIApplicationCommandInteractionDataOption>
       | undefined
   }) =>
-    Option.flatMapNullable(getOption(name)(data), o =>
+    Option.flatMapNullishOr(getOption(name)(data), o =>
       "value" in o ? o.value : undefined,
     )
 
@@ -166,7 +166,7 @@ export const optionValue =
  * Try extract resolved data
  */
 export const resolved = (data: Discord.APIInteraction) =>
-  Option.flatMapNullable(Option.fromNullable(data.data), a =>
+  Option.flatMapNullishOr(Option.fromNullishOr(data.data), a =>
     "resolved" in a
       ? (a.resolved as Discord.InteractionDataResolved)
       : undefined,
@@ -185,15 +185,15 @@ export const resolveOptionValue =
   ) =>
   (a: Discord.APIInteraction): Option.Option<T> =>
     Option.Do.pipe(
-      Option.bind("data", () => Option.fromNullable(a.data as any)),
+      Option.bind("data", () => Option.fromNullishOr(a.data as any)),
       Option.bind("id", ({ data }) =>
-        Option.flatMapNullable(
+        Option.flatMapNullishOr(
           getOption(name)(data) as Option.Option<{ value: Discord.Snowflake }>,
           ({ value }) => value,
         ),
       ),
       Option.bind("r", () => resolved(a)),
-      Option.flatMapNullable(({ id, r }) => f(id, r)),
+      Option.flatMapNullishOr(({ id, r }) => f(id, r)),
     )
 
 /**
@@ -209,14 +209,16 @@ export const resolveValues =
   (a: Discord.APIInteraction): Option.Option<ReadonlyArray<T>> =>
     Option.Do.pipe(
       Option.bind("values", () =>
-        Option.flatMapNullable(
-          Option.fromNullable(a.data as any),
-          a => a.values as unknown as Array<string>,
+        Option.flatMapNullishOr(
+          Option.fromNullishOr(a.data as any),
+          data => data.values as unknown as Array<string>,
         ),
       ),
       Option.bind("r", () => resolved(a)),
       Option.map(({ r, values }) =>
-        Arr.getSomes(values.map(a => Option.fromNullable(f(a as any, r)))),
+        Arr.getSomes(
+          values.map(value => Option.fromNullishOr(f(value as any, r))),
+        ),
       ),
     )
 
@@ -276,7 +278,7 @@ export const getComponent =
  */
 export const componentValue =
   (id: string) => (data: Discord.APIModalSubmission) =>
-    Option.flatMapNullable(
+    Option.flatMapNullishOr(
       getComponent(id)(data),
       o => (o as Discord.TextInputComponentResponse).value,
     )

package/src/Helpers/members.ts

@@ -1,12 +1,12 @@
-import type * as Discord from "dfx/types"
+import type * as Discord from "../types.ts"
 
 /**
  * From a list of roles, filter out the ones the guild member has.
  */
 export const roles =
-  (roles: Array<Discord.GuildRoleResponse>) =>
+  (guildRoles: Array<Discord.GuildRoleResponse>) =>
   (member: Discord.GuildMemberResponse) =>
-    roles.filter(
+    guildRoles.filter(
       role => member.roles.includes(role.id) || role.name === "@everyone",
     )
 

package/src/Helpers/permissions.ts

@@ -1,8 +1,8 @@
 import { pipe } from "effect/Function"
 import * as Effect from "effect/Effect"
-import * as Flags from "dfx/Helpers/flags"
-import * as Members from "dfx/Helpers/members"
-import * as Discord from "dfx/types"
+import * as Flags from "./flags.ts"
+import * as Members from "./members.ts"
+import * as Discord from "../types.ts"
 
 /**
  * A constant of all the permissions
@@ -108,8 +108,8 @@ export const applyOverwrites =
   (permissions: bigint) =>
   (overwrites: ReadonlyArray<Discord.ChannelPermissionOverwriteResponse>) =>
     overwrites.reduce(
-      (permissions, overwrite) =>
-        (permissions & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
+      (current, overwrite) =>
+        (current & ~BigInt(overwrite.deny)) | BigInt(overwrite.allow),
       permissions,
     )
 

package/src/Helpers/ui.ts

@@ -19,13 +19,13 @@ import type {
   TextInputComponentForModalRequest,
   ThumbnailComponentForMessageRequest,
   UserSelectComponentForMessageRequest,
-} from "dfx/types"
+} from "../types.ts"
 import {
   TextInputStyleTypes,
   ButtonStyleTypes,
   MessageComponentTypes,
   MessageFlags,
-} from "dfx/types"
+} from "../types.ts"
 
 type ActionRowComponents = ReadonlyArray<
   | ActionRowComponentForMessageRequest["components"][number]
@@ -69,61 +69,61 @@ export const singleColumn = <C extends ActionRowComponents>(
  * Helper to create a button component.
  */
 export const button = (
-  button: Partial<ButtonComponentForMessageRequest>,
+  options: Partial<ButtonComponentForMessageRequest>,
 ): ButtonComponentForMessageRequest => ({
   type: MessageComponentTypes.BUTTON,
   style: ButtonStyleTypes.PRIMARY,
-  ...button,
+  ...options,
 })
 
 /**
  * Helper to create a select component.
  */
 export const select = (
-  select: Omit<StringSelectComponentForMessageRequest, "type">,
+  options: Omit<StringSelectComponentForMessageRequest, "type">,
 ): StringSelectComponentForMessageRequest => ({
   type: MessageComponentTypes.STRING_SELECT,
-  ...select,
+  ...options,
 })
 
 /**
  * Helper to create a select component.
  */
 export const userSelect = (
-  select: Omit<UserSelectComponentForMessageRequest, "type">,
+  options: Omit<UserSelectComponentForMessageRequest, "type">,
 ): UserSelectComponentForMessageRequest => ({
   type: MessageComponentTypes.USER_SELECT,
-  ...select,
+  ...options,
 })
 
 /**
  * Helper to create a select component.
  */
 export const roleSelect = (
-  select: Omit<RoleSelectComponentForMessageRequest, "type">,
+  options: Omit<RoleSelectComponentForMessageRequest, "type">,
 ): RoleSelectComponentForMessageRequest => ({
   type: MessageComponentTypes.ROLE_SELECT,
-  ...select,
+  ...options,
 })
 
 /**
  * Helper to create a select component.
  */
 export const mentionableSelect = (
-  select: Omit<MentionableSelectComponentForMessageRequest, "type">,
+  options: Omit<MentionableSelectComponentForMessageRequest, "type">,
 ): MentionableSelectComponentForMessageRequest => ({
   type: MessageComponentTypes.MENTIONABLE_SELECT,
-  ...select,
+  ...options,
 })
 
 /**
  * Helper to create a select component.
  */
 export const channelSelect = (
-  select: Omit<ChannelSelectComponentForMessageRequest, "type">,
+  options: Omit<ChannelSelectComponentForMessageRequest, "type">,
 ): ChannelSelectComponentForMessageRequest => ({
   type: MessageComponentTypes.CHANNEL_SELECT,
-  ...select,
+  ...options,
 })
 
 type TextInputOpts = Omit<
@@ -238,7 +238,7 @@ type MessageComponents = NonNullable<MessageCreateRequest["components"]>[number]
  * Create a components v2 message
  */
 export const components = <const C extends ReadonlyArray<MessageComponents>>(
-  components: C,
+  items: C,
   options?: {
     readonly ephemeral?: boolean | undefined
   },
@@ -249,5 +249,5 @@ export const components = <const C extends ReadonlyArray<MessageComponents>>(
   flags: options?.ephemeral
     ? MessageFlags.Ephemeral | MessageFlags.IsComponentsV2
     : MessageFlags.IsComponentsV2,
-  components,
+  components: items,
 })

package/src/Interactions/builder.ts

@@ -3,10 +3,10 @@ import { identity } from "effect/Function"
 import type * as Cause from "effect/Cause"
 import * as Effect from "effect/Effect"
 import { catchTag } from "effect/Effect"
-import type { DiscordRESTError } from "dfx/DiscordREST"
-import { DiscordREST } from "dfx/DiscordREST"
-import type * as D from "dfx/Interactions/definitions"
-import type * as Discord from "dfx/types"
+import type { DiscordRESTError } from "../DiscordREST.ts"
+import { DiscordREST } from "../DiscordREST.ts"
+import type * as D from "./definitions.ts"
+import type * as Discord from "../types.ts"
 
 type ExtractTag<A> = A extends { _tag: infer Tag }
   ? Tag extends string
@@ -78,7 +78,7 @@ export class InteractionBuilder<R, E, TE> {
   catchAllCause<R1, E1>(
     f: (cause: Cause.Cause<TE>) => Effect.Effect<void, E1, R1>,
   ) {
-    return this.transformTransform<R | R1, E1>(Effect.catchAllCause(f))
+    return this.transformTransform<R | R1, E1>(Effect.catchCause(f))
   }
 
   catchAllCauseRespond<R1, E1>(
@@ -86,11 +86,11 @@ export class InteractionBuilder<R, E, TE> {
       cause: Cause.Cause<E>,
     ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
   ) {
-    return this.transformHandlers<R | R1, E1>(Effect.catchAllCause(f))
+    return this.transformHandlers<R | R1, E1>(Effect.catchCause(f))
   }
 
   catchAll<R1, E1>(f: (error: TE) => Effect.Effect<void, E1, R1>) {
-    return this.transformTransform<R | R1, E1>(Effect.catchAll(f))
+    return this.transformTransform<R | R1, E1>(Effect.catch(f))
   }
 
   catchAllRespond<R1, E1>(
@@ -98,7 +98,7 @@ export class InteractionBuilder<R, E, TE> {
       error: E,
     ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E1, R1>,
   ) {
-    return this.transformHandlers<R | R1, E1>(Effect.catchAll(f))
+    return this.transformHandlers<R | R1, E1>(Effect.catch(f))
   }
 
   catchTag<T extends ExtractTag<E>, R1, E1>(
@@ -131,7 +131,7 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(DiscordREST, rest =>
+    return DiscordREST.use(rest =>
       rest
         .getMyApplication()
         .pipe(
@@ -155,7 +155,7 @@ export class InteractionBuilder<R, E, TE> {
       Chunk.map(c => c.command),
     )
 
-    return Effect.flatMap(DiscordREST, rest =>
+    return DiscordREST.use(rest =>
       rest.bulkSetGuildApplicationCommands(
         appId,
         guildId,

package/src/Interactions/commandHelper.ts

@@ -1,13 +1,14 @@
 import * as Option from "effect/Option"
 import * as Effect from "effect/Effect"
 import {
+  type DiscordSubCommand,
   SubCommandContext,
   SubCommandNotFound,
   type DiscordApplicationCommand,
   type DiscordInteraction,
-} from "dfx/Interactions/context"
-import type * as Discord from "dfx/types"
-import * as Helpers from "dfx/Helpers/interactions"
+} from "./context.ts"
+import type * as Discord from "../types.ts"
+import * as Helpers from "../Helpers/interactions.ts"
 import * as Arr from "effect/Array"
 import type { HashMap } from "effect/HashMap"
 
@@ -82,37 +83,25 @@ export class CommandHelper<A> {
   >(
     commands: NER,
   ): Effect.Effect<
-    Discord.CreateInteractionResponseRequest,
-    [NER[keyof NER]] extends [
-      { [Effect.EffectTypeId]: { _E: (_: never) => infer E } },
-    ]
-      ? E
-      : never,
-    | Exclude<
-        [NER[keyof NER]] extends [
-          { [Effect.EffectTypeId]: { _R: (_: never) => infer R } },
-        ]
-          ? R
-          : never,
-        SubCommandContext
-      >
+    Effect.Success<NER[keyof NER]>,
+    Effect.Error<NER[keyof NER]>,
+    | Exclude<Effect.Services<NER[keyof NER]>, DiscordSubCommand>
     | DiscordInteraction
     | DiscordApplicationCommand
   > {
     const commands_ = commands as Record<string, any>
-    return Effect.mapError(
-      Arr.findFirst(
-        Helpers.allSubCommands(this.data),
-        _ => !!commands_[_.name],
-      ),
-      () => new SubCommandNotFound({ data: this.data }),
-    ).pipe(
-      Effect.flatMap(command =>
-        Effect.provideService(commands_[command.name], SubCommandContext, {
-          command,
+    const matchedCommand = Arr.findFirst(
+      Helpers.allSubCommands(this.data),
+      _ => !!commands_[_.name],
+    )
+
+    return Option.match(matchedCommand, {
+      onNone: () => Effect.fail(new SubCommandNotFound({ data: this.data })),
+      onSome: subCommand =>
+        Effect.provideService(commands_[subCommand.name], SubCommandContext, {
+          command: subCommand,
         }),
-      ),
-    ) as any
+    }) as any
   }
 
   get optionsMap(): HashMap<string, string | undefined> {