dfx 0.50.0 → 0.51.0

package/src/DiscordREST.ts

@@ -24,12 +24,12 @@ export class DiscordRESTError {
 export { ResponseDecodeError } from "@effect-http/client"
 
 const make = Do($ => {
-  const { token, rest } = $(DiscordConfig)
+  const { token, rest } = $(DiscordConfig.accessWith(identity))
 
-  const http = $(Http.HttpRequestExecutor)
-  const log = $(Log)
-  const store = $(RateLimitStore)
-  const { maybeWait } = $(RateLimiter)
+  const http = $(Http.HttpRequestExecutor.accessWith(identity))
+  const log = $(Log.accessWith(identity))
+  const store = $(RateLimitStore.accessWith(identity))
+  const { maybeWait } = $(RateLimiter.accessWith(identity))
 
   const globalRateLimit = maybeWait(
     "dfx.rest.global",
@@ -40,15 +40,18 @@ const make = Do($ => {
   // Invalid route handling (40x)
   const badRoutesRef = $(Ref.make(HashSet.empty<string>()))
   const addBadRoute = (route: string) =>
-    Effect.allParDiscard([
-      log.info("DiscordREST", "addBadRoute", route),
-      badRoutesRef.update(s => s.add(route)),
-      store.incrementCounter(
-        "dfx.rest.invalid",
-        Duration.minutes(10).millis,
-        10000,
-      ),
-    ])
+    Effect.all(
+      [
+        log.info("DiscordREST", "addBadRoute", route),
+        badRoutesRef.update(s => s.add(route)),
+        store.incrementCounter(
+          "dfx.rest.invalid",
+          Duration.minutes(10).toMillis,
+          10000,
+        ),
+      ],
+      { discard: true, concurrency: "unbounded" },
+    )
   const isBadRoute = (route: string) => badRoutesRef.get.map(s => s.has(route))
   const removeBadRoute = (route: string) =>
     badRoutesRef.update(s => s.remove(route))
@@ -57,7 +60,7 @@ const make = Do($ => {
     isBadRoute(route).tap(invalid =>
       invalid
         ? maybeWait("dfx.rest.invalid", Duration.minutes(10), 10000)
-        : Effect.unit(),
+        : Effect.unit,
     ).asUnit
 
   // Request rate limiting
@@ -66,16 +69,16 @@ const make = Do($ => {
       const route = routeFromConfig(path, request.method)
       const maybeBucket = $(store.getBucketForRoute(route))
 
-      const effect = maybeBucket.match(
-        () => invalidRateLimit(route),
-        bucket =>
+      const effect = maybeBucket.match({
+        onNone: () => invalidRateLimit(route),
+        onSome: bucket =>
           Do($ => {
             $(invalidRateLimit(route))
             const resetAfter = millis(bucket.resetAfter)
 
             $(maybeWait(`dfx.rest.${bucket.key}`, resetAfter, bucket.limit))
           }),
-      )
+      })
 
       $(effect)
     })
@@ -99,13 +102,13 @@ const make = Do($ => {
           store.removeCounter(`dfx.rest.?.${route}`),
           store.putBucket({
             key: bucket,
-            resetAfter: retryAfter.millis,
+            resetAfter: retryAfter.toMillis,
             limit: !hasBucket && remaining > 0 ? remaining : limit,
           }),
         )
       }
 
-      $(Effect.allParDiscard(effectsToRun))
+      $(Effect.all(effectsToRun, { concurrency: "unbounded", discard: true }))
     }).ignore
 
   const httpExecutor = http.execute.filterStatusOk
@@ -146,11 +149,14 @@ const make = Do($ => {
         case 403:
           return Do($ => {
             $(
-              Effect.allParDiscard([
-                log.info("DiscordREST", "403", request.url),
-                addBadRoute(routeFromConfig(request.url, request.method)),
-                updateBuckets(request, response),
-              ]),
+              Effect.all(
+                [
+                  log.info("DiscordREST", "403", request.url),
+                  addBadRoute(routeFromConfig(request.url, request.method)),
+                  updateBuckets(request, response),
+                ],
+                { concurrency: "unbounded", discard: true },
+              ),
             )
             return $(Effect.fail(e))
           })
@@ -158,16 +164,19 @@ const make = Do($ => {
         case 429:
           return Do($ => {
             $(
-              Effect.allParDiscard([
-                log.info("DiscordREST", "429", request.url),
-                addBadRoute(routeFromConfig(request.url, request.method)),
-                updateBuckets(request, response),
-                Effect.sleep(
-                  retryAfter(response.headers).getOrElse(() =>
-                    Duration.seconds(5),
+              Effect.all(
+                [
+                  log.info("DiscordREST", "429", request.url),
+                  addBadRoute(routeFromConfig(request.url, request.method)),
+                  updateBuckets(request, response),
+                  Effect.sleep(
+                    retryAfter(response.headers).getOrElse(() =>
+                      Duration.seconds(5),
+                    ),
                   ),
-                ),
-              ]),
+                ],
+                { concurrency: "unbounded", discard: true },
+              ),
             )
             return $(executor<A>(request))
           })

package/src/Helpers/interactions.ts

@@ -1,4 +1,4 @@
-import { Option as Maybe, Product } from "@effect/data/Option"
+import { Option as Maybe } from "@effect/data/Option"
 import * as Arr from "@effect/data/ReadonlyArray"
 
 /**
@@ -29,14 +29,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) =>
+    findSubCommand(name)(_).isSome()
 
 /**
  * Maybe 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) =>
+    findSubCommand(name)(_).flatMapNullable(o => o.options)
 
 /**
  * A lens for accessing nested options in a interaction.
@@ -49,7 +51,7 @@ export const optionsWithNested = (
   ): Discord.ApplicationCommandInteractionDataOption[] =>
     Maybe.fromNullable(opt.options)
       .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
-      .match(() => [], identity)
+      .match({ onNone: () => [], onSome: identity })
 
   return Maybe.fromNullable(data.options)
     .map(opts => [...opts, ...opts.flatMap(optsFromOption)])
@@ -70,30 +72,30 @@ export const transformOptions = (
 /**
  * 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">) =>
+    getOption(name)(data).flatMapNullable(o => o.value)
 
 /**
  * Try extract resolved data
@@ -140,9 +142,7 @@ export const resolveValues =
         ).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)))),
-      )
+      return Arr.compact(values.map(a => Maybe.fromNullable(f(a as any, r))))
     })
 
 const extractComponents = (c: Discord.Component): Discord.Component[] => {
@@ -166,10 +166,8 @@ 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.
@@ -183,24 +181,24 @@ export const transformComponents = (options: Discord.Component[]) =>
 /**
  * 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) =>
+    getComponent(id)(data).flatMapNullable(o => (o as Discord.TextInput).value)
 
 export type InteractionResponse =
   | {

package/src/Interactions/builder.ts

@@ -34,7 +34,7 @@ export class InteractionBuilder<R, E, TE> {
 
   concat<R1, E1, TE1>(builder: InteractionBuilder<R1, E1, TE1>) {
     return new InteractionBuilder<R | R1, E | E1, TE | TE1>(
-      this.definitions.concat(builder.definitions),
+      this.definitions.appendAll(builder.definitions),
       this.transform,
     )
   }
@@ -120,7 +120,7 @@ export class InteractionBuilder<R, E, TE> {
       )
       .map(c => c.command)
 
-    return DiscordREST.flatMap(rest =>
+    return DiscordREST.accessWithEffect(rest =>
       rest
         .getCurrentBotApplicationInformation()
         .flatMap(r => r.json)
@@ -141,7 +141,7 @@ export class InteractionBuilder<R, E, TE> {
       )
       .map(c => c.command)
 
-    return DiscordREST.flatMap(rest =>
+    return DiscordREST.accessWithEffect(rest =>
       rest.bulkOverwriteGuildApplicationCommands(
         appId,
         guildId,

package/src/Interactions/context.ts

@@ -26,7 +26,7 @@ export class ResolvedDataNotFound {
 export const resolvedValues = <A>(
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
 ) =>
-  Interaction.flatMap(ix =>
+  Interaction.accessWithEffect(ix =>
     IxHelpers.resolveValues(f)(ix).mapError(() => new ResolvedDataNotFound(ix)),
   )
 
@@ -34,14 +34,14 @@ export const resolved = <A>(
   name: string,
   f: (id: Discord.Snowflake, data: Discord.ResolvedDatum) => A | undefined,
 ) =>
-  Interaction.flatMap(ix =>
+  Interaction.accessWithEffect(ix =>
     IxHelpers.resolveOptionValue(
       name,
       f,
     )(ix).mapError(() => new ResolvedDataNotFound(ix, name)),
   )
 
-export const focusedOptionValue = FocusedOptionContext.map(
+export const focusedOptionValue = FocusedOptionContext.accessWith(
   _ => _.focusedOption.value ?? "",
 )
 
@@ -73,7 +73,7 @@ export const handleSubCommands = <
   | SubCommandNotFound,
   Discord.InteractionResponse
 > =>
-  ApplicationCommand.flatMap(data =>
+  ApplicationCommand.accessWithEffect(data =>
     Arr.findFirst(IxHelpers.allSubCommands(data), _ => !!commands[_.name])
       .mapError(() => new SubCommandNotFound(data))
       .flatMap(command =>
@@ -83,9 +83,9 @@ export const handleSubCommands = <
       ),
   )
 
-export const currentSubCommand = SubCommandContext.map(_ => _.command)
+export const currentSubCommand = SubCommandContext.accessWith(_ => _.command)
 
-export const optionsMap = ApplicationCommand.map(IxHelpers.optionsMap)
+export const optionsMap = ApplicationCommand.accessWith(IxHelpers.optionsMap)
 
 export class RequiredOptionNotFound {
   readonly _tag = "RequiredOptionNotFound"
@@ -98,26 +98,26 @@ export class RequiredOptionNotFound {
 }
 
 export const option = (name: string) =>
-  ApplicationCommand.map(IxHelpers.getOption(name))
+  ApplicationCommand.accessWith(IxHelpers.getOption(name))
 
 export const optionValue = (name: string) =>
   option(name).flatMap(_ =>
-    _.flatMapNullable(a => a.value).match(
-      () =>
-        ApplicationCommand.flatMap(data =>
+    _.flatMapNullable(a => a.value).match({
+      onNone: () =>
+        ApplicationCommand.accessWithEffect(data =>
           Effect.fail(new RequiredOptionNotFound(data, name)),
         ),
-      Effect.succeed,
-    ),
+      onSome: Effect.succeed,
+    }),
   )
 
 export const optionValueOptional = (name: string) =>
   option(name).map(o => o.flatMapNullable(o => o.value))
 
-export const modalValues = ModalSubmitData.map(IxHelpers.componentsMap)
+export const modalValues = ModalSubmitData.accessWith(IxHelpers.componentsMap)
 
 export const modalValueOption = (name: string) =>
-  ModalSubmitData.map(IxHelpers.componentValue(name))
+  ModalSubmitData.accessWith(IxHelpers.componentValue(name))
 
 export class ModalValueNotFound {
   readonly _tag = "ModalValueNotFound"
@@ -125,7 +125,7 @@ export class ModalValueNotFound {
 }
 
 export const modalValue = (name: string) =>
-  ModalSubmitData.flatMap(data =>
+  ModalSubmitData.accessWithEffect(data =>
     IxHelpers.componentValue(name)(data).mapError(
       () => new ModalValueNotFound(data, name),
     ),

package/src/Interactions/gateway.ts

@@ -47,8 +47,8 @@ export const run =
             _._tag === "GuildApplicationCommand",
         ).toReadonlyArray
 
-      const gateway = $(DiscordGateway)
-      const rest = $(DiscordREST)
+      const gateway = $(DiscordGateway.accessWith(identity))
+      const rest = $(DiscordREST.accessWith(identity))
 
       const application = $(
         rest.getCurrentBotApplicationInformation().flatMap(a => a.json),
@@ -69,7 +69,7 @@ export const run =
               GuildApplicationCommand.map(_ => _.command) as any,
             ),
           )
-        : Effect.never()
+        : Effect.never
 
       const handle = handlers(ix.definitions, (i, r) =>
         rest.createInteractionResponse(i.id, i.token, r),
@@ -79,7 +79,14 @@ export const run =
         postHandler(handle[i.type](i)).provideService(Interaction, i),
       )
 
-      return $(sync ? run.zipParRight(globalSync).zipParRight(guildSync) : run)
+      return $(
+        sync
+          ? Effect.all(run, globalSync, guildSync, {
+              concurrency: "unbounded",
+              discard: true,
+            }).forever
+          : run,
+      )
     })
 
 const makeRegistry = Do($ => {
@@ -124,5 +131,7 @@ export interface InteractionsRegistry {
 }
 
 export const InteractionsRegistry = Tag<InteractionsRegistry>()
-export const InteractionsRegistryLive =
-  makeRegistry.toLayer(InteractionsRegistry)
+export const InteractionsRegistryLive = Layer.effect(
+  InteractionsRegistry,
+  makeRegistry,
+)

package/src/Interactions/handlers.ts

@@ -43,67 +43,70 @@ export const handlers = <R, E, TE, A, B>(
     [Discord.InteractionType.APPLICATION_COMMAND]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return Maybe.fromNullable(Commands[data.name]).match(
-        () => Effect.fail(new DefinitionNotFound(i)),
-        command =>
+      return Maybe.fromNullable(Commands[data.name]).match({
+        onNone: () => Effect.fail(new DefinitionNotFound(i)),
+        onSome: command =>
           command
             .handle(i)
             .provideService(Ctx.ApplicationCommand, data) as Handler<R, E, B>,
-      )
+      })
     },
 
     [Discord.InteractionType.MODAL_SUBMIT]: i => {
       const data = i.data as Discord.ModalSubmitDatum
 
-      return ModalSubmit.find(_ => _.predicate(data.custom_id)).flatMap(_ =>
-        _.match(
-          () => Effect.fail(new DefinitionNotFound(i)),
-          match =>
-            match
-              .handle(i)
-              .provideService(Ctx.ModalSubmitData, data) as Handler<R, E, B>,
-        ),
+      return ModalSubmit.findFirst(_ => _.predicate(data.custom_id)).flatMap(
+        _ =>
+          _.match({
+            onNone: () => Effect.fail(new DefinitionNotFound(i)),
+            onSome: match =>
+              match
+                .handle(i)
+                .provideService(Ctx.ModalSubmitData, data) as Handler<R, E, B>,
+          }),
       )
     },
 
     [Discord.InteractionType.MESSAGE_COMPONENT]: i => {
       const data = i.data as Discord.MessageComponentDatum
 
-      return MessageComponent.find(_ => _.predicate(data.custom_id)).flatMap(
-        _ =>
-          _.match(
-            () => Effect.fail(new DefinitionNotFound(i)),
-            match =>
-              match
-                .handle(i)
-                .provideService(Ctx.MessageComponentData, data) as Handler<
-                R,
-                E,
-                B
-              >,
-          ),
+      return MessageComponent.findFirst(_ =>
+        _.predicate(data.custom_id),
+      ).flatMap(_ =>
+        _.match({
+          onNone: () => Effect.fail(new DefinitionNotFound(i)),
+          onSome: match =>
+            match
+              .handle(i)
+              .provideService(Ctx.MessageComponentData, data) as Handler<
+              R,
+              E,
+              B
+            >,
+        }),
       )
     },
 
     [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
       const data = i.data as Discord.ApplicationCommandDatum
 
-      return IxHelpers.focusedOption(data).match(
-        () => Effect.fail(new DefinitionNotFound(i)),
-        focusedOption =>
-          Autocomplete.find(_ => _.predicate(data, focusedOption)).flatMap(_ =>
-            _.match(
-              () => Effect.fail(new DefinitionNotFound(i)),
-              match =>
-                match
-                  .handle(i)
-                  .provideService(Ctx.ApplicationCommand, data)
-                  .provideService(Ctx.FocusedOptionContext, {
-                    focusedOption,
-                  }) as Handler<R, E, B>,
-            ),
+      return IxHelpers.focusedOption(data).match({
+        onNone: () => Effect.fail(new DefinitionNotFound(i)),
+        onSome: focusedOption =>
+          Autocomplete.findFirst(_ => _.predicate(data, focusedOption)).flatMap(
+            _ =>
+              _.match({
+                onNone: () => Effect.fail(new DefinitionNotFound(i)),
+                onSome: match =>
+                  match
+                    .handle(i)
+                    .provideService(Ctx.ApplicationCommand, data)
+                    .provideService(Ctx.FocusedOptionContext, {
+                      focusedOption,
+                    }) as Handler<R, E, B>,
+              }),
           ),
-      )
+      })
     },
   }
 }

package/src/Interactions/utils.ts

@@ -68,7 +68,7 @@ export const splitDefinitions = <R, E, TE, A>(
     }),
   )
 
-  const Commands = grouped.GlobalApplicationCommand.concat(
+  const Commands = grouped.GlobalApplicationCommand.appendAll(
     grouped.GuildApplicationCommand,
   ).reduce(
     {} as Record<string, DefinitionFlattenedCommand<R, E, TE, A>>,

package/src/Interactions/webhook.ts

@@ -2,6 +2,8 @@ import * as Verify from "discord-verify"
 import * as D from "./definitions.js"
 import { DefinitionNotFound, handlers } from "./handlers.js"
 import { InteractionBuilder, Interaction } from "./index.js"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
 
 export class BadWebhookSignature {
   readonly _tag = "BadWebhookSignature"
@@ -16,7 +18,7 @@ const checkSignature = (
   crypto: SubtleCrypto,
   algorithm: any,
 ) =>
-  Maybe.struct({
+  Option.all({
     signature: Maybe.fromNullable(headers["x-signature-ed25519"]),
     timestamp: Maybe.fromNullable(headers["x-signature-timestamp"]),
   })
@@ -54,11 +56,10 @@ const makeConfig = ({
 })
 export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
 export const WebhookConfig = Tag<WebhookConfig>()
-export const makeConfigLayer = flow(makeConfig, _ =>
-  Layer.succeed(WebhookConfig, _),
-)
+export const makeConfigLayer = (opts: MakeConfigOpts) =>
+  Layer.succeed(WebhookConfig, makeConfig(opts))
 export const makeFromConfig = (a: Config<MakeConfigOpts>) =>
-  a.config.map(makeConfig).toLayer(WebhookConfig)
+  Layer.effect(WebhookConfig, a.config.map(makeConfig))
 
 export class WebhookParseError {
   readonly _tag = "WebhookParseError"
@@ -67,13 +68,15 @@ export class WebhookParseError {
 
 const fromHeadersAndBody = (headers: Headers, body: string) =>
   Do($ => {
-    const { publicKey, crypto, algorithm } = $(WebhookConfig)
+    const { publicKey, crypto, algorithm } = $(
+      WebhookConfig.accessWith(identity),
+    )
     $(checkSignature(publicKey, headers, body, crypto, algorithm))
     return $(
-      Effect.tryCatch(
-        () => JSON.parse(body) as Discord.Interaction,
-        reason => new WebhookParseError(reason),
-      ),
+      Effect.try({
+        try: () => JSON.parse(body) as Discord.Interaction,
+        catch: reason => new WebhookParseError(reason),
+      }),
     )
   })
 
@@ -82,14 +85,14 @@ const run = <R, E>(
     readonly [
       handler: D.InteractionDefinition<R, E>,
       transform: (
-        self: Effect<R, E, Discord.InteractionResponse>,
-      ) => Effect<R, E, Discord.InteractionResponse>,
+        self: Effect.Effect<R, E, Discord.InteractionResponse>,
+      ) => Effect.Effect<R, E, Discord.InteractionResponse>,
     ]
   >,
   handleResponse: (
     ix: Discord.Interaction,
     _: Discord.InteractionResponse,
-  ) => Effect<R, E, Discord.InteractionResponse>,
+  ) => Effect.Effect<R, E, Discord.InteractionResponse>,
 ) => {
   const handler = handlers(definitions, handleResponse)
   return (headers: Headers, body: string) =>
@@ -107,8 +110,8 @@ const run = <R, E>(
 export interface HandleWebhookOpts<E> {
   headers: Headers
   body: string
-  success: (a: Discord.InteractionResponse) => Effect<never, never, void>
-  error: (e: Cause<E>) => Effect<never, never, void>
+  success: (a: Discord.InteractionResponse) => Effect.Effect<never, never, void>
+  error: (e: Cause<E>) => Effect.Effect<never, never, void>
 }
 
 /**

package/src/Log.ts

@@ -8,7 +8,7 @@ const make = (debug = false) => ({
       ? Effect.sync(() => {
           console.error("DEBUG", ...args)
         })
-      : Effect.unit(),
+      : Effect.unit,
 })
 
 export interface Log extends ReturnType<typeof make> {}