dfx 0.9.5 → 0.9.8

package/src/Interactions/gateway.ts

@@ -1,55 +0,0 @@
-import { handlers } from "./handlers.js"
-import { InteractionBuilder } from "./index.js"
-import { splitDefinitions } from "./utils.js"
-
-export interface RunOpts {
-  sync?: boolean
-}
-
-export const run =
-  <R2, E, E2>(
-    catchAll: (
-      e: Http.FetchError | Http.StatusCodeError | Http.JsonParseError | E,
-    ) => Effect<R2, E2, any>,
-    { sync = true }: RunOpts = {},
-  ) =>
-  <R>(ix: InteractionBuilder<R, E>) =>
-    Do(($) => {
-      const { GlobalApplicationCommand, GuildApplicationCommand } =
-        splitDefinitions(ix.definitions)
-
-      const application = $(
-        Rest.rest.getCurrentBotApplicationInformation().flatMap((a) => a.json),
-      )
-
-      const globalSync = Rest.rest.bulkOverwriteGlobalApplicationCommands(
-        application.id,
-        {
-          body: JSON.stringify(GlobalApplicationCommand.map((a) => a.command)),
-        },
-      )
-
-      const guildSync = GuildApplicationCommand.length
-        ? Gateway.handleDispatch("GUILD_CREATE", (a) =>
-            Rest.rest.bulkOverwriteGuildApplicationCommands(
-              application.id,
-              a.id,
-              GuildApplicationCommand.map((a) => a.command) as any,
-            ),
-          )
-        : Effect.unit()
-
-      const handle = handlers(ix.definitions)
-
-      const run = Gateway.handleDispatch("INTERACTION_CREATE", (i) =>
-        handle[i.type](i)
-          .tap((r) =>
-            r.match(Effect.unit, (r) =>
-              Rest.rest.createInteractionResponse(i.id, i.token, r),
-            ),
-          )
-          .catchAll(catchAll),
-      )
-
-      $(sync ? run.zipPar(globalSync).zipPar(guildSync) : run)
-    })

package/src/Interactions/handlers.ts

@@ -1,139 +0,0 @@
-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, Maybe<Discord.InteractionResponse>>
-> => {
-  const { Commands, Autocomplete, MessageComponent, ModalSubmit } =
-    splitDefinitions(definitions)
-
-  return {
-    [Discord.InteractionType.PING]: () =>
-      Effect.succeed({
-        type: Discord.InteractionCallbackType.PONG,
-      }).asSome,
-
-    [Discord.InteractionType.APPLICATION_COMMAND]: (i) => {
-      const data = i.data as Discord.ApplicationCommandDatum
-
-      return pipe(
-        Maybe.fromNullable(Commands[data.name]).match(
-          () =>
-            Effect.fail(new InteractionNotFound(i)) as any as Effect<
-              R,
-              E,
-              Maybe<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(
-        ModalSubmit,
-        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,
-                    Maybe<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(
-        MessageComponent,
-        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,
-                    Maybe<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(
-            Autocomplete,
-            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,
-                        Maybe<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

@@ -1,83 +0,0 @@
-import * as D from "./definitions.js"
-
-export * from "./context.js"
-
-export {
-  global,
-  guild,
-  messageComponent,
-  modalSubmit,
-  autocomplete,
-  InteractionDefinition,
-  InteractionResponse,
-} from "./definitions.js"
-
-export {
-  makeConfigLayer as makeWebhookConfig,
-  makeHandler as makeWebhookHandler,
-  MakeConfigOpts as MakeWebhookConfigOpts,
-  WebhookConfig,
-  WebhookParseError,
-  BadWebhookSignature,
-} from "./webhook.js"
-
-export 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,
-    ])
-  }
-
-  get syncGlobal() {
-    const commands = this.definitions
-      .filter(
-        (c): c is D.GlobalApplicationCommand<R, E> =>
-          c._tag === "GlobalApplicationCommand",
-      )
-      .map((c) => c.command)
-
-    return Rest.rest
-      .getCurrentBotApplicationInformation()
-      .flatMap((r) => r.json)
-      .flatMap((app) =>
-        Rest.rest.bulkOverwriteGlobalApplicationCommands(app.id, {
-          body: JSON.stringify(commands),
-        }),
-      )
-  }
-
-  syncGuild(appId: Discord.Snowflake, guildId: Discord.Snowflake) {
-    const commands = this.definitions
-      .filter(
-        (c): c is D.GuildApplicationCommand<R, E> =>
-          c._tag === "GuildApplicationCommand",
-      )
-      .map((c) => c.command)
-
-    return Rest.rest.bulkOverwriteGuildApplicationCommands(
-      appId,
-      guildId,
-      commands as any,
-    )
-  }
-}
-
-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

@@ -1,81 +0,0 @@
-import * as D from "./definitions.js"
-
-export const splitDefinitions = <R, E>(
-  definitions: D.InteractionDefinition<R, E>[],
-) => {
-  const grouped = definitions.reduce<{
-    [K in D.InteractionDefinition<R, E>["_tag"]]: Extract<
-      D.InteractionDefinition<R, E>,
-      { _tag: K }
-    >[]
-  }>(
-    (acc, a) => ({
-      ...acc,
-      [a._tag]: [...(acc[a._tag] ?? []), a],
-    }),
-    {
-      Autocomplete: [],
-      GlobalApplicationCommand: [],
-      GuildApplicationCommand: [],
-      MessageComponent: [],
-      ModalSubmit: [],
-    },
-  )
-
-  const Commands = [
-    ...grouped.GlobalApplicationCommand,
-    ...grouped.GuildApplicationCommand,
-  ].reduce(
-    (acc, a) => ({
-      ...acc,
-      [a.command.name]: a,
-    }),
-    {} as Record<
-      string,
-      D.GlobalApplicationCommand<R, E> | D.GuildApplicationCommand<R, E>
-    >,
-  )
-
-  return {
-    ...grouped,
-    Commands,
-  }
-}
-const MAP_HEX: Record<string, number> = {
-  0: 0,
-  1: 1,
-  2: 2,
-  3: 3,
-  4: 4,
-  5: 5,
-  6: 6,
-  7: 7,
-  8: 8,
-  9: 9,
-  a: 10,
-  b: 11,
-  c: 12,
-  d: 13,
-  e: 14,
-  f: 15,
-  A: 10,
-  B: 11,
-  C: 12,
-  D: 13,
-  E: 14,
-  F: 15,
-}
-
-export function fromHex(hexString: string) {
-  const bytes = new Uint8Array(Math.floor((hexString || "").length / 2))
-  let i
-  for (i = 0; i < bytes.length; i++) {
-    const a = MAP_HEX[hexString[i * 2]]
-    const b = MAP_HEX[hexString[i * 2 + 1]]
-    if (a === undefined || b === undefined) {
-      break
-    }
-    bytes[i] = (a << 4) | b
-  }
-  return i === bytes.length ? bytes : bytes.slice(0, i)
-}

package/src/Interactions/webhook.ts

@@ -1,96 +0,0 @@
-import Nacl from "tweetnacl"
-import * as D from "./definitions.js"
-import { handlers } from "./handlers.js"
-import { InteractionBuilder } 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: string
-}
-const makeConfig = ({ applicationId, publicKey }: MakeConfigOpts) => ({
-  applicationId,
-  publicKey: fromHex(publicKey),
-})
-export interface WebhookConfig extends ReturnType<typeof makeConfig> {}
-export const WebhookConfig = Tag<WebhookConfig>()
-export const makeConfigLayer = flow(makeConfig, Layer.succeed(WebhookConfig))
-
-export class WebhookParseError {
-  readonly _tag = "WebhookParseError"
-  constructor(readonly reason: unknown) {}
-}
-
-const fromHeadersAndBody = (headers: Headers, 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),
-      ),
-    )
-  })
-
-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))
-    })
-}
-
-export interface HandleWebhookOpts<E> {
-  headers: Headers
-  body: string
-  success: (a: Discord.InteractionResponse) => Effect<never, never, void>
-  error: (e: Cause<E>) => Effect<never, never, void>
-  empty: Effect<never, never, void>
-}
-
-export const makeHandler = <R, E>(ix: InteractionBuilder<R, E>) => {
-  const handle = run(ix.definitions)
-
-  return ({
-    headers,
-    body,
-    success,
-    empty,
-    error,
-  }: HandleWebhookOpts<E | WebhookParseError | BadWebhookSignature>) =>
-    handle(headers, body)
-      .flatMap((o) =>
-        o.match(
-          () => empty,
-          (a) => success(a),
-        ),
-      )
-      .catchAllCause(error)
-}

package/src/Log/index.ts

@@ -1,23 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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-gateway.ts

@@ -1,5 +0,0 @@
-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"

package/src/common.ts

@@ -1,30 +0,0 @@
-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 Ix from "dfx/Interactions/index"
-
-export * as Flags from "./Helpers/flags.js"
-export * as IxHelpers from "./Helpers/interactions.js"
-export * as Intents from "./Helpers/intents.js"
-export * as Members from "./Helpers/members.js"
-export * as Perms from "./Helpers/permissions.js"
-export * as UI from "./Helpers/ui.js"