dfx 1.0.5 → 1.0.7

package/dist/src/Interactions/context.ts

@@ -1,104 +0,0 @@
-import * as IxHelpers from "../Helpers/interactions.ts"
-import type * as Discord from "../types.ts"
-import type { NoSuchElementError } from "effect/Cause"
-import * as Data from "effect/Data"
-import * as Effect from "effect/Effect"
-import * as ServiceMap from "effect/ServiceMap"
-
-export class Interaction extends ServiceMap.Service<
-  Interaction,
-  Discord.APIInteraction
->()("dfx/Interactions/Interaction") {}
-export type DiscordInteraction = Interaction
-
-export class ApplicationCommand extends ServiceMap.Service<
-  ApplicationCommand,
-  Discord.APIApplicationCommandInteraction["data"]
->()("dfx/Interactions/ApplicationCommand") {}
-export type DiscordApplicationCommand = ApplicationCommand
-
-export class MessageComponentData extends ServiceMap.Service<
-  MessageComponentData,
-  Discord.APIMessageComponentInteractionData
->()("dfx/Interactions/MessageComponentData") {}
-export type DiscordMessageComponent = MessageComponentData
-
-export class ModalSubmitData extends ServiceMap.Service<
-  ModalSubmitData,
-  Discord.APIModalSubmission
->()("dfx/Interactions/ModalSubmitData") {}
-export type DiscordModalSubmit = ModalSubmitData
-
-export class FocusedOptionContext extends ServiceMap.Service<
-  FocusedOptionContext,
-  Discord.APIApplicationCommandInteractionDataOption
->()("dfx/Interactions/FocusedOptionContext") {}
-export type DiscordFocusedOption = FocusedOptionContext
-
-export interface SubCommandContextData {
-  readonly command: Discord.APIApplicationCommandInteractionDataSubcommandOption
-}
-export class SubCommandContext extends ServiceMap.Service<
-  SubCommandContext,
-  SubCommandContextData
->()("dfx/Interactions/SubCommandContext") {}
-export type DiscordSubCommand = SubCommandContext
-
-export const resolvedValues = <A>(
-  f: (
-    id: Discord.Snowflake,
-    data: Discord.InteractionDataResolved,
-  ) => A | undefined,
-): Effect.Effect<ReadonlyArray<A>, NoSuchElementError, DiscordInteraction> =>
-  Interaction.use(ix => Effect.fromOption(IxHelpers.resolveValues(f)(ix)))
-
-export const resolved = <A>(
-  name: string,
-  f: (
-    id: Discord.Snowflake,
-    data: Discord.InteractionDataResolved,
-  ) => A | undefined,
-): Effect.Effect<A, NoSuchElementError, DiscordInteraction> =>
-  Interaction.use(ix =>
-    Effect.fromOption(IxHelpers.resolveOptionValue(name, f)(ix)),
-  )
-
-export const focusedOptionValue = FocusedOptionContext.use(_ =>
-  Effect.succeed("value" in _ ? _.value : ""),
-)
-
-export class SubCommandNotFound extends Data.TaggedError("SubCommandNotFound")<{
-  data: Discord.APIApplicationCommandInteraction["data"]
-}> {}
-
-export const currentSubCommand: Effect.Effect<
-  Discord.APIApplicationCommandInteractionDataSubcommandOption,
-  never,
-  DiscordSubCommand
-> = SubCommandContext.use(_ => Effect.succeed(_.command))
-
-export class RequiredOptionNotFound {
-  readonly _tag = "RequiredOptionNotFound"
-  constructor(
-    readonly data:
-      | Discord.APIApplicationCommandInteraction["data"]
-      | Discord.APIApplicationCommandSubcommandOption,
-    readonly name: string,
-  ) {}
-}
-
-export const modalValues = ModalSubmitData.use(data =>
-  Effect.succeed(IxHelpers.componentsMap(data)),
-)
-
-export const modalValueOption = (name: string) =>
-  ModalSubmitData.use(data =>
-    Effect.succeed(IxHelpers.componentValue(name)(data)),
-  )
-
-export const modalValue = (
-  name: string,
-): Effect.Effect<string, NoSuchElementError, DiscordModalSubmit> =>
-  ModalSubmitData.use(data =>
-    Effect.fromOption(IxHelpers.componentValue(name)(data)),
-  )

package/dist/src/Interactions/definitions.ts

@@ -1,144 +0,0 @@
-import type * as Effect from "effect/Effect"
-import type {
-  DiscordApplicationCommand,
-  DiscordFocusedOption,
-  DiscordInteraction,
-  DiscordMessageComponent,
-  DiscordModalSubmit,
-} from "./context.ts"
-import type * as Discord from "../types.ts"
-import type { Scope } from "effect/Scope"
-import type { CommandHelper } from "./commandHelper.ts"
-
-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.ApplicationCommandCreateRequest,
-    readonly handle: CommandHandler<R, E>,
-  ) {}
-}
-
-export const global = <
-  R,
-  E,
-  const A extends Discord.ApplicationCommandCreateRequest,
->(
-  command: A,
-  handle: CommandHandler<R, E, A>,
-) =>
-  new GlobalApplicationCommand<
-    Exclude<R, DiscordInteraction | DiscordApplicationCommand | Scope>,
-    E
-  >(command as any, handle as any)
-
-export class GuildApplicationCommand<R, E> {
-  readonly _tag = "GuildApplicationCommand"
-  constructor(
-    readonly command: Discord.ApplicationCommandCreateRequest,
-    readonly handle: CommandHandler<R, E>,
-  ) {}
-}
-
-export const guild = <
-  R,
-  E,
-  const A extends Discord.ApplicationCommandCreateRequest,
->(
-  command: A,
-  handle: CommandHandler<R, E, A>,
-) =>
-  new GuildApplicationCommand<
-    Exclude<R, DiscordInteraction | DiscordApplicationCommand | Scope>,
-    E
-  >(command as any, handle as any)
-
-export class MessageComponent<R, E> {
-  readonly _tag = "MessageComponent"
-  constructor(
-    readonly predicate: (customId: string) => boolean,
-    readonly handle: Effect.Effect<
-      Discord.CreateInteractionResponseRequest,
-      E,
-      R
-    >,
-  ) {}
-}
-
-export const messageComponent = <E, R>(
-  pred: (customId: string) => boolean,
-  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-) =>
-  new MessageComponent<
-    Exclude<R, DiscordInteraction | DiscordMessageComponent | Scope>,
-    E
-  >(pred, handle as any)
-
-export class ModalSubmit<R, E> {
-  readonly _tag = "ModalSubmit"
-  constructor(
-    readonly predicate: (customId: string) => boolean,
-    readonly handle: Effect.Effect<
-      Discord.CreateInteractionResponseRequest,
-      E,
-      R
-    >,
-  ) {}
-}
-
-export const modalSubmit = <R, E>(
-  pred: (customId: string) => boolean,
-  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-) =>
-  new ModalSubmit<
-    Exclude<R, DiscordInteraction | DiscordModalSubmit | Scope>,
-    E
-  >(pred, handle as any)
-
-export class Autocomplete<R, E> {
-  readonly _tag = "Autocomplete"
-  constructor(
-    readonly predicate: (
-      data: Discord.APIApplicationCommandInteraction["data"],
-      focusedOption: Discord.APIApplicationCommandInteractionDataOption,
-    ) => boolean,
-    readonly handle: Effect.Effect<
-      Discord.CreateInteractionResponseRequest,
-      E,
-      R
-    >,
-  ) {}
-}
-
-export const autocomplete = <R, E>(
-  pred: (
-    data: Discord.APIApplicationCommandInteraction["data"],
-    focusedOption: Discord.APIApplicationCommandInteractionDataOption,
-  ) => boolean,
-  handle: Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>,
-) =>
-  new Autocomplete<
-    Exclude<
-      R,
-      | DiscordInteraction
-      | DiscordApplicationCommand
-      | DiscordFocusedOption
-      | Scope
-    >,
-    E
-  >(pred, handle as any)
-
-// ==== Command handler helpers
-export type CommandHandler<R, E, A = any> =
-  | Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>
-  | CommandHandlerFn<R, E, A>
-
-export type CommandHandlerFn<R, E, A> = (
-  i: CommandHelper<A>,
-) => Effect.Effect<Discord.CreateInteractionResponseRequest, E, R>

package/dist/src/Interactions/error.ts

@@ -1,3 +0,0 @@
-export const InteractionsErrorTypeId = Symbol.for(
-  "dfx/Interactions/InteractionsError",
-)

package/dist/src/Interactions/gateway.ts

@@ -1,193 +0,0 @@
-import * as Arr from "effect/Array"
-import * as Chunk from "effect/Chunk"
-import * as Duration from "effect/Duration"
-import * as Effect from "effect/Effect"
-import { pipe } from "effect/Function"
-import * as Layer from "effect/Layer"
-import * as Queue from "effect/Queue"
-import * as Ref from "effect/Ref"
-import * as Schedule from "effect/Schedule"
-import * as ServiceMap from "effect/ServiceMap"
-import { DiscordGateway } from "../DiscordGateway.ts"
-import type { DiscordRESTError } from "../DiscordREST.ts"
-import { DiscordREST } from "../DiscordREST.ts"
-import type { ListMyGuilds200, MyGuildResponse } from "../types.ts"
-import type {
-  GlobalApplicationCommand,
-  GuildApplicationCommand,
-} from "./definitions.ts"
-import type { DefinitionNotFound } from "./handlers.ts"
-import { handlers } from "./handlers.ts"
-import type { DiscordInteraction, InteractionBuilder } from "./index.ts"
-import { builder, Interaction } from "./index.ts"
-import * as EffectUtils from "../utils/Effect.ts"
-
-export const interactionsSync = ServiceMap.Reference("dfx/Interactions/sync", {
-  defaultValue: () => true,
-})
-
-export const setInteractionsSync = (enabled: boolean) =>
-  Layer.provide(Layer.succeed(interactionsSync, enabled))
-
-const retryPolicy = Schedule.exponential("1 seconds").pipe(
-  Schedule.either(Schedule.spaced("20 seconds")),
-)
-
-export const run =
-  <R, R2, E, TE, E2>(
-    postHandler: (
-      effect: Effect.Effect<
-        void,
-        TE | DiscordRESTError | DefinitionNotFound,
-        R | DiscordREST | DiscordInteraction
-      >,
-    ) => Effect.Effect<void, E2, R2>,
-  ) =>
-  (
-    ix: InteractionBuilder<R, E, TE>,
-  ): Effect.Effect<
-    never,
-    E2 | DiscordRESTError,
-    DiscordREST | DiscordGateway | Exclude<R2, DiscordInteraction>
-  > =>
-    Effect.gen(function* () {
-      const GlobalApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GlobalApplicationCommand<R, E> =>
-            _._tag === "GlobalApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-      const GuildApplicationCommand = ix.definitions.pipe(
-        Chunk.map(_ => _[0]),
-        Chunk.filter(
-          (_): _ is GuildApplicationCommand<R, E> =>
-            _._tag === "GuildApplicationCommand",
-        ),
-        Chunk.toReadonlyArray,
-      )
-
-      const gateway = yield* DiscordGateway
-      const rest = yield* DiscordREST
-
-      const application = yield* rest.getMyApplication()
-
-      const globalSync = rest.bulkSetApplicationCommands(
-        application.id,
-        GlobalApplicationCommand.map(_ => _.command),
-      )
-
-      const runGuildSync = Effect.gen(function* () {
-        const commands = GuildApplicationCommand.map(_ => _.command)
-        let results: Arr.NonEmptyReadonlyArray<MyGuildResponse> | undefined =
-          undefined
-        while (true) {
-          const next: ListMyGuilds200 = yield* rest.listMyGuilds({
-            after: results && Arr.lastNonEmpty(results).id,
-          })
-          if (!Arr.isReadonlyArrayNonEmpty(next)) break
-          results = next
-          yield* Effect.forEach(
-            results!,
-            guild =>
-              rest.bulkSetGuildApplicationCommands(
-                application.id,
-                guild.id,
-                commands,
-              ),
-            { concurrency: "unbounded", discard: true },
-          )
-        }
-
-        return yield* gateway.handleDispatch("GUILD_CREATE", a =>
-          rest.bulkSetGuildApplicationCommands(
-            application.id,
-            a.id,
-            GuildApplicationCommand.map(_ => _.command),
-          ),
-        )
-      })
-
-      const guildSync = GuildApplicationCommand.length
-        ? runGuildSync
-        : Effect.never
-
-      const handle = handlers(ix.definitions, (i, r) => {
-        const hasFiles = "files" in r
-        const payload = hasFiles ? { ...r, files: undefined } : r
-        const effect = rest.createInteractionResponse(i.id, i.token, {
-          payload,
-        })
-        return hasFiles ? rest.withFiles(r.files as any)(effect) : effect
-      })
-
-      const interactionRun = gateway.handleDispatch("INTERACTION_CREATE", i =>
-        Effect.withSpan(
-          Effect.provideService(postHandler(handle[i.type](i)), Interaction, i),
-          "dfx.Interaction",
-          { attributes: { interactionId: i.id }, captureStackTrace: false },
-        ),
-      )
-
-      const sync = yield* interactionsSync
-
-      return yield* sync
-        ? Effect.forever(
-            Effect.all([interactionRun, globalSync, guildSync], {
-              concurrency: "unbounded",
-              discard: true,
-            }),
-          )
-        : interactionRun
-    })
-
-const makeRegistry = Effect.gen(function* () {
-  const ref = yield* Ref.make(
-    builder as InteractionBuilder<never, never, never>,
-  )
-  const queue = yield* Queue.sliding<InteractionBuilder<never, never, never>>(1)
-
-  const register = <E>(ix: InteractionBuilder<never, E, never>) =>
-    Effect.flatMap(
-      Ref.updateAndGet(ref, _ => _.concat(ix as any)),
-      _ => Queue.offer(queue, _),
-    )
-
-  yield* EffectUtils.foreverSwitch(Queue.take(queue), ix =>
-    pipe(
-      ix,
-      run(Effect.catchCause(_ => Effect.logError("unhandled error", _))),
-      Effect.delay(Duration.seconds(5)),
-    ),
-  ).pipe(
-    Effect.tapCause(_ => Effect.logError("registry error", _)),
-    Effect.retry(retryPolicy),
-    Effect.forkScoped,
-    Effect.interruptible,
-  )
-
-  return { register } as const
-}).pipe(
-  Effect.annotateLogs({
-    package: "dfx",
-    service: "InteractionsRegistry",
-  }),
-)
-
-export interface InteractionsRegistryService {
-  readonly register: <E>(
-    ix: InteractionBuilder<never, E, never>,
-  ) => Effect.Effect<void>
-}
-
-export class InteractionsRegistry extends ServiceMap.Service<
-  InteractionsRegistry,
-  InteractionsRegistryService
->()("dfx/Interactions/InteractionsRegistry") {}
-
-export const InteractionsRegistryLive: Layer.Layer<
-  InteractionsRegistry,
-  never,
-  DiscordREST | DiscordGateway
-> = Layer.effect(InteractionsRegistry, makeRegistry)

package/dist/src/Interactions/handlers.ts

@@ -1,108 +0,0 @@
-import type * as Chunk from "effect/Chunk"
-import * as Effect from "effect/Effect"
-import * as IxHelpers from "../Helpers/interactions.ts"
-import * as Ctx from "./context.ts"
-import type * as D from "./definitions.ts"
-import { flattenDefinitions, splitDefinitions } from "./utils.ts"
-import * as Discord from "../types.ts"
-import type { Scope } from "effect/Scope"
-
-export class DefinitionNotFound {
-  readonly _tag = "DefinitionNotFound"
-  constructor(readonly interaction: Discord.APIInteraction) {}
-}
-
-type Handler<R, E, A> = Effect.Effect<
-  A,
-  E | DefinitionNotFound,
-  R | Ctx.DiscordInteraction
->
-
-export const handlers = <R, E, TE, A, B>(
-  definitions: Chunk.Chunk<
-    readonly [
-      handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
-    ]
-  >,
-  handleResponse: (
-    ix: Discord.APIInteraction,
-    _: Discord.CreateInteractionResponseRequest,
-  ) => Effect.Effect<A, E, R>,
-): Record<
-  Discord.InteractionTypes,
-  (i: Discord.APIInteraction) => Handler<Exclude<R, Scope>, E, B>
-> => {
-  const flattened = flattenDefinitions(definitions, handleResponse)
-
-  const { Autocomplete, Commands, MessageComponent, ModalSubmit } =
-    splitDefinitions(flattened)
-
-  return {
-    [Discord.InteractionTypes.PING]: _ =>
-      Effect.succeed({
-        type: Discord.InteractionCallbackTypes.PONG,
-      } as any),
-
-    [Discord.InteractionTypes.APPLICATION_COMMAND]: i => {
-      const data =
-        i.data as Discord.APIChatInputApplicationCommandInteractionData
-      const command = Commands[data.name]
-      if (command === undefined) {
-        return Effect.fail(new DefinitionNotFound(i))
-      }
-      return Effect.provideService(
-        command.handle(i),
-        Ctx.ApplicationCommand,
-        data,
-      ) as Handler<Exclude<R, Scope>, E, B>
-    },
-
-    [Discord.InteractionTypes.SOCIAL_LAYER_SKU_PURCHASE_ELIGIBILITY]: i =>
-      Effect.fail(new DefinitionNotFound(i)),
-
-    [Discord.InteractionTypes.MODAL_SUBMIT]: i => {
-      const data = i.data as Discord.APIModalSubmission
-      const match = ModalSubmit.find(_ => _.predicate(data.custom_id))
-      if (match === undefined) {
-        return Effect.fail(new DefinitionNotFound(i))
-      }
-      return Effect.provideService(
-        match.handle(i),
-        Ctx.ModalSubmitData,
-        data,
-      ) as Handler<Exclude<R, Scope>, E, B>
-    },
-
-    [Discord.InteractionTypes.MESSAGE_COMPONENT]: i => {
-      const data = i.data as Discord.APIMessageComponentInteractionData
-      const match = MessageComponent.find(_ => _.predicate(data.custom_id))
-      if (match === undefined) {
-        return Effect.fail(new DefinitionNotFound(i))
-      }
-      return Effect.provideService(
-        match.handle(i),
-        Ctx.MessageComponentData,
-        data,
-      ) as Handler<Exclude<R, Scope>, E, B>
-    },
-
-    [Discord.InteractionTypes.APPLICATION_COMMAND_AUTOCOMPLETE]: i => {
-      const data = i.data as Discord.APIApplicationCommandInteraction["data"]
-      const option = IxHelpers.focusedOption(data as any)
-      if (option._tag === "None") {
-        return Effect.fail(new DefinitionNotFound(i))
-      }
-      const match = Autocomplete.find(_ => _.predicate(data, option.value))
-      if (match === undefined) {
-        return Effect.fail(new DefinitionNotFound(i))
-      }
-      return match
-        .handle(i)
-        .pipe(
-          Effect.provideService(Ctx.ApplicationCommand, data),
-          Effect.provideService(Ctx.FocusedOptionContext, option.value),
-        ) as Handler<Exclude<R, Scope>, E, B>
-    },
-  }
-}

package/dist/src/Interactions/index.ts

@@ -1,30 +0,0 @@
-export { response } from "../Helpers/interactions.ts"
-export * from "./builder.ts"
-export * from "./context.ts"
-export type { InteractionDefinition } from "./definitions.ts"
-export {
-  autocomplete,
-  global,
-  guild,
-  messageComponent,
-  modalSubmit,
-} from "./definitions.ts"
-
-// Filters
-export const id = (query: string) => (customId: string) => query === customId
-
-export const idStartsWith = (query: string) => (customId: string) =>
-  customId.startsWith(query)
-
-export const idRegex = (query: RegExp) => (customId: string) =>
-  query.test(customId)
-
-export const option =
-  (command: string, optionName: string) =>
-  (data: { readonly name: string }, focusedOption: { readonly name: string }) =>
-    data.name === command && focusedOption.name === optionName
-
-export const optionOnly =
-  (optionName: string) =>
-  (_: unknown, focusedOption: { readonly name: string }) =>
-    focusedOption.name === optionName

package/dist/src/Interactions/utils.ts

@@ -1,93 +0,0 @@
-import * as Chunk from "effect/Chunk"
-import * as Effect from "effect/Effect"
-import type * as D from "./definitions.ts"
-import type * as Discord from "../types.ts"
-import * as Array from "effect/Array"
-import { CommandHelper } from "./commandHelper.ts"
-
-export type DefinitionFlattened<R, E, TE, A> =
-  D.InteractionDefinition<R, E> extends infer Def
-    ? {
-        [K in keyof Def]: K extends "handle"
-          ? (_: Discord.APIInteraction) => Effect.Effect<A, TE, R>
-          : Def[K]
-      }
-    : never
-
-export type DefinitionFlattenedCommand<R, E, TE, A> = Extract<
-  DefinitionFlattened<R, E, TE, A>,
-  { _tag: "GlobalApplicationCommand" | "GuildApplicationCommand" }
->
-
-export const flattenDefinitions = <R, E, TE, A, B>(
-  definitions: Chunk.Chunk<
-    readonly [
-      handler: D.InteractionDefinition<R, E>,
-      transform: (self: Effect.Effect<A, E, R>) => Effect.Effect<B, TE, R>,
-    ]
-  >,
-  handleResponse: (
-    ix: Discord.APIInteraction,
-    _: Discord.CreateInteractionResponseRequest,
-  ) => Effect.Effect<A, E, R>,
-) =>
-  Array.map(Chunk.toReadonlyArray(definitions), ([definition, transform]) => ({
-    ...definition,
-    handle: Effect.isEffect(definition.handle)
-      ? (i: Discord.APIInteraction) =>
-          Effect.scoped(
-            transform(
-              Effect.flatMap(
-                definition.handle as Effect.Effect<Discord.CreateInteractionResponseRequest>,
-                _ => handleResponse(i, _),
-              ),
-            ),
-          )
-      : (i: Discord.APIInteraction) =>
-          Effect.scoped(
-            transform(
-              Effect.flatMap(
-                (
-                  definition.handle as (
-                    _: any,
-                  ) => Effect.Effect<Discord.CreateInteractionResponseRequest>
-                )(new CommandHelper(i)),
-                _ => handleResponse(i, _),
-              ),
-            ),
-          ),
-  }))
-
-export const splitDefinitions = <R, E, TE, A>(
-  definitions: ReadonlyArray<DefinitionFlattened<R, E, TE, A>>,
-) => {
-  const grouped = Array.reduce(
-    definitions,
-    {
-      Autocomplete: [],
-      GlobalApplicationCommand: [],
-      GuildApplicationCommand: [],
-      MessageComponent: [],
-      ModalSubmit: [],
-      Commands: {},
-    } as {
-      [K in D.InteractionDefinition<R, E>["_tag"]]: Array<
-        Extract<DefinitionFlattened<R, E, TE, A>, { _tag: K }>
-      >
-    } & {
-      readonly Commands: Record<string, DefinitionFlattenedCommand<R, E, TE, A>>
-    },
-    (acc, d) => {
-      acc[d._tag].push(d as any)
-      if (
-        d._tag === "GlobalApplicationCommand" ||
-        d._tag === "GuildApplicationCommand"
-      ) {
-        acc.Commands[d.command.name] = d as any
-      }
-      return acc
-    },
-  )
-
-  return grouped
-}