dfx 0.9.7 → 0.9.9

package/src/Interactions/definitions.ts

@@ -1,144 +0,0 @@
-export type InteractionResponse =
-  | {
-      type: Discord.InteractionCallbackType.CHANNEL_MESSAGE_WITH_SOURCE
-      data: Discord.InteractionCallbackMessage
-    }
-  | {
-      type: Discord.InteractionCallbackType.UPDATE_MESSAGE
-      data: Discord.InteractionCallbackMessage
-    }
-  | {
-      type: Discord.InteractionCallbackType.MODAL
-      data: Discord.InteractionCallbackModal
-    }
-  | {
-      type: Discord.InteractionCallbackType.DEFERRED_UPDATE_MESSAGE
-    }
-  | {
-      type: Discord.InteractionCallbackType.DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE
-    }
-  | {
-      type: Discord.InteractionCallbackType.APPLICATION_COMMAND_AUTOCOMPLETE_RESULT
-      data: Discord.InteractionCallbackAutocomplete
-    }
-
-type DescriptionMissing<A> = A extends {
-  type: Exclude<Discord.ApplicationCommandType, 1>
-}
-  ? false
-  : A extends { description: string }
-  ? false
-  : true
-
-export type InteractionDefinition<R, E> =
-  | GlobalApplicationCommand<R, E>
-  | GuildApplicationCommand<R, E>
-  | MessageComponent<R, E>
-  | ModalSubmit<R, E>
-  | Autocomplete<R, E>
-
-export class GlobalApplicationCommand<R, E> {
-  readonly _tag = "GlobalApplicationCommand"
-  constructor(
-    readonly command: Discord.CreateGlobalApplicationCommandParams,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const global = <
-  R,
-  E,
-  A extends Discord.CreateGlobalApplicationCommandParams,
->(
-  command: A,
-  handle: DescriptionMissing<A> extends true
-    ? "command description is missing"
-    : Effect<R, E, Maybe<InteractionResponse>>,
-) =>
-  new GlobalApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
-    E
-  >(command, handle as any)
-
-export class GuildApplicationCommand<R, E> {
-  readonly _tag = "GuildApplicationCommand"
-  constructor(
-    readonly command: Discord.CreateGuildApplicationCommandParams,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const guild = <
-  R,
-  E,
-  A extends Discord.CreateGuildApplicationCommandParams,
->(
-  command: A,
-  handle: DescriptionMissing<A> extends true
-    ? "command description is missing"
-    : Effect<R, E, Maybe<InteractionResponse>>,
-) =>
-  new GuildApplicationCommand<
-    Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>,
-    E
-  >(command, handle as any)
-
-export class MessageComponent<R, E> {
-  readonly _tag = "MessageComponent"
-  constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const messageComponent = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new MessageComponent<
-    Exclude<R1 | R2, Discord.Interaction | Discord.MessageComponentDatum>,
-    E1 | E2
-  >(pred as any, handle as any)
-
-export class ModalSubmit<R, E> {
-  readonly _tag = "ModalSubmit"
-  constructor(
-    readonly predicate: (customId: string) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const modalSubmit = <R1, R2, E1, E2>(
-  pred: (customId: string) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new ModalSubmit<
-    Exclude<R1 | R2, Discord.Interaction | Discord.ModalSubmitDatum>,
-    E1 | E2
-  >(pred as any, handle as any)
-
-export class Autocomplete<R, E> {
-  readonly _tag = "Autocomplete"
-  constructor(
-    readonly predicate: (
-      focusedOption: Discord.ApplicationCommandInteractionDataOption,
-    ) => Effect<R, E, boolean>,
-    readonly handle: Effect<R, E, Maybe<InteractionResponse>>,
-  ) {}
-}
-
-export const autocomplete = <R1, R2, E1, E2>(
-  pred: (
-    focusedOption: Discord.ApplicationCommandInteractionDataOption,
-  ) => Effect<R1, E1, boolean>,
-  handle: Effect<R2, E2, Maybe<InteractionResponse>>,
-) =>
-  new Autocomplete<
-    Exclude<
-      R1 | R2,
-      | Discord.Interaction
-      | Discord.ApplicationCommandDatum
-      | Discord.ApplicationCommandInteractionDataOption
-    >,
-    E1 | E2
-  >(pred as any, handle as any)

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)