dfx 0.42.2 → 0.42.4

package/src/Interactions/webhook.ts

@@ -0,0 +1,110 @@
+import Nacl from "tweetnacl"
+import * as D from "./definitions.js"
+import { DefinitionNotFound, handlers } from "./handlers.js"
+import { InteractionBuilder, Interaction } from "./index.js"
+import { fromHex } from "./utils.js"
+
+export class BadWebhookSignature {
+  readonly _tag = "BadWebhookSignature"
+}
+
+export type Headers = Record<string, string | string[] | undefined>
+
+const checkSignature = (
+  publicKey: Uint8Array,
+  headers: Headers,
+  body: string,
+) =>
+  Maybe.struct({
+    signature: Maybe.fromNullable(headers["x-signature-ed25519"]),
+    timestamp: Maybe.fromNullable(headers["x-signature-timestamp"]),
+  })
+    .filter(a => {
+      const enc = new TextEncoder()
+      return Nacl.sign.detached.verify(
+        enc.encode(a.timestamp + body),
+        fromHex(`${a.signature}`),
+        publicKey,
+      )
+    })
+    .toEither(() => new BadWebhookSignature()).asUnit
+
+export interface MakeConfigOpts {
+  applicationId: string
+  publicKey: ConfigSecret
+}
+const makeConfig = ({ applicationId, publicKey }: MakeConfigOpts) => ({
+  applicationId,
+  publicKey: fromHex(publicKey.value),
+})
+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 class WebhookParseError {
+  readonly _tag = "WebhookParseError"
+  constructor(readonly reason: unknown) {}
+}
+
+const fromHeadersAndBody = (headers: Headers, body: string) =>
+  Do($ => {
+    const { publicKey } = $(WebhookConfig)
+    $(checkSignature(publicKey, headers, body))
+    return $(
+      Effect.tryCatch(
+        () => JSON.parse(body) as Discord.Interaction,
+        reason => new WebhookParseError(reason),
+      ),
+    )
+  })
+
+const run = <R, E>(definitions: D.InteractionDefinition<R, E>[]) => {
+  const handler = handlers(definitions)
+  return (headers: Headers, body: string) =>
+    Do($ => {
+      const interaction = $(fromHeadersAndBody(headers, body))
+      return $(
+        handler[interaction.type](interaction).provideService(
+          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>
+}
+
+/**
+ * @tsplus getter dfx/InteractionBuilder webhookHandler
+ */
+export const makeHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
+  const handle = run(ix.definitions)
+
+  return ({
+    headers,
+    body,
+    success,
+    error,
+  }: HandleWebhookOpts<
+    E | WebhookParseError | BadWebhookSignature | DefinitionNotFound
+  >) => handle(headers, body).flatMap(success).catchAllCause(error)
+}
+
+/**
+ * @tsplus getter dfx/InteractionBuilder simpleWebhookHandler
+ */
+export const makeSimpleHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
+  const handle = run(ix.definitions)
+
+  return ({ headers, body }: { headers: Headers; body: string }) =>
+    handle(headers, body)
+}

package/src/Log.ts

@@ -0,0 +1,17 @@
+const make = (debug = false) => ({
+  info: (...args: any[]) =>
+    Effect.sync(() => {
+      console.error("INFO", ...args)
+    }),
+  debug: (...args: any[]) =>
+    debug
+      ? Effect.sync(() => {
+          console.error("DEBUG", ...args)
+        })
+      : Effect.unit(),
+})
+
+export interface Log extends ReturnType<typeof make> {}
+export const Log = Tag<Log>()
+export const LiveLog = Layer.succeed(Log, make(false))
+export const LiveLogDebug = Layer.succeed(Log, make(true))

package/src/RateLimit/memory.ts

@@ -0,0 +1,57 @@
+import { BucketDetails, RateLimitStore } from "../RateLimit.js"
+
+interface Counter {
+  count: number
+  expires: number
+}
+
+export const make = (): RateLimitStore => {
+  const buckets = new Map<string, BucketDetails>()
+  const routes = new Map<string, string>()
+  const counters = new Map<string, Counter>()
+
+  const getCounter = (key: string) =>
+    Maybe.fromNullable(counters.get(key)).filter(c => c.expires > Date.now())
+
+  const getBucketForRoute = (route: string) =>
+    Effect.sync(() => Maybe.fromNullable(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 = getCounter(key).getOrElse(
+          (): 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/src/RateLimit/utils.ts

@@ -0,0 +1,27 @@
+import { millis, zero } from "@effect/data/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/src/RateLimit.ts

@@ -0,0 +1,69 @@
+import { delayFrom } from "./RateLimit/utils.js"
+import * as Memory from "./RateLimit/memory.js"
+import { Log } from "dfx/Log"
+
+export type BucketDetails = {
+  key: "global" | string
+  resetAfter: number
+  limit: number
+}
+
+export interface RateLimitStore {
+  hasBucket: (bucketKey: string) => Effect<never, never, boolean>
+
+  putBucket: (bucket: BucketDetails) => Effect<never, never, void>
+
+  getBucketForRoute: (
+    route: string,
+  ) => Effect<never, never, Maybe<BucketDetails>>
+
+  putBucketRoute: (
+    route: string,
+    bucketKey: string,
+  ) => Effect<never, never, void>
+
+  incrementCounter: (
+    key: string,
+    window: number,
+    limit: number,
+  ) => Effect<never, never, readonly [count: number, ttl: number]>
+
+  removeCounter: (key: string) => 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 maybeWait = (
+    key: string,
+    window: Duration,
+    limit: number,
+    multiplier = 1.05,
+  ) => {
+    const windowMs = window.millis * multiplier
+
+    return store
+      .incrementCounter(key, windowMs, limit)
+      .map(([count, ttl]) => delayFrom(windowMs, limit, count, ttl))
+      .tap(d =>
+        log.debug("RateLimitStore maybeWait", {
+          key,
+          window: window.millis,
+          windowMs,
+          limit,
+          delay: d.millis,
+        }),
+      )
+      .tap(_ => (_.millis === 0 ? Effect.unit() : Effect.sleep(_))).asUnit
+  }
+
+  return { maybeWait }
+})
+
+export interface RateLimiter extends Effect.Success<typeof makeLimiter> {}
+export const RateLimiter = Tag<RateLimiter>()
+export const LiveRateLimiter = Layer.effect(RateLimiter, makeLimiter)

package/src/_common.ts

@@ -0,0 +1,43 @@
+import type { Schedule as _Schedule } from "@effect/io/Schedule"
+import * as Deferred from "@effect/io/Deferred"
+
+export type { Cause } from "@effect/io/Cause"
+export type { Config } from "@effect/io/Config"
+export type { ConfigSecret } from "@effect/io/Config/Secret"
+export type { ConfigError } from "@effect/io/Config/Error"
+export type { Deferred } from "@effect/io/Deferred"
+export type { Effect } from "@effect/io/Effect"
+export type { Exit } from "@effect/io/Exit"
+export type { RuntimeFiber } from "@effect/io/Fiber"
+export type { Hub } from "@effect/io/Hub"
+export type { Layer } from "@effect/io/Layer"
+export type { Dequeue, Enqueue, Queue } from "@effect/io/Queue"
+export type { Ref } from "@effect/io/Ref"
+export type { Scope } from "@effect/io/Scope"
+
+export type { Stream } from "@effect/stream/Stream"
+
+export type { Chunk } from "@effect/data/Chunk"
+export { Context, Tag } from "@effect/data/Context"
+export type { Duration } from "@effect/data/Duration"
+export type { Equal } from "@effect/data/Equal"
+export type { HashMap } from "@effect/data/HashMap"
+export type { HashSet } from "@effect/data/HashSet"
+
+export type { Option as Maybe } from "@effect/data/Option"
+export type { Either } from "@effect/data/Either"
+
+export * as Discord from "./types.js"
+
+/**
+ * @tsplus type effect/io/Schedule
+ * @tsplus companion effect/io/Schedule.Ops
+ */
+export type Schedule<Env, In, Out> = _Schedule<Env, In, Out>
+
+/**
+ * @tsplus getter effect/io/Deferred await
+ */
+export const deferredAwait: <E, A>(
+  self: Deferred.Deferred<E, A>,
+) => Effect<never, E, A> = Deferred.await

package/src/gateway.ts

@@ -0,0 +1,38 @@
+import { LiveFetchRequestExecutor } from "@effect-http/client"
+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"
+
+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 WS from "./DiscordGateway/WS.js"
+export { run as runIx } from "./Interactions/gateway.js"
+
+export const MemoryRateLimit = LiveMemoryRateLimitStore >> LiveRateLimiter
+
+export const MemoryBot =
+  (LiveMemoryShardStore + LiveMemoryRateLimitStore + LiveJsonDiscordWSCodec) >>
+  ((LiveDiscordREST > LiveDiscordGateway) + MemoryRateLimit)
+
+export const makeLiveWithoutFetch = (
+  config: Config.Wrap<DiscordConfig.MakeOpts>,
+  debug = false,
+) => {
+  const LiveLog = debug ? Log.LiveLogDebug : Log.LiveLog
+  const LiveConfig = DiscordConfig.makeFromConfig(Config.unwrap(config))
+  const LiveEnv = LiveLog + LiveConfig > MemoryBot
+
+  return LiveEnv
+}
+
+export const makeLive = (
+  config: Config.Wrap<DiscordConfig.MakeOpts>,
+  debug = false,
+) => {
+  return LiveFetchRequestExecutor >> makeLiveWithoutFetch(config, debug)
+}

package/src/global.ts

@@ -0,0 +1,45 @@
+/**
+ * @tsplus global
+ */
+import type {
+  Cause,
+  Config,
+  ConfigSecret,
+  ConfigError,
+  Deferred,
+  Effect,
+  Exit,
+  Hub,
+  Layer,
+  RuntimeFiber,
+  Dequeue,
+  Enqueue,
+  Queue,
+  Schedule,
+  Scope,
+  Stream,
+  Chunk,
+  Context,
+  Duration,
+  Equal,
+  Either,
+  HashMap,
+  Maybe,
+  Ref,
+  HashSet,
+} from "dfx/_common"
+
+/**
+ * @tsplus global
+ */
+import { Tag, Discord } from "dfx/_common"
+
+/**
+ * @tsplus global
+ */
+import { pipe, flow, identity } from "@effect/data/Function"
+
+/**
+ * @tsplus global
+ */
+import type { LazyArg } from "@effect/data/Function"

package/src/index.ts

@@ -0,0 +1,20 @@
+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"
+export {
+  BucketDetails,
+  RateLimitStore,
+  LiveMemoryRateLimitStore,
+  RateLimiter,
+  LiveRateLimiter,
+} from "./RateLimit.js"
+export * as Cache from "./Cache.js"
+
+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"