dfx 0.50.1 → 0.51.1

package/src/Interactions/webhook.ts

@@ -1,7 +1,18 @@
+import * as Chunk from "@effect/data/Chunk"
+import { Tag } from "@effect/data/Context"
+import { identity } from "@effect/data/Function"
+import * as Option from "@effect/data/Option"
+import * as Cause from "@effect/io/Cause"
+import * as Config from "@effect/io/Config"
+import * as ConfigError from "@effect/io/Config/Error"
+import * as ConfigSecret from "@effect/io/Config/Secret"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import * as D from "dfx/Interactions/definitions"
+import { DefinitionNotFound, handlers } from "dfx/Interactions/handlers"
+import { Interaction, InteractionBuilder } from "dfx/Interactions/index"
+import * as Discord from "dfx/types"
 import * as Verify from "discord-verify"
-import * as D from "./definitions.js"
-import { DefinitionNotFound, handlers } from "./handlers.js"
-import { InteractionBuilder, Interaction } from "./index.js"
 
 export class BadWebhookSignature {
   readonly _tag = "BadWebhookSignature"
@@ -16,11 +27,11 @@ const checkSignature = (
   crypto: SubtleCrypto,
   algorithm: any,
 ) =>
-  Maybe.struct({
-    signature: Maybe.fromNullable(headers["x-signature-ed25519"]),
-    timestamp: Maybe.fromNullable(headers["x-signature-timestamp"]),
-  })
-    .flatMap(_ =>
+  Option.all({
+    signature: Option.fromNullable(headers["x-signature-ed25519"]),
+    timestamp: Option.fromNullable(headers["x-signature-timestamp"]),
+  }).pipe(
+    Effect.flatMap(_ =>
       Effect.promise(() =>
         Verify.verify(
           body,
@@ -31,15 +42,17 @@ const checkSignature = (
           algorithm,
         ),
       ),
-    )
-    .filterOrFail(identity, () => new BadWebhookSignature())
-    .catchAllCause(() => Effect.fail(new BadWebhookSignature())).asUnit
+    ),
+    Effect.filterOrFail(identity, () => new BadWebhookSignature()),
+    Effect.catchAllCause(() => Effect.fail(new BadWebhookSignature())),
+    Effect.asUnit,
+  )
 
 export interface MakeConfigOpts {
-  applicationId: string
-  publicKey: ConfigSecret
-  crypto: SubtleCrypto
-  algorithm: keyof typeof Verify.PlatformAlgorithm
+  readonly applicationId: string
+  readonly publicKey: ConfigSecret.ConfigSecret
+  readonly crypto: SubtleCrypto
+  readonly algorithm: keyof typeof Verify.PlatformAlgorithm
 }
 const makeConfig = ({
   applicationId,
@@ -48,17 +61,22 @@ const makeConfig = ({
   algorithm,
 }: MakeConfigOpts) => ({
   applicationId,
-  publicKey: publicKey.value,
+  publicKey: ConfigSecret.value(publicKey),
   crypto,
   algorithm: Verify.PlatformAlgorithm[algorithm],
 })
+
 export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
 export const WebhookConfig = Tag<WebhookConfig>()
-export const makeConfigLayer = flow(makeConfig, _ =>
-  Layer.succeed(WebhookConfig, _),
-)
-export const makeFromConfig = (a: Config<MakeConfigOpts>) =>
-  a.config.map(makeConfig).toLayer(WebhookConfig)
+
+export const makeConfigLayer = (opts: MakeConfigOpts) =>
+  Layer.succeed(WebhookConfig, makeConfig(opts))
+
+export const makeFromConfig: (
+  a: Config.Config<MakeConfigOpts>,
+) => Layer.Layer<never, ConfigError.ConfigError, WebhookConfig> = (
+  a: Config.Config<MakeConfigOpts>,
+) => Layer.effect(WebhookConfig, Effect.map(Effect.config(a), makeConfig))
 
 export class WebhookParseError {
   readonly _tag = "WebhookParseError"
@@ -66,57 +84,64 @@ export class WebhookParseError {
 }
 
 const fromHeadersAndBody = (headers: Headers, body: string) =>
-  Do($ => {
-    const { publicKey, crypto, algorithm } = $(WebhookConfig)
-    $(checkSignature(publicKey, headers, body, crypto, algorithm))
-    return $(
-      Effect.tryCatch(
-        () => JSON.parse(body) as Discord.Interaction,
-        reason => new WebhookParseError(reason),
-      ),
-    )
-  })
+  Effect.tap(WebhookConfig, ({ publicKey, crypto, algorithm }) =>
+    checkSignature(publicKey, headers, body, crypto, algorithm),
+  ).pipe(
+    Effect.flatMap(() =>
+      Effect.try({
+        try: () => JSON.parse(body) as Discord.Interaction,
+        catch: reason => new WebhookParseError(reason),
+      }),
+    ),
+  )
 
 const run = <R, E>(
-  definitions: Chunk<
+  definitions: Chunk.Chunk<
     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) =>
-    Do($ => {
-      const interaction = $(fromHeadersAndBody(headers, body))
-      return $(
-        handler[interaction.type](interaction).provideService(
-          Interaction,
-          interaction,
-        ),
-      )
-    })
+    Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
+      Effect.provideService(
+        handler[interaction.type](interaction),
+        Interaction,
+        interaction,
+      ),
+    )
 }
 
 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.Cause<E>) => Effect.Effect<never, never, void>
 }
 
 /**
  * @tsplus getter dfx/InteractionBuilder webhookHandler
  */
-export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
+export const makeHandler = <R, E, TE>(
+  ix: InteractionBuilder<R, E, TE>,
+): (({
+  headers,
+  body,
+  success,
+  error,
+}: HandleWebhookOpts<
+  E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
+>) => Effect.Effect<WebhookConfig, never, void>) => {
   const handle = run(
-    ix.definitions.map(([d]) => [d, identity] as any),
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
   )
 
@@ -127,7 +152,11 @@ export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
     error,
   }: HandleWebhookOpts<
     E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
-  >) => handle(headers, body).flatMap(success).catchAllCause(error)
+  >): Effect.Effect<WebhookConfig, never, void> =>
+    handle(headers, body).pipe(
+      Effect.flatMap(success),
+      Effect.catchAllCause(error),
+    )
 }
 
 /**
@@ -135,9 +164,19 @@ export const makeHandler = <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => {
  */
 export const makeSimpleHandler = <R, E, TE>(
   ix: InteractionBuilder<R, E, TE>,
-) => {
+): (({
+  headers,
+  body,
+}: {
+  headers: Headers
+  body: string
+}) => Effect.Effect<
+  WebhookConfig,
+  BadWebhookSignature | WebhookParseError | DefinitionNotFound,
+  Discord.InteractionResponse
+>) => {
   const handle = run(
-    ix.definitions.map(([d]) => [d, identity] as any),
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
     (_i, r) => Effect.succeed(r),
   )
 

package/src/Log.ts

@@ -1,3 +1,7 @@
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import { Tag } from "@effect/data/Context"
+
 const make = (debug = false) => ({
   info: (...args: any[]) =>
     Effect.sync(() => {
@@ -8,7 +12,7 @@ const make = (debug = false) => ({
       ? Effect.sync(() => {
           console.error("DEBUG", ...args)
         })
-      : Effect.unit(),
+      : Effect.unit,
 })
 
 export interface Log extends ReturnType<typeof make> {}

package/src/RateLimit/memory.ts

@@ -1,4 +1,6 @@
-import { BucketDetails, RateLimitStore } from "../RateLimit.js"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import { BucketDetails, RateLimitStore } from "dfx/RateLimit"
 
 interface Counter {
   count: number
@@ -11,10 +13,13 @@ export const make = (): RateLimitStore => {
   const counters = new Map<string, Counter>()
 
   const getCounter = (key: string) =>
-    Maybe.fromNullable(counters.get(key)).filter(c => c.expires > Date.now())
+    Option.filter(
+      Option.fromNullable(counters.get(key)),
+      c => c.expires > Date.now(),
+    )
 
   const getBucketForRoute = (route: string) =>
-    Effect.sync(() => Maybe.fromNullable(buckets.get(routes.get(route)!)))
+    Effect.sync(() => Option.fromNullable(buckets.get(routes.get(route)!)))
 
   return {
     hasBucket: key => Effect.sync(() => buckets.has(key)),
@@ -40,7 +45,8 @@ export const make = (): RateLimitStore => {
       Effect.sync(() => {
         const now = Date.now()
         const perRequest = Math.ceil(window / limit)
-        const counter = getCounter(key).getOrElse(
+        const counter = Option.getOrElse(
+          getCounter(key),
           (): Counter => ({
             expires: now,
             count: 0,

package/src/RateLimit/utils.ts

@@ -1,4 +1,4 @@
-import { millis, zero } from "@effect/data/Duration"
+import { Duration, millis, zero } from "@effect/data/Duration"
 
 export const delayFrom = (
   window: number,

package/src/RateLimit.ts

@@ -1,6 +1,11 @@
-import { delayFrom } from "./RateLimit/utils.js"
-import * as Memory from "./RateLimit/memory.js"
+import { Tag } from "@effect/data/Context"
+import * as Duration from "@effect/data/Duration"
+import * as Option from "@effect/data/Option"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
 import { Log } from "dfx/Log"
+import * as Memory from "dfx/RateLimit/memory"
+import { delayFrom } from "dfx/RateLimit/utils"
 
 export type BucketDetails = {
   key: "global" | string
@@ -9,61 +14,69 @@ export type BucketDetails = {
 }
 
 export interface RateLimitStore {
-  hasBucket: (bucketKey: string) => Effect<never, never, boolean>
+  readonly hasBucket: (
+    bucketKey: string,
+  ) => Effect.Effect<never, never, boolean>
 
-  putBucket: (bucket: BucketDetails) => Effect<never, never, void>
+  readonly putBucket: (
+    bucket: BucketDetails,
+  ) => Effect.Effect<never, never, void>
 
-  getBucketForRoute: (
+  readonly getBucketForRoute: (
     route: string,
-  ) => Effect<never, never, Maybe<BucketDetails>>
+  ) => Effect.Effect<never, never, Option.Option<BucketDetails>>
 
-  putBucketRoute: (
+  readonly putBucketRoute: (
     route: string,
     bucketKey: string,
-  ) => Effect<never, never, void>
+  ) => Effect.Effect<never, never, void>
 
-  incrementCounter: (
+  readonly incrementCounter: (
     key: string,
     window: number,
     limit: number,
-  ) => Effect<never, never, readonly [count: number, ttl: number]>
+  ) => Effect.Effect<never, never, readonly [count: number, ttl: number]>
 
-  removeCounter: (key: string) => Effect<never, never, void>
+  readonly removeCounter: (key: string) => Effect.Effect<never, never, void>
 }
 
 export const RateLimitStore = Tag<RateLimitStore>()
 export const LiveMemoryRateLimitStore = Layer.sync(RateLimitStore, Memory.make)
 
-const makeLimiter = Do($ => {
-  const store = $(RateLimitStore)
-  const log = $(Log)
+const makeLimiter = Effect.gen(function* (_) {
+  const store = yield* _(RateLimitStore)
+  const log = yield* _(Log)
 
   const maybeWait = (
     key: string,
-    window: Duration,
+    window: Duration.Duration,
     limit: number,
     multiplier = 1.05,
   ) => {
-    const windowMs = window.millis * multiplier
+    const windowMs = Duration.toMillis(window) * multiplier
 
-    return store
-      .incrementCounter(key, windowMs, limit)
-      .map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl))
-      .tap(d =>
+    return store.incrementCounter(key, windowMs, limit).pipe(
+      Effect.map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl)),
+      Effect.tap(d =>
         log.debug("RateLimitStore maybeWait", {
           key,
-          window: window.millis,
+          window: Duration.toMillis(window),
           windowMs,
           limit,
-          delay: d.millis,
+          delay: Duration.toMillis(d),
         }),
-      )
-      .tap(_ => (_.millis === 0 ? Effect.unit() : Effect.sleep(_))).asUnit
+      ),
+      Effect.tap(_ =>
+        Duration.toMillis(_) === 0 ? Effect.unit : Effect.sleep(_),
+      ),
+      Effect.asUnit,
+    )
   }
 
   return { maybeWait }
 })
 
-export interface RateLimiter extends Effect.Success<typeof makeLimiter> {}
+export interface RateLimiter
+  extends Effect.Effect.Success<typeof makeLimiter> {}
 export const RateLimiter = Tag<RateLimiter>()
 export const LiveRateLimiter = Layer.effect(RateLimiter, makeLimiter)

package/src/gateway.ts

@@ -1,41 +1,78 @@
+import type { HttpRequestExecutor } from "@effect-http/client"
 import { LiveFetchRequestExecutor } from "@effect-http/client"
+import * as Config from "@effect/io/Config"
+import type * as ConfigError from "@effect/io/Config/Error"
+import * as Effect from "@effect/io/Effect"
+import * as Layer from "@effect/io/Layer"
+import type { DiscordREST } from "dfx"
 import { DiscordConfig, LiveDiscordREST, Log } from "dfx"
-import { LiveDiscordGateway } from "./DiscordGateway.js"
-import { LiveJsonDiscordWSCodec } from "./DiscordGateway/DiscordWS.js"
-import { LiveMemoryShardStore } from "./DiscordGateway/ShardStore.js"
-import { LiveMemoryRateLimitStore, LiveRateLimiter } from "./RateLimit.js"
+import * as CachePrelude from "dfx/Cache/prelude"
+import type { DiscordGateway } from "dfx/DiscordGateway"
+import { LiveDiscordGateway } from "dfx/DiscordGateway"
+import * as DiscordWS from "dfx/DiscordGateway/DiscordWS"
+import { LiveJsonDiscordWSCodec } from "dfx/DiscordGateway/DiscordWS"
+import * as Shard from "dfx/DiscordGateway/Shard"
+import * as SendEvent from "dfx/DiscordGateway/Shard/sendEvents"
+import * as ShardStore from "dfx/DiscordGateway/ShardStore"
+import { LiveMemoryShardStore } from "dfx/DiscordGateway/ShardStore"
+import * as WS from "dfx/DiscordGateway/WS"
+import type { RateLimiter } from "dfx/RateLimit"
+import { LiveMemoryRateLimitStore, LiveRateLimiter } from "dfx/RateLimit"
 
-export * as CachePrelude from "./Cache/prelude.js"
-export { DiscordGateway, LiveDiscordGateway } from "./DiscordGateway.js"
-export * as DiscordWS from "./DiscordGateway/DiscordWS.js"
-export * as Shard from "./DiscordGateway/Shard.js"
-export * as ShardStore from "./DiscordGateway/ShardStore.js"
-export * as SendEvent from "./DiscordGateway/Shard/sendEvents.js"
-export * as WS from "./DiscordGateway/WS.js"
+export { DiscordGateway, LiveDiscordGateway } from "dfx/DiscordGateway"
 export {
   InteractionsRegistry,
   InteractionsRegistryLive,
   run as runIx,
-} from "./Interactions/gateway.js"
+} from "dfx/Interactions/gateway"
+export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore, WS }
 
-export const MemoryRateLimit = LiveMemoryRateLimitStore >> LiveRateLimiter
-
-export const MemoryBot =
-  (LiveMemoryShardStore + LiveMemoryRateLimitStore + LiveJsonDiscordWSCodec) >>
-  ((LiveDiscordREST > LiveDiscordGateway) + MemoryRateLimit)
+export const MemoryRateLimit = Layer.provide(
+  LiveMemoryRateLimitStore,
+  LiveRateLimiter,
+)
 
+export const MemoryBot = Layer.provide(
+  Layer.mergeAll(
+    LiveMemoryShardStore,
+    LiveMemoryRateLimitStore,
+    LiveJsonDiscordWSCodec,
+  ),
+  Layer.merge(
+    Layer.provideMerge(LiveDiscordREST, LiveDiscordGateway),
+    MemoryRateLimit,
+  ),
+)
 export const makeLiveWithoutFetch = (
-  config: Config.Wrap<DiscordConfig.MakeOpts>,
-) =>
+  config: Config.Config.Wrap<DiscordConfig.MakeOpts>,
+): Layer.Layer<
+  HttpRequestExecutor,
+  ConfigError.ConfigError,
+  | RateLimiter
+  | Log.Log
+  | DiscordREST
+  | DiscordConfig.DiscordConfig
+  | DiscordGateway
+> =>
   Layer.unwrapEffect(
-    Config.unwrap(config)
-      .config.map(DiscordConfig.make)
-      .map(config => {
+    Effect.config(Config.unwrap(config)).pipe(
+      Effect.map(DiscordConfig.make),
+      Effect.map(config => {
         const LiveLog = config.debug ? Log.LiveLogDebug : Log.LiveLog
         const LiveConfig = Layer.succeed(DiscordConfig.DiscordConfig, config)
-        return LiveLog + LiveConfig > MemoryBot
+        return Layer.provideMerge(Layer.merge(LiveLog, LiveConfig), MemoryBot)
       }),
+    ),
   )
 
-export const makeLive = (config: Config.Wrap<DiscordConfig.MakeOpts>) =>
-  LiveFetchRequestExecutor >> makeLiveWithoutFetch(config)
+export const makeLive = (
+  config: Config.Config.Wrap<DiscordConfig.MakeOpts>,
+): Layer.Layer<
+  never,
+  ConfigError.ConfigError,
+  | RateLimiter
+  | Log.Log
+  | DiscordREST
+  | DiscordConfig.DiscordConfig
+  | DiscordGateway
+> => Layer.provide(LiveFetchRequestExecutor, makeLiveWithoutFetch(config))

package/src/index.ts

@@ -1,20 +1,34 @@
-export * as Discord from "./types.js"
-export * as DiscordConfig from "./DiscordConfig.js"
-export { DiscordREST, LiveDiscordREST } from "./DiscordREST.js"
-export * as Ix from "./Interactions/index.js"
-export * as Log from "./Log.js"
+import * as Cache from "dfx/Cache"
+import * as DiscordConfig from "dfx/DiscordConfig"
+import * as Flags from "dfx/Helpers/flags"
+import * as Intents from "dfx/Helpers/intents"
+import * as IxHelpers from "dfx/Helpers/interactions"
+import * as Members from "dfx/Helpers/members"
+import * as Perms from "dfx/Helpers/permissions"
+import * as UI from "dfx/Helpers/ui"
+import * as Ix from "dfx/Interactions/index"
+import * as Log from "dfx/Log"
+import * as Discord from "dfx/types"
+
+export { DiscordREST, LiveDiscordREST } from "dfx/DiscordREST"
 export {
   BucketDetails,
-  RateLimitStore,
   LiveMemoryRateLimitStore,
-  RateLimiter,
   LiveRateLimiter,
-} from "./RateLimit.js"
-export * as Cache from "./Cache.js"
+  RateLimitStore,
+  RateLimiter,
+} from "dfx/RateLimit"
 
-export * as Flags from "./Helpers/flags.js"
-export * as Intents from "./Helpers/intents.js"
-export * as IxHelpers from "./Helpers/interactions.js"
-export * as Members from "./Helpers/members.js"
-export * as Perms from "./Helpers/permissions.js"
-export * as UI from "./Helpers/ui.js"
+export {
+  Cache,
+  Discord,
+  DiscordConfig,
+  Flags,
+  Intents,
+  Ix,
+  IxHelpers,
+  Log,
+  Members,
+  Perms,
+  UI,
+}

package/src/utils/Effect.ts

@@ -0,0 +1,69 @@
+import * as Effect from "@effect/io/Effect"
+import * as Option from "@effect/data/Option"
+import * as Ref from "@effect/io/Ref"
+import * as Queue from "@effect/io/Queue"
+import * as Hub from "@effect/io/Hub"
+import * as Deferred from "@effect/io/Deferred"
+import * as Fiber from "@effect/io/Fiber"
+
+export const subscribeForEachPar = <R, E, A, X>(
+  self: Hub.Hub<A>,
+  effect: (_: A) => Effect.Effect<R, E, X>,
+): Effect.Effect<R, E, never> =>
+  Effect.flatMap(Deferred.make<E, never>(), deferred => {
+    const run = Hub.subscribe(self).pipe(
+      Effect.flatMap(queue =>
+        Queue.take(queue).pipe(
+          Effect.flatMap(_ =>
+            effect(_).pipe(
+              Effect.catchAllCause(_ => Deferred.failCause(deferred, _)),
+              Effect.fork,
+            ),
+          ),
+          Effect.forever,
+        ),
+      ),
+      Effect.scoped,
+    )
+
+    return Effect.all(run, Deferred.await(deferred), {
+      concurrency: "unbounded",
+      discard: true,
+    }).pipe(Effect.forever)
+  })
+
+/**
+ * @tsplus fluent effect/io/Effect foreverSwitch
+ */
+export const foreverSwitch = <R, E, A, R1, E1, X>(
+  self: Effect.Effect<R, E, A>,
+  f: (_: A) => Effect.Effect<R1, E1, X>,
+): Effect.Effect<R | R1, E | E1, never> =>
+  Effect.flatMap(
+    Effect.all(
+      Deferred.make<E1, never>(),
+      Ref.make<Option.Option<Fiber.RuntimeFiber<E1, X>>>(Option.none()),
+    ),
+    ([causeDeferred, fiberRef]) => {
+      const run = Effect.flatMap(self, _ =>
+        f(_).pipe(
+          Effect.tapErrorCause(_ => Deferred.failCause(causeDeferred, _)),
+          Effect.fork,
+        ),
+      ).pipe(
+        Effect.flatMap(fiber => Ref.getAndSet(fiberRef, Option.some(fiber))),
+        Effect.tap(
+          Option.match({
+            onNone: () => Effect.unit,
+            onSome: fiber => Fiber.interrupt(fiber),
+          }),
+        ),
+        Effect.forever,
+      )
+
+      return Effect.all(run, Deferred.await(causeDeferred), {
+        concurrency: "unbounded",
+        discard: true,
+      }).pipe(Effect.forever)
+    },
+  )

package/src/version.ts

@@ -0,0 +1 @@
+export const LIB_VERSION = "0.51.1";