dfx 1.0.4 → 1.0.5

package/dist/src/Interactions/webhook.ts

@@ -0,0 +1,204 @@
+import * as Chunk from "effect/Chunk"
+import { identity } from "effect/Function"
+import * as Option from "effect/Option"
+import type * as Cause from "effect/Cause"
+import type * as Config from "effect/Config"
+import * as Redacted from "effect/Redacted"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as ServiceMap from "effect/ServiceMap"
+import type * as D from "./definitions.ts"
+import type { DefinitionNotFound } from "./handlers.ts"
+import { handlers } from "./handlers.ts"
+import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
+import { Interaction } from "./index.ts"
+import type * as Discord from "../types.ts"
+import * as Verify from "discord-verify"
+import * as Data from "effect/Data"
+
+export class BadWebhookSignature {
+  readonly _tag = "BadWebhookSignature"
+}
+
+export type Headers = Record<string, string | Array<string> | undefined>
+
+const checkSignature = (
+  publicKey: string,
+  headers: Headers,
+  body: string,
+  crypto: SubtleCrypto,
+  algorithm: any,
+) =>
+  Effect.fromOption(
+    Option.all({
+      signature: Option.fromNullishOr(headers["x-signature-ed25519"]),
+      timestamp: Option.fromNullishOr(headers["x-signature-timestamp"]),
+    }),
+  ).pipe(
+    Effect.flatMap(_ =>
+      Effect.promise(() =>
+        Verify.verify(
+          body,
+          _.signature as string,
+          _.timestamp as string,
+          publicKey,
+          crypto,
+          algorithm,
+        ),
+      ),
+    ),
+    Effect.filterOrFail(identity, () => new BadWebhookSignature()),
+    Effect.catchCause(() => Effect.fail(new BadWebhookSignature())),
+    Effect.asVoid,
+  )
+
+export interface MakeConfigOpts {
+  readonly applicationId: string
+  readonly publicKey: Redacted.Redacted
+  readonly crypto: SubtleCrypto
+  readonly algorithm: keyof typeof Verify.PlatformAlgorithm
+}
+const makeConfig = ({
+  algorithm,
+  applicationId,
+  crypto,
+  publicKey,
+}: MakeConfigOpts) => ({
+  applicationId,
+  publicKey: Redacted.value(publicKey),
+  crypto,
+  algorithm: Verify.PlatformAlgorithm[algorithm],
+})
+
+export class WebhookConfig extends ServiceMap.Service<
+  WebhookConfig,
+  ReturnType<typeof makeConfig>
+>()("dfx/Interactions/WebhookConfig") {}
+
+export const layer = (opts: MakeConfigOpts) =>
+  Layer.succeed(WebhookConfig, makeConfig(opts))
+
+export const layerConfig: (
+  config: Config.Config<MakeConfigOpts>,
+) => Layer.Layer<WebhookConfig, Config.ConfigError> = (
+  config: Config.Config<MakeConfigOpts>,
+) => Layer.effect(WebhookConfig, Effect.map(config.asEffect(), makeConfig))
+
+export class WebhookParseError extends Data.TaggedError("WebhookParseError")<{
+  cause: unknown
+}> {}
+
+const fromHeadersAndBody = (headers: Headers, body: string) =>
+  WebhookConfig.use(({ algorithm, crypto, publicKey }) =>
+    checkSignature(publicKey, headers, body, crypto, algorithm).pipe(
+      Effect.andThen(
+        Effect.try({
+          try: () => JSON.parse(body) as Discord.APIInteraction,
+          catch: cause => new WebhookParseError({ cause }),
+        }),
+      ),
+    ),
+  )
+
+const run = <R, E>(
+  definitions: Chunk.Chunk<
+    readonly [
+      handler: D.InteractionDefinition<R, E>,
+      transform: (
+        self: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+      ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+    ]
+  >,
+  handleResponse: (
+    ix: Discord.APIInteraction,
+    _: Discord.CreateInteractionResponseRequest,
+  ) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
+) => {
+  const handler = handlers(definitions, handleResponse)
+  return (
+    headers: Headers,
+    body: string,
+  ): Effect.Effect<
+    Discord.CreateInteractionResponseRequest,
+    BadWebhookSignature | WebhookParseError | E | DefinitionNotFound,
+    WebhookConfig | Exclude<R, DiscordInteraction>
+  > =>
+    Effect.flatMap(fromHeadersAndBody(headers, body), interaction =>
+      Effect.withSpan(
+        Effect.provideService(
+          handler[interaction.type](interaction),
+          Interaction,
+          interaction,
+        ),
+        "dfx.Interaction",
+        {
+          attributes: { interactionId: interaction.id },
+          captureStackTrace: false,
+        },
+      ),
+    )
+}
+
+export interface HandleWebhookOpts<E> {
+  headers: Headers
+  body: string
+  success: (a: Discord.CreateInteractionResponseRequest) => Effect.Effect<void>
+  error: (e: Cause.Cause<E>) => Effect.Effect<void>
+}
+
+/**
+ * @tsplus getter dfx/InteractionBuilder webhookHandler
+ */
+export const makeHandler = <R, E, TE>(
+  ix: InteractionBuilder<R, E, TE>,
+): (({
+  body,
+  error,
+  headers,
+  success,
+}: HandleWebhookOpts<
+  E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
+>) => Effect.Effect<void, never, WebhookConfig>) => {
+  const handle = run(
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
+    (_i, r) => Effect.succeed(r),
+  )
+
+  return ({
+    body,
+    error,
+    headers,
+    success,
+  }: HandleWebhookOpts<
+    E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
+  >): Effect.Effect<void, never, WebhookConfig> =>
+    handle(headers, body).pipe(
+      Effect.flatMap(success),
+      Effect.catchCause(error),
+    )
+}
+
+/**
+ * @tsplus getter dfx/InteractionBuilder simpleWebhookHandler
+ */
+export const makeSimpleHandler = <R, E, TE>(
+  ix: InteractionBuilder<R, E, TE>,
+): (({
+  body,
+  headers,
+}: {
+  headers: Headers
+  body: string
+}) => Effect.Effect<
+  Discord.CreateInteractionResponseRequest,
+  BadWebhookSignature | WebhookParseError | DefinitionNotFound,
+  WebhookConfig
+>) => {
+  const handle = run(
+    Chunk.map(ix.definitions, ([d]) => [d, identity] as any),
+    (_i, r) => Effect.succeed(r),
+  )
+
+  return ({ body, headers }: { headers: Headers; body: string }) =>
+    handle(headers, body)
+}

package/dist/src/RateLimit/memory.ts

@@ -0,0 +1,63 @@
+import * as Option from "effect/Option"
+import * as Effect from "effect/Effect"
+import type { BucketDetails, RateLimitStoreService } from "../RateLimit.ts"
+
+interface Counter {
+  count: number
+  expires: number
+}
+
+export const make = (): RateLimitStoreService => {
+  const buckets = new Map<string, BucketDetails>()
+  const routes = new Map<string, string>()
+  const counters = new Map<string, Counter>()
+
+  const getCounter = (key: string) =>
+    Option.filter(
+      Option.fromNullishOr(counters.get(key)),
+      c => c.expires > Date.now(),
+    )
+
+  const getBucketForRoute = (route: string) =>
+    Effect.sync(() => Option.fromNullishOr(buckets.get(routes.get(route)!)))
+
+  return {
+    hasBucket: key => Effect.sync(() => buckets.has(key)),
+
+    putBucket: bucket =>
+      Effect.sync(() => {
+        buckets.set(bucket.key, bucket)
+      }),
+
+    getBucketForRoute,
+
+    putBucketRoute: (route, bucket) =>
+      Effect.sync(() => {
+        routes.set(route, bucket)
+      }),
+
+    removeCounter: key =>
+      Effect.sync(() => {
+        counters.delete(key)
+      }),
+
+    incrementCounter: (key, window, limit) =>
+      Effect.sync(() => {
+        const now = Date.now()
+        const perRequest = Math.ceil(window / limit)
+        const counter = Option.getOrElse(
+          getCounter(key),
+          (): Counter => ({
+            expires: now,
+            count: 0,
+          }),
+        )
+
+        const count = counter.count + 1
+        const expires = counter.expires + perRequest
+        counters.set(key, { ...counter, count, expires })
+
+        return [count, expires - now]
+      }),
+  }
+}

package/dist/src/RateLimit/utils.ts

@@ -0,0 +1,28 @@
+import type { Duration } from "effect/Duration"
+import { millis, zero } from "effect/Duration"
+
+export const delayFrom = (
+  window: number,
+  limit: number,
+  count: number,
+  ttl: number,
+): Duration => {
+  const perRequest = Math.ceil(window / limit)
+
+  const totalTime = count * perRequest
+  const elapsedTime = totalTime - ttl
+  const elapsedWindows = Math.floor(elapsedTime / window)
+  const completedRequests = elapsedWindows * limit
+  const remainingRequests = count - completedRequests
+  const remainingWindows = Math.floor((remainingRequests - 1) / limit)
+  const delayRemainder = elapsedTime % window
+
+  const requestRemainder = count % limit
+  const staggerDelay = requestRemainder * 50
+
+  if (remainingWindows === 0) {
+    return zero
+  }
+
+  return millis(remainingWindows * window - delayRemainder + staggerDelay)
+}

package/dist/src/RateLimit.ts

@@ -0,0 +1,90 @@
+import * as Duration from "effect/Duration"
+import type * as Option from "effect/Option"
+import * as Effect from "effect/Effect"
+import * as Layer from "effect/Layer"
+import * as Memory from "./RateLimit/memory.ts"
+import { delayFrom } from "./RateLimit/utils.ts"
+import * as ServiceMap from "effect/ServiceMap"
+
+export type BucketDetails = {
+  key: "global" | string
+  resetAfter: number
+  limit: number
+}
+
+export interface RateLimitStoreService {
+  readonly hasBucket: (bucketKey: string) => Effect.Effect<boolean>
+
+  readonly putBucket: (bucket: BucketDetails) => Effect.Effect<void>
+
+  readonly getBucketForRoute: (
+    route: string,
+  ) => Effect.Effect<Option.Option<BucketDetails>>
+
+  readonly putBucketRoute: (
+    route: string,
+    bucketKey: string,
+  ) => Effect.Effect<void>
+
+  readonly incrementCounter: (
+    key: string,
+    window: number,
+    limit: number,
+  ) => Effect.Effect<readonly [count: number, ttl: number]>
+
+  readonly removeCounter: (key: string) => Effect.Effect<void>
+}
+
+export class RateLimitStore extends ServiceMap.Service<
+  RateLimitStore,
+  RateLimitStoreService
+>()("dfx/RateLimit/RateLimitStore") {}
+
+export const MemoryRateLimitStoreLive = Layer.sync(RateLimitStore, Memory.make)
+
+const makeLimiter = Effect.gen(function* () {
+  const store = yield* RateLimitStore
+
+  const maybeWait = (
+    key: string,
+    window: Duration.Duration,
+    limit: number,
+    multiplier = 1.05,
+  ) => {
+    const windowMs = Duration.toMillis(window) * multiplier
+
+    return store.incrementCounter(key, windowMs, limit).pipe(
+      Effect.map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl)),
+      Effect.tap(d =>
+        Effect.annotateLogs(Effect.logTrace("maybeWait"), {
+          service: "RateLimit",
+          key,
+          window: Duration.toMillis(window),
+          windowMs,
+          limit,
+          delay: Duration.toMillis(d),
+        }),
+      ),
+      Effect.tap(_ =>
+        Duration.toMillis(_) === 0 ? Effect.void : Effect.sleep(_),
+      ),
+      Effect.asVoid,
+    )
+  }
+
+  return { maybeWait }
+})
+
+export class RateLimiter extends ServiceMap.Service<
+  RateLimiter,
+  {
+    maybeWait: (
+      key: string,
+      window: Duration.Duration,
+      limit: number,
+      multiplier?: number,
+    ) => Effect.Effect<void, never, never>
+  }
+>()("dfx/RateLimit/RateLimiter") {}
+
+export const RateLimiterLive = Layer.effect(RateLimiter, makeLimiter)

package/dist/src/gateway.ts

@@ -0,0 +1,50 @@
+import * as CachePrelude from "./Cache/prelude.ts"
+import type { DiscordGateway } from "./DiscordGateway.ts"
+import { DiscordGatewayLive } from "./DiscordGateway.ts"
+import * as DiscordWS from "./DiscordGateway/DiscordWS.ts"
+import { JsonDiscordWSCodecLive } from "./DiscordGateway/DiscordWS.ts"
+import * as Shard from "./DiscordGateway/Shard.ts"
+import { ShardStateStore } from "./DiscordGateway/Shard/StateStore.ts"
+import * as SendEvent from "./DiscordGateway/Shard/sendEvents.ts"
+import * as ShardStore from "./DiscordGateway/ShardStore.ts"
+import { MemoryShardStoreLive } from "./DiscordGateway/ShardStore.ts"
+import type { DiscordREST } from "./DiscordREST.ts"
+import { DiscordRESTLive } from "./DiscordREST.ts"
+import type { InteractionsRegistry } from "./Interactions/gateway.ts"
+import { InteractionsRegistryLive } from "./Interactions/gateway.ts"
+import type { RateLimiter } from "./RateLimit.ts"
+import { MemoryRateLimitStoreLive, RateLimiterLive } from "./RateLimit.ts"
+import * as Layer from "effect/Layer"
+import type * as HttpClient from "effect/unstable/http/HttpClient"
+import type { DiscordConfig } from "./DiscordConfig.ts"
+import type { WebSocketConstructor } from "effect/unstable/socket/Socket"
+
+export { DiscordGateway, DiscordGatewayLive } from "./DiscordGateway.ts"
+
+export {
+  InteractionsRegistry,
+  InteractionsRegistryLive,
+  interactionsSync,
+  run as runIx,
+  setInteractionsSync,
+} from "./Interactions/gateway.ts"
+
+export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore }
+
+export const DiscordLive: Layer.Layer<
+  RateLimiter | DiscordGateway | DiscordREST,
+  never,
+  DiscordConfig | WebSocketConstructor | HttpClient.HttpClient
+> = Layer.mergeAll(RateLimiterLive, DiscordGatewayLive).pipe(
+  Layer.provideMerge(DiscordRESTLive),
+  Layer.provide(JsonDiscordWSCodecLive),
+  Layer.provide(MemoryRateLimitStoreLive),
+  Layer.provide(MemoryShardStoreLive),
+  Layer.provide(ShardStateStore.MemoryLive),
+)
+
+export const DiscordIxLive: Layer.Layer<
+  RateLimiter | DiscordGateway | DiscordREST | InteractionsRegistry,
+  never,
+  DiscordConfig | WebSocketConstructor | HttpClient.HttpClient
+> = InteractionsRegistryLive.pipe(Layer.provideMerge(DiscordLive))

package/dist/src/index.ts

@@ -0,0 +1,44 @@
+import type { HttpClient } from "effect/unstable/http/HttpClient"
+import * as Cache from "./Cache.ts"
+import * as DiscordConfig from "./DiscordConfig.ts"
+import type { DiscordREST } from "./DiscordREST.ts"
+import { DiscordRESTLive } from "./DiscordREST.ts"
+import * as Flags from "./Helpers/flags.ts"
+import * as Intents from "./Helpers/intents.ts"
+import * as IxHelpers from "./Helpers/interactions.ts"
+import * as Members from "./Helpers/members.ts"
+import * as Perms from "./Helpers/permissions.ts"
+import * as UI from "./Helpers/ui.ts"
+import * as Ix from "./Interactions/index.ts"
+import { MemoryRateLimitStoreLive } from "./RateLimit.ts"
+import * as Discord from "./types.ts"
+import * as Layer from "effect/Layer"
+
+export { DiscordREST, DiscordRESTLive } from "./DiscordREST.ts"
+
+export {
+  type BucketDetails,
+  MemoryRateLimitStoreLive,
+  RateLimitStore,
+  RateLimiter,
+  RateLimiterLive,
+} from "./RateLimit.ts"
+
+export {
+  Cache,
+  Discord,
+  DiscordConfig,
+  Flags,
+  Intents,
+  Ix,
+  IxHelpers,
+  Members,
+  Perms,
+  UI,
+}
+
+export const DiscordRESTMemoryLive: Layer.Layer<
+  DiscordREST,
+  never,
+  DiscordConfig.DiscordConfig | HttpClient
+> = DiscordRESTLive.pipe(Layer.provide(MemoryRateLimitStoreLive))