dfx 0.3.0 → 0.5.0

package/src/Interactions/handlers.ts

@@ -0,0 +1,139 @@
+import * as Ctx from "./context.js"
+import * as D from "./definitions.js"
+import * as Arr from "@fp-ts/data/ReadonlyArray"
+import { splitDefinitions } from "./utils.js"
+
+export class InteractionNotFound {
+  readonly _tag = "InteractionNotFound"
+  constructor(readonly interaction: Discord.Interaction) {}
+}
+
+export const handlers = <R, E>(
+  definitions: D.InteractionDefinition<R, E>[],
+): Record<
+  Discord.InteractionType,
+  (i: Discord.Interaction) => Effect<R, E, Discord.InteractionResponse>
+> => {
+  const { allCommands, autocompletes, messageComponents, modalSubmits } =
+    splitDefinitions(definitions)
+
+  return {
+    [Discord.InteractionType.PING]: () =>
+      Effect.succeed({
+        type: Discord.InteractionCallbackType.PONG,
+      }),
+
+    [Discord.InteractionType.APPLICATION_COMMAND]: (i) => {
+      const data = i.data as Discord.ApplicationCommandDatum
+
+      return pipe(
+        Maybe.fromNullable(allCommands[data.name]).match(
+          () =>
+            Effect.fail(new InteractionNotFound(i)) as any as Effect<
+              R,
+              E,
+              Discord.InteractionResponse
+            >,
+          (command) => command.handle,
+        ),
+        Effect.provideService(Ctx.InteractionContext)(i),
+        Effect.provideService(Ctx.ApplicationCommandContext)(data),
+      )
+    },
+
+    [Discord.InteractionType.MODAL_SUBMIT]: (i: Discord.Interaction) => {
+      const data = i.data as Discord.ModalSubmitDatum
+
+      return pipe(
+        modalSubmits,
+        Arr.map((a) =>
+          Effect.struct({
+            command: Effect.succeed(a),
+            match: a.predicate(data.custom_id),
+          }),
+        ),
+        (a) =>
+          a.collectAllPar.flatMap((a) =>
+            a
+              .findFirst((a) => a.match)
+              .match(
+                () =>
+                  Effect.fail(new InteractionNotFound(i)) as any as Effect<
+                    R,
+                    E,
+                    Discord.InteractionResponse
+                  >,
+                (a) => a.command.handle,
+              ),
+          ),
+        Effect.provideService(Ctx.InteractionContext)(i),
+        Effect.provideService(Ctx.ModalSubmitContext)(data),
+      )
+    },
+
+    [Discord.InteractionType.MESSAGE_COMPONENT]: (i) => {
+      const data = i.data as Discord.MessageComponentDatum
+
+      return pipe(
+        messageComponents,
+        Arr.map((a) =>
+          Effect.struct({
+            command: Effect.succeed(a),
+            match: a.predicate(data.custom_id),
+          }),
+        ),
+        (a) =>
+          a.collectAllPar.flatMap((a) =>
+            a
+              .findFirst((a) => a.match)
+              .match(
+                () =>
+                  Effect.fail(new InteractionNotFound(i)) as any as Effect<
+                    R,
+                    E,
+                    Discord.InteractionResponse
+                  >,
+                (a) => a.command.handle,
+              ),
+          ),
+        Effect.provideService(Ctx.InteractionContext)(i),
+        Effect.provideService(Ctx.MessageComponentContext)(data),
+      )
+    },
+
+    [Discord.InteractionType.APPLICATION_COMMAND_AUTOCOMPLETE]: (i) => {
+      const data = i.data as Discord.ApplicationCommandDatum
+
+      return IxHelpers.focusedOption(data)
+        .map((focusedOption) =>
+          pipe(
+            autocompletes,
+            Arr.map((a) =>
+              Effect.struct({
+                command: Effect.succeed(a),
+                match: a.predicate(focusedOption),
+              }),
+            ),
+            (a) =>
+              a.collectAllPar.flatMap((a) =>
+                a
+                  .findFirst((a) => a.match)
+                  .match(
+                    () =>
+                      Effect.fail(new InteractionNotFound(i)) as any as Effect<
+                        R,
+                        E,
+                        Discord.InteractionResponse
+                      >,
+                    (a) => a.command.handle,
+                  ),
+              ),
+            Effect.provideService(Ctx.InteractionContext)(i),
+            Effect.provideService(Ctx.ApplicationCommandContext)(data),
+            Effect.provideService(Ctx.FocusedOptionContext)({ focusedOption }),
+          ),
+        )
+        .getOrElse(() => Effect.fail(new InteractionNotFound(i)) as any)
+    },
+  }
+}

package/src/Interactions/index.ts

@@ -0,0 +1,57 @@
+import * as D from "./definitions.js"
+import * as Gateway from "./gateway.js"
+import * as Webhook from "./webhook.js"
+
+export * from "./context.js"
+
+export {
+  global,
+  guild,
+  messageComponent,
+  modalSubmit,
+  autocomplete,
+  InteractionDefinition,
+} from "./definitions.js"
+
+export {
+  makeConfig as makeWebhookConfig,
+  WebhookConfig,
+  WebhookParseError,
+  BadWebhookSignature,
+} from "./webhook.js"
+
+class InteractionBuilder<R, E> {
+  constructor(readonly definitions: D.InteractionDefinition<R, E>[]) {}
+
+  add<R1, E1>(definition: D.InteractionDefinition<R1, E1>) {
+    return new InteractionBuilder<R | R1, E | E1>([
+      ...this.definitions,
+      definition,
+    ])
+  }
+
+  runGateway(opts: Gateway.RunOpts = {}) {
+    return Gateway.run(this.definitions, opts)
+  }
+
+  handleWebhook(headers: Record<string, string>, rawBody: string) {
+    return Webhook.run(this.definitions, headers, rawBody)
+  }
+}
+
+export const builder = new InteractionBuilder<never, never>([])
+
+// Filters
+export const id = (query: string) => (customId: string) =>
+  Effect.succeed(query === customId)
+
+export const idStartsWith = (query: string) => (customId: string) =>
+  Effect.succeed(customId.startsWith(query))
+
+export const regex = (query: RegExp) => (customId: string) =>
+  Effect.succeed(query.test(customId))
+
+export const option =
+  (name: string) =>
+  (focusedOption: Discord.ApplicationCommandInteractionDataOption) =>
+    Effect.succeed(focusedOption.name === name)

package/src/Interactions/utils.ts

@@ -0,0 +1,47 @@
+import * as D from "./definitions.js"
+
+export const splitDefinitions = <R, E>(
+  definitions: D.InteractionDefinition<R, E>[],
+) => {
+  const globalCommands = definitions.filter(
+    (a): a is D.GlobalApplicationCommand<R, E> =>
+      a._tag === "GlobalApplicationCommand",
+  )
+
+  const guildCommands = definitions.filter(
+    (a): a is D.GuildApplicationCommand<R, E> =>
+      a._tag === "GuildApplicationCommand",
+  )
+
+  const messageComponents = definitions.filter(
+    (a): a is D.MessageComponent<R, E> => a._tag === "MessageComponent",
+  )
+
+  const modalSubmits = definitions.filter(
+    (a): a is D.ModalSubmit<R, E> => a._tag === "ModalSubmit",
+  )
+
+  const autocompletes = definitions.filter(
+    (a): a is D.Autocomplete<R, E> => a._tag === "Autocomplete",
+  )
+
+  const allCommands = [...globalCommands, ...guildCommands].reduce(
+    (acc, a) => ({
+      ...acc,
+      [a.command.name]: a,
+    }),
+    {} as Record<
+      string,
+      D.GlobalApplicationCommand<R, E> | D.GuildApplicationCommand<R, E>
+    >,
+  )
+
+  return {
+    globalCommands,
+    guildCommands,
+    messageComponents,
+    modalSubmits,
+    autocompletes,
+    allCommands,
+  }
+}

package/src/Interactions/webhook.ts

@@ -0,0 +1,59 @@
+import Nacl from "tweetnacl"
+import * as D from "./definitions.js"
+import { handlers } from "./handlers.js"
+
+export class BadWebhookSignature {
+  readonly _tag = "BadWebhookSignature"
+}
+
+const checkSignature = (
+  publicKey: string,
+  headers: Record<string, string>,
+  body: string,
+) =>
+  Maybe.struct({
+    signature: Maybe.fromNullable(headers["x-signature-ed25519"]),
+    timestamp: Maybe.fromNullable(headers["x-signature-timestamp"]),
+  })
+    .filter((a) =>
+      Nacl.sign.detached.verify(
+        Buffer.from(a.timestamp + body),
+        Buffer.from(a.signature, "hex"),
+        Buffer.from(publicKey, "hex"),
+      ),
+    )
+    .toEither(() => new BadWebhookSignature()).asUnit
+
+export interface WebhookConfig {
+  applicationId: string
+  publicKey: string
+}
+export const WebhookConfig = Tag<WebhookConfig>()
+export const makeConfig = (a: WebhookConfig) => Layer.succeed(WebhookConfig)(a)
+
+export class WebhookParseError {
+  readonly _tag = "WebhookParseError"
+  constructor(readonly reason: unknown) {}
+}
+
+const fromHeadersAndBody = (headers: Record<string, string>, body: string) =>
+  Do(($) => {
+    const { publicKey } = $(Effect.service(WebhookConfig))
+    $(Effect.fromEither(checkSignature(publicKey, headers, body)))
+    return $(
+      Effect.tryCatch(
+        () => JSON.parse(body) as Discord.Interaction,
+        (reason) => new WebhookParseError(reason),
+      ),
+    )
+  })
+
+export const run = <R, E>(
+  definitions: D.InteractionDefinition<R, E>[],
+  headers: Record<string, string>,
+  body: string,
+) =>
+  Do(($) => {
+    const interaction = $(fromHeadersAndBody(headers, body))
+    return $(handlers(definitions)[interaction.type](interaction))
+  })

package/src/Log/index.ts

@@ -0,0 +1,23 @@
+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))
+
+export const info = (...args: any[]) =>
+  Effect.serviceWithEffect(Log)(({ info: log }) => log(...args))
+
+export const debug = (...args: any[]) =>
+  Effect.serviceWithEffect(Log)(({ debug }) => debug(...args))

package/src/RateLimitStore/index.ts

@@ -0,0 +1,65 @@
+import { delayFrom } from "./utils.js"
+import * as Memory from "./memory.js"
+
+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]>
+}
+
+export const RateLimitStore = Tag<RateLimitStore>()
+export const LiveMemoryRateLimitStore = Layer.sync(RateLimitStore)(Memory.make)
+
+const makeLimiter = Do(($) => {
+  const store = $(Effect.service(RateLimitStore))
+  const log = $(Effect.service(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(Effect.sleep).asUnit
+  }
+
+  return { maybeWait }
+})
+
+export interface RateLimiter extends Success<typeof makeLimiter> {}
+export const RateLimiter = Tag<RateLimiter>()
+export const LiveRateLimiter = Layer.fromEffect(RateLimiter)(makeLimiter)

package/src/RateLimitStore/memory.ts

@@ -0,0 +1,48 @@
+interface Counter {
+  count: number
+  expires: number
+}
+
+export const make = (): RateLimitStore.RateLimitStore => {
+  const buckets = new Map<string, RateLimitStore.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())
+
+  return {
+    hasBucket: (key) => Effect.sync(() => buckets.has(key)),
+
+    putBucket: (bucket) =>
+      Effect.sync(() => {
+        buckets.set(bucket.key, bucket)
+      }),
+
+    getBucketForRoute: (route) =>
+      Effect.sync(() => Maybe.fromNullable(buckets.get(routes.get(route)!))),
+
+    putBucketRoute: (route, bucket) =>
+      Effect.sync(() => {
+        routes.set(route, bucket)
+      }),
+
+    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/RateLimitStore/utils.ts

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

@@ -0,0 +1,35 @@
+export { Effect, EffectTypeId } from "@effect/io/Effect"
+export type { Layer } from "@effect/io/Layer"
+export type { Schedule } from "@effect/io/Schedule"
+export type { Cause } from "@effect/io/Cause"
+export type { Chunk } from "@fp-ts/data/Chunk"
+export { Context, Tag } from "@fp-ts/data/Context"
+export type { Duration } from "@fp-ts/data/Duration"
+export type { Equal } from "@fp-ts/data/Equal"
+export type { Option as Maybe } from "@fp-ts/data/Option"
+export type { Either } from "@fp-ts/data/Either"
+export type { Exit } from "@effect/io/Exit"
+export type { EffectSource } from "callbag-effect-ts/Source"
+export type { EffectSink } from "callbag-effect-ts/Sink"
+export type { HashMap } from "@fp-ts/data/HashMap"
+export type { Ref } from "@effect/io/Ref"
+
+export * as Config from "dfx/DiscordConfig/index"
+export * as Discord from "dfx/types"
+export * as Http from "dfx/Http/index"
+export * as Log from "dfx/Log/index"
+export * as RateLimitStore from "dfx/RateLimitStore/index"
+export * as Rest from "dfx/DiscordREST/index"
+export * as Gateway from "dfx/DiscordGateway/index"
+export * as WS from "dfx/DiscordGateway/WS/index"
+export * as DWS from "dfx/DiscordGateway/DiscordWS/index"
+export * as Shard from "dfx/DiscordGateway/Shard/index"
+export * as ShardStore from "dfx/DiscordGateway/ShardStore/index"
+export * as Ix from "dfx/Interactions/index"
+
+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"

package/src/example.ts

@@ -0,0 +1,52 @@
+import { Ix, makeLayer } from "dfx"
+import Dotenv from "dotenv"
+
+Dotenv.config()
+
+const LiveEnv = makeLayer({
+  token: process.env.DISCORD_BOT_TOKEN!,
+})
+
+const hello = Ix.guild(
+  {
+    name: "hello",
+    description: "Eh yo",
+    options: [
+      {
+        type: Discord.ApplicationCommandOptionType.SUB_COMMAND,
+        name: "one",
+        description: "The first sub command",
+      },
+      {
+        type: Discord.ApplicationCommandOptionType.SUB_COMMAND,
+        name: "two",
+        description: "The second sub command",
+      },
+    ],
+  },
+  Ix.handleSubCommands({
+    one: Effect.succeed({
+      type: 4,
+      data: {
+        content: "One",
+      },
+    }),
+
+    two: Ix.getSubCommand.map((a) => ({
+      type: 4,
+      data: {
+        content: a.name,
+      },
+    })),
+  }),
+)
+
+Ix.builder
+  .add(hello)
+  .runGateway()
+  .provideLayer(LiveEnv)
+  .unsafeRunPromiseExit.then((exit) => {
+    if (exit.isFailure) {
+      console.error(exit.cause.unsafeRunSync.pretty())
+    }
+  })

package/src/global.ts

@@ -0,0 +1,50 @@
+/**
+ * @tsplus global
+ */
+import type {
+  Effect,
+  EffectTypeId,
+  Layer,
+  Either,
+  Maybe,
+  Tag,
+  Context,
+  Cause,
+  Chunk,
+  Duration,
+  Equal,
+  Exit,
+  HashMap,
+  Schedule,
+  EffectSource,
+  EffectSink,
+  Ref,
+  Config,
+  Discord,
+  Http,
+  Log,
+  RateLimitStore,
+  Rest,
+  Gateway,
+  WS,
+  DWS,
+  Shard,
+  ShardStore,
+  Ix,
+  Flags,
+  Intents,
+  IxHelpers,
+  Members,
+  Perms,
+  UI,
+} from "dfx/common"
+
+/**
+ * @tsplus global
+ */
+import type { Success } from "dfx/utils/effect"
+
+/**
+ * @tsplus global
+ */
+import { pipe, flow, identity } from "@fp-ts/data/Function"

package/src/index.ts

@@ -0,0 +1,45 @@
+export * as Config from "./DiscordConfig/index.js"
+export * as DiscordWS from "./DiscordGateway/DiscordWS/index.js"
+export * as Gateway from "./DiscordGateway/index.js"
+export { DiscordREST, LiveDiscordREST, rest } from "./DiscordREST/index.js"
+export * as Ix from "./Interactions/index.js"
+export * as Log from "./Log/index.js"
+export * as RateLimitStore from "./RateLimitStore/index.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"
+
+export const LiveRateLimit =
+  RateLimitStore.LiveMemoryRateLimitStore > RateLimitStore.LiveRateLimiter
+
+export const LiveREST = LiveRateLimit > Rest.LiveDiscordREST
+
+export const LiveGateway =
+  ShardStore.LiveMemoryShardStore + DWS.LiveJsonDiscordWSCodec >
+  Gateway.LiveDiscordGateway
+
+export const LiveBot = LiveREST > LiveGateway
+
+export const makeLayer = (config: Config.MakeOpts, debug = false) => {
+  const LiveLog = debug ? Log.LiveLogDebug : Log.LiveLog
+  const LiveConfig = Config.makeLayer(config)
+  const LiveEnv = LiveLog + LiveConfig > LiveBot
+
+  return LiveEnv
+}
+
+export const makeWebhookLayer = (
+  config: Config.MakeOpts & Ix.WebhookConfig,
+  debug = false,
+) => {
+  const LiveWebhook = Ix.makeWebhookConfig(config)
+  const LiveLog = debug ? Log.LiveLogDebug : Log.LiveLog
+  const LiveConfig = Config.makeLayer(config)
+  const LiveEnv = LiveLog + LiveConfig + LiveWebhook > LiveREST
+
+  return LiveEnv
+}

package/src/json.d.ts

@@ -0,0 +1 @@
+declare module "*.json"