@dereekb/discord 13.33.0

package/nestjs/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@dereekb/discord/nestjs",
+  "version": "13.33.0",
+  "peerDependencies": {
+    "@dereekb/discord": "13.33.0",
+    "@dereekb/nestjs": "13.33.0",
+    "@dereekb/rxjs": "13.33.0",
+    "@dereekb/util": "13.33.0",
+    "@nestjs/common": "^11.1.19",
+    "@nestjs/config": "^4.0.4",
+    "discord.js": "^14.26.3",
+    "express": "^5.2.1"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/nestjs/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';

package/nestjs/src/lib/discord/discord.api.d.ts

@@ -0,0 +1,69 @@
+import { Client, type Message } from 'discord.js';
+import { type OnModuleDestroy, type OnModuleInit } from '@nestjs/common';
+import { DiscordServiceConfig } from './discord.config';
+import { type DiscordChannelId } from '@dereekb/discord';
+/**
+ * Injectable service that wraps the discord.js Client for bot operations.
+ *
+ * Automatically logs in on module init and destroys the client on module destroy
+ * when autoLogin is enabled (default).
+ */
+export declare class DiscordApi implements OnModuleInit, OnModuleDestroy {
+    readonly config: DiscordServiceConfig;
+    private readonly logger;
+    /**
+     * The underlying discord.js Client instance.
+     */
+    readonly client: Client;
+    constructor(config: DiscordServiceConfig);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Sends a text message to a Discord channel.
+     *
+     * @param channelId - target channel's snowflake ID
+     * @param content - message text to send
+     *
+     * @throws {Error} When the channel is not found or is not a text channel.
+     *
+     * @example
+     * ```ts
+     * const message = await discordApi.sendMessage('123456789', 'Hello from the bot!');
+     * ```
+     */
+    /**
+     * Sends a text message to the specified Discord channel.
+     *
+     * @param channelId - Target channel's snowflake ID.
+     * @param content - Message text to send.
+     * @returns The sent Discord Message.
+     * @throws {Error} When the channel is not found or is not a text channel.
+     */
+    sendMessage(channelId: DiscordChannelId, content: string): Promise<Message>;
+    /**
+     * Registers a handler for the MessageCreate event (incoming messages).
+     *
+     * Returns an unsubscribe function to remove the handler.
+     *
+     * @param handler - callback invoked for each incoming message
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = discordApi.onMessage((message) => {
+     *   if (!message.author.bot) {
+     *     console.log(`${message.author.tag}: ${message.content}`);
+     *   }
+     * });
+     *
+     * // Later, to stop listening:
+     * unsubscribe();
+     * ```
+     */
+    /**
+     * Registers a handler for incoming Discord messages (MessageCreate event).
+     *
+     * @param handler - Callback invoked for each incoming Message.
+     * @returns An unsubscribe function that removes the registered handler.
+     */
+    onMessage(handler: (message: Message) => void): () => void;
+}

package/nestjs/src/lib/discord/discord.api.spec.client.d.ts

@@ -0,0 +1,20 @@
+import { DiscordApi } from './discord.api';
+/**
+ * Shared, process-singleton Discord test client.
+ *
+ * Integration spec files import {@link getSharedDiscordTestClient} so that at most one
+ * `client.login()` call occurs per vitest worker process, regardless of how many spec
+ * files participate. This keeps the bot's daily gateway-session quota intact during
+ * normal development.
+ */
+export interface SharedDiscordTestClient {
+    readonly discordApi: DiscordApi;
+    readonly testChannelId: string;
+}
+/**
+ * Returns the shared logged-in test client, creating it on first call and reusing it
+ * on subsequent calls within the same process.
+ *
+ * @returns The cached {@link SharedDiscordTestClient}.
+ */
+export declare function getSharedDiscordTestClient(): Promise<SharedDiscordTestClient>;

package/nestjs/src/lib/discord/discord.config.d.ts

@@ -0,0 +1,58 @@
+import { type Maybe } from '@dereekb/util';
+import { type ClientOptions, GatewayIntentBits } from 'discord.js';
+import { type DiscordBotToken } from '@dereekb/discord';
+/**
+ * Default environment variable for the Discord bot token.
+ */
+export declare const DISCORD_BOT_TOKEN_ENV_VAR = "DISCORD_BOT_TOKEN";
+/**
+ * Placeholder bot token value used in development and CI environments where a real Discord
+ * login should not be attempted. Mirrors the value used in the workspace's .env file.
+ */
+export declare const DISCORD_BOT_TOKEN_PLACEHOLDER = "placeholder";
+/**
+ * Returns true if the input is a real, usable Discord bot token.
+ *
+ * A token is usable when it is non-empty and is not the shared placeholder value, allowing
+ * non-production environments to skip a real gateway login that would always fail.
+ *
+ * @param botToken - The bot token read from configuration, if any.
+ * @returns True when the token should be used to log in.
+ *
+ * @example
+ * ```ts
+ * isUsableDiscordBotToken('placeholder'); // false
+ * isUsableDiscordBotToken('real-token');  // true
+ * ```
+ */
+export declare function isUsableDiscordBotToken(botToken: Maybe<DiscordBotToken>): boolean;
+/**
+ * Default gateway intents for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent.
+ * Note: MessageContent is a privileged intent and must be enabled in the Discord Developer Portal.
+ */
+export declare const DEFAULT_DISCORD_INTENTS: GatewayIntentBits[];
+export interface DiscordServiceApiConfig {
+    /**
+     * The bot token used to authenticate with the Discord gateway.
+     */
+    readonly botToken: DiscordBotToken;
+    /**
+     * discord.js Client options. Intents default to DEFAULT_DISCORD_INTENTS if not provided.
+     */
+    readonly clientOptions?: Partial<ClientOptions>;
+    /**
+     * Whether to automatically call client.login() during module initialization.
+     *
+     * Defaults to true.
+     */
+    readonly autoLogin?: boolean;
+}
+/**
+ * Configuration for the DiscordApi service.
+ */
+export declare abstract class DiscordServiceConfig {
+    readonly discord: DiscordServiceApiConfig;
+    static assertValidConfig(config: DiscordServiceConfig): void;
+}

package/nestjs/src/lib/discord/discord.module.d.ts

@@ -0,0 +1,20 @@
+import { ConfigService } from '@nestjs/config';
+import { DiscordServiceConfig } from './discord.config';
+/**
+ * Factory that creates a DiscordServiceConfig from environment variables.
+ *
+ * autoLogin is enabled only when a real bot token is configured and the process is not running
+ * under a test environment, so development and CI runs (which use a placeholder token) never
+ * attempt a real gateway login that would fail.
+ *
+ * @param configService - The NestJS config service used to read Discord environment variables.
+ * @returns A validated DiscordServiceConfig populated from environment variables.
+ */
+export declare function discordServiceConfigFactory(configService: ConfigService): DiscordServiceConfig;
+/**
+ * NestJS module that provides the DiscordApi service.
+ *
+ * Reads the bot token from the DISCORD_BOT_TOKEN environment variable.
+ */
+export declare class DiscordModule {
+}

package/nestjs/src/lib/discord/discord.util.d.ts

@@ -0,0 +1,28 @@
+import { type GatewayIntentBits, type ClientOptions } from 'discord.js';
+/**
+ * Returns default ClientOptions for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent intents.
+ *
+ * @returns Partial ClientOptions with the default bot intents set.
+ *
+ * @example
+ * ```ts
+ * const options = discordDefaultClientOptions();
+ * // options.intents === [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
+ * ```
+ */
+export declare function discordDefaultClientOptions(): Partial<ClientOptions>;
+/**
+ * Returns ClientOptions with additional intents merged with the defaults.
+ *
+ * @param additionalIntents - Extra intents to include beyond the defaults.
+ * @returns Partial ClientOptions with the merged intent list.
+ *
+ * @example
+ * ```ts
+ * const options = discordClientOptionsWithIntents([GatewayIntentBits.DirectMessages]);
+ * // options.intents includes Guilds, GuildMessages, MessageContent, and DirectMessages
+ * ```
+ */
+export declare function discordClientOptionsWithIntents(additionalIntents: GatewayIntentBits[]): Partial<ClientOptions>;

package/nestjs/src/lib/discord/index.d.ts

@@ -0,0 +1,4 @@
+export * from './discord.api';
+export * from './discord.config';
+export * from './discord.module';
+export * from './discord.util';

package/nestjs/src/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './discord';
+export * from './oauth';
+export * from './webhook';

package/nestjs/src/lib/oauth/index.d.ts

@@ -0,0 +1,3 @@
+export * from './oauth.api';
+export * from './oauth.config';
+export * from './oauth.module';

package/nestjs/src/lib/oauth/oauth.api.d.ts

@@ -0,0 +1,74 @@
+import { type DiscordAccessToken, type DiscordOAuth, type DiscordOAuthAuthorizeUrlFactory, type DiscordOAuthAuthorizeUrlFactoryConfig, type DiscordOAuthClientId, type DiscordOAuthContext, type DiscordOAuthExchangeAuthorizationCodeInput, type DiscordOAuthRefreshTokenInput } from '@dereekb/discord';
+import { DiscordOAuthServiceConfig } from './oauth.config';
+/**
+ * Provides the app's configured Discord OAuth client.
+ *
+ * Deliberately thinner than `CalcomOAuthApi`, which owns an access-token cache service and memoizes a
+ * token factory per user. Discord needs neither: the external-connection framework persists each
+ * user's credentials itself, so this api holds one client authenticated with the *application's*
+ * credentials and hands out the three calls that run through it.
+ *
+ * Note this is not the bot. The app acting as itself against Discord goes through `DiscordApi` and
+ * discord.js with a bot token; that token never reaches this client.
+ */
+export declare class DiscordOAuthApi {
+    readonly config: DiscordOAuthServiceConfig;
+    readonly discordOAuth: DiscordOAuth;
+    get oauthContext(): DiscordOAuthContext;
+    /**
+     * The OAuth client id the api authorizes as. Read from the context so there is a single source.
+     *
+     * @returns The configured Discord OAuth client id.
+     */
+    get clientId(): DiscordOAuthClientId;
+    constructor(config: DiscordOAuthServiceConfig);
+    /**
+     * Configured pass-through for {@link exchangeAuthorizationCode}.
+     *
+     * @returns Function to exchange an OAuth authorization code for tokens.
+     */
+    get exchangeAuthorizationCode(): (input: DiscordOAuthExchangeAuthorizationCodeInput) => Promise<import("@dereekb/discord").DiscordOAuthTokenResponse>;
+    /**
+     * Configured pass-through for {@link refreshAccessToken}.
+     *
+     * @returns Function to refresh an access token using a stored refresh token.
+     */
+    get refreshAccessToken(): (input: DiscordOAuthRefreshTokenInput) => Promise<import("@dereekb/discord").DiscordOAuthTokenResponse>;
+    /**
+     * Configured pass-through for {@link readCurrentUser}.
+     *
+     * Bearer-authenticated with the user's own access token, unlike the two token-endpoint calls above,
+     * which authenticate with the application's Basic credentials.
+     *
+     * @returns Function to read the Discord user an access token belongs to.
+     */
+    get readCurrentUser(): (input: import("@dereekb/discord").DiscordOAuthReadCurrentUserInput) => Promise<import("@dereekb/discord").DiscordOAuthCurrentUser>;
+    /**
+     * Builds a {@link DiscordOAuthAuthorizeUrlFactory} for the app's client id.
+     *
+     * The redirect URI and scopes stay the caller's, since they are properties of the flow being
+     * mounted rather than of the client, but the client id comes from this api so a caller never has to
+     * read it out of the config itself.
+     *
+     * @param config - The redirect URI, requested scopes, and optional authorize URL override.
+     * @returns A factory composing the authorize URL to redirect a user's browser to.
+     */
+    authorizeUrlFactory(config: Omit<DiscordOAuthAuthorizeUrlFactoryConfig, 'clientId'>): DiscordOAuthAuthorizeUrlFactory;
+    /**
+     * Exchanges an OAuth authorization code and maps the response to a {@link DiscordAccessToken}.
+     *
+     * @param input - The authorization code and the exact redirect URI it was issued for.
+     * @returns The exchanged access token.
+     */
+    exchangeAuthorizationCodeToAccessToken(input: DiscordOAuthExchangeAuthorizationCodeInput): Promise<DiscordAccessToken>;
+    /**
+     * Refreshes an access token and maps the response to a {@link DiscordAccessToken}.
+     *
+     * The returned `refreshToken` is the one to persist: Discord's refresh responses carry a refresh
+     * token of their own, so storing whatever came back is correct whether or not it rotated.
+     *
+     * @param input - The stored refresh token.
+     * @returns The refreshed access token.
+     */
+    refreshToAccessToken(input: DiscordOAuthRefreshTokenInput): Promise<DiscordAccessToken>;
+}

package/nestjs/src/lib/oauth/oauth.config.d.ts

@@ -0,0 +1,55 @@
+import { type DiscordOAuthClientId, type DiscordOAuthClientSecret, type DiscordOAuthConfig, type DiscordOAuthFactoryConfig } from '@dereekb/discord';
+import { type ConfigService } from '@nestjs/config';
+export declare const DISCORD_SERVICE_NAME = "discord";
+export declare const DISCORD_CLIENT_ID_CONFIG_KEY = "DISCORD_CLIENT_ID";
+export declare const DISCORD_CLIENT_SECRET_CONFIG_KEY = "DISCORD_CLIENT_SECRET";
+/**
+ * The environment-facing shape of the Discord OAuth client credentials.
+ *
+ * Both values are optional here, mirroring the `DISCORD_*` variables they are read from, so a missing
+ * variable is reported by {@link DiscordOAuthServiceConfig.assertValidConfig} rather than surfacing as
+ * `undefined` further down.
+ */
+export interface DiscordOAuthServiceApiConfig {
+    readonly clientId?: DiscordOAuthClientId;
+    readonly clientSecret?: DiscordOAuthClientSecret;
+}
+/**
+ * Configuration for the {@link DiscordOAuthApi}.
+ *
+ * Carries no server-level token or access-token cache, unlike `CalcomOAuthServiceConfig`: Discord has
+ * no api-key alternative to the client-credentials pair, and the app acting as *itself* against
+ * Discord authenticates with a bot token through `DiscordServiceConfig` and discord.js instead. This
+ * config only ever describes the OAuth client that performs the per-user authorization-code handoff.
+ */
+export declare abstract class DiscordOAuthServiceConfig {
+    readonly discordOAuth: DiscordOAuthServiceApiConfig;
+    /**
+     * Optional configuration for the Discord OAuth client the api builds — a custom fetch handler or
+     * error logger.
+     */
+    readonly factoryConfig?: DiscordOAuthFactoryConfig;
+    static assertValidConfig(config: DiscordOAuthServiceConfig): void;
+    /**
+     * Narrows the environment-facing config to the fully-populated {@link DiscordOAuthConfig} the core
+     * factory requires, asserting both credentials are present.
+     *
+     * @param config - The service configuration to read.
+     * @returns The validated OAuth client configuration.
+     * @throws {Error} When either client credential is missing.
+     */
+    static assertedDiscordOAuthConfig(config: DiscordOAuthServiceConfig): DiscordOAuthConfig;
+}
+/**
+ * Factory function that creates a {@link DiscordOAuthServiceConfig} from NestJS ConfigService
+ * environment variables.
+ *
+ * Fails at startup rather than at the consent screen: a missing client id otherwise composes an
+ * authorize URL carrying `client_id=undefined`, and a missing secret fails the exchange only after the
+ * user has already consented.
+ *
+ * @param configService - The NestJS ConfigService instance.
+ * @returns A validated DiscordOAuthServiceConfig.
+ * @throws {Error} When either client credential is missing.
+ */
+export declare function discordOAuthServiceConfigFactory(configService: ConfigService): DiscordOAuthServiceConfig;

package/nestjs/src/lib/oauth/oauth.module.d.ts

@@ -0,0 +1,22 @@
+import { type ModuleMetadata } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { DiscordOAuthServiceConfig } from './oauth.config';
+export type DiscordOAuthServiceConfigFactory = (configService: ConfigService) => DiscordOAuthServiceConfig;
+export interface ProvideAppDiscordOAuthMetadataConfig extends Pick<ModuleMetadata, 'imports' | 'exports' | 'providers'> {
+    /**
+     * Optional override for the DiscordOAuthServiceConfigFactory.
+     *
+     * @default discordOAuthServiceConfigFactory
+     */
+    readonly discordOAuthServiceConfigFactory?: DiscordOAuthServiceConfigFactory;
+}
+/**
+ * Convenience function used to generate ModuleMetadata for an app's DiscordOAuthModule.
+ *
+ * Takes no `dependencyModule`, unlike the Cal.com equivalent: {@link DiscordOAuthApi} depends only on
+ * its own config, since Discord's connect flow needs no access-token cache service.
+ *
+ * @param config - The module metadata configuration including an optional config factory.
+ * @returns NestJS ModuleMetadata for registering the DiscordOAuthModule.
+ */
+export declare function appDiscordOAuthModuleMetadata(config: ProvideAppDiscordOAuthMetadataConfig): ModuleMetadata;

package/nestjs/src/lib/webhook/index.d.ts

@@ -0,0 +1,6 @@
+export * from './webhook.discord';
+export * from './webhook.discord.config';
+export * from './webhook.discord.controller';
+export * from './webhook.discord.module';
+export * from './webhook.discord.service';
+export * from './webhook.discord.verify';

package/nestjs/src/lib/webhook/webhook.discord.config.d.ts

@@ -0,0 +1,22 @@
+import { type DiscordPublicKey } from '@dereekb/discord';
+/**
+ * Default environment variable for the Discord application public key.
+ */
+export declare const DISCORD_PUBLIC_KEY_ENV_VAR = "DISCORD_PUBLIC_KEY";
+/**
+ * The byte length of a Discord Ed25519 public key (32 bytes = 64 hex characters).
+ */
+export declare const DISCORD_ED25519_PUBLIC_KEY_BYTE_LENGTH = 32;
+export interface DiscordWebhookConfig {
+    /**
+     * The Ed25519 public key used to verify incoming interaction webhook signatures.
+     */
+    readonly publicKey: DiscordPublicKey;
+}
+/**
+ * Configuration for the DiscordWebhookService.
+ */
+export declare abstract class DiscordWebhookServiceConfig {
+    readonly discordWebhook: DiscordWebhookConfig;
+    static assertValidConfig(config: DiscordWebhookServiceConfig): void;
+}

package/nestjs/src/lib/webhook/webhook.discord.controller.d.ts

@@ -0,0 +1,8 @@
+import { type RawBodyBuffer } from '@dereekb/nestjs';
+import { type Request } from 'express';
+import { DiscordWebhookService } from './webhook.discord.service';
+export declare class DiscordWebhookController {
+    private readonly _discordWebhookService;
+    constructor(discordWebhookService: DiscordWebhookService);
+    handleDiscordWebhook(req: Request, rawBody: RawBodyBuffer): Promise<void>;
+}

package/nestjs/src/lib/webhook/webhook.discord.d.ts

@@ -0,0 +1,59 @@
+import { type HandlerBindAccessor, type HandlerMappedSetFunction, type Handler } from '@dereekb/util';
+import { InteractionType, type Interaction } from 'discord.js';
+/**
+ * Discord interaction type numeric key, used for handler dispatch.
+ */
+export type DiscordInteractionType = InteractionType;
+/**
+ * An untyped Discord interaction received via webhook.
+ */
+export type UntypedDiscordInteraction = Interaction;
+/**
+ * A typed Discord interaction, narrowed from the base Interaction type.
+ *
+ * @example
+ * ```ts
+ * const interaction: DiscordWebhookInteraction<ChatInputCommandInteraction> = discordWebhookInteraction(rawInteraction);
+ * ```
+ */
+export type DiscordWebhookInteraction<T extends Interaction = Interaction> = T;
+/**
+ * Casts an untyped Discord interaction to a typed one.
+ *
+ * @param interaction - The raw interaction to cast.
+ * @returns The interaction cast to the specified typed DiscordWebhookInteraction.
+ */
+export declare function discordWebhookInteraction<T extends Interaction = Interaction>(interaction: UntypedDiscordInteraction): DiscordWebhookInteraction<T>;
+export type DiscordInteractionHandler = Handler<UntypedDiscordInteraction, DiscordInteractionType>;
+export declare const discordInteractionHandlerFactory: import("@dereekb/util").HandlerFactory<UntypedDiscordInteraction, InteractionType, boolean>;
+export type DiscordHandlerMappedSetFunction<T extends Interaction = Interaction> = HandlerMappedSetFunction<DiscordWebhookInteraction<T>>;
+/**
+ * Configurer for Discord interaction handlers.
+ *
+ * Handlers are keyed on InteractionType. Use discord.js type guards
+ * (e.g., interaction.isChatInputCommand(), interaction.isButton()) within
+ * your handler callback for sub-type refinement.
+ */
+export interface DiscordInteractionHandlerConfigurer extends HandlerBindAccessor<UntypedDiscordInteraction, DiscordInteractionType> {
+    /**
+     * Handles application commands (slash commands + context menu commands).
+     *
+     * Use interaction.isChatInputCommand() or interaction.isContextMenuCommand() to narrow the type within your handler.
+     */
+    readonly handleApplicationCommand: DiscordHandlerMappedSetFunction;
+    /**
+     * Handles message component interactions (buttons + select menus).
+     *
+     * Use interaction.isButton() or interaction.isStringSelectMenu() to narrow the type within your handler.
+     */
+    readonly handleMessageComponent: DiscordHandlerMappedSetFunction;
+    /**
+     * Handles modal submit interactions.
+     */
+    readonly handleModalSubmit: DiscordHandlerMappedSetFunction;
+    /**
+     * Handles autocomplete interactions for slash command options.
+     */
+    readonly handleAutocomplete: DiscordHandlerMappedSetFunction;
+}
+export declare const discordInteractionHandlerConfigurerFactory: import("@dereekb/util").HandlerConfigurerFactory<DiscordInteractionHandlerConfigurer, UntypedDiscordInteraction, InteractionType, boolean>;

package/nestjs/src/lib/webhook/webhook.discord.module.d.ts

@@ -0,0 +1,17 @@
+import { ConfigService } from '@nestjs/config';
+import { DiscordWebhookServiceConfig } from './webhook.discord.config';
+/**
+ * Factory that creates a DiscordWebhookServiceConfig from environment variables.
+ *
+ * @param configService - The NestJS config service used to read the Discord public key environment variable.
+ * @returns A validated DiscordWebhookServiceConfig populated from environment variables.
+ */
+export declare function discordWebhookServiceConfigFactory(configService: ConfigService): DiscordWebhookServiceConfig;
+/**
+ * NestJS module that provides Discord interaction webhook handling.
+ *
+ * Standalone — does not depend on DiscordModule (no bot token needed).
+ * Reads the application public key from the DISCORD_PUBLIC_KEY environment variable.
+ */
+export declare class DiscordWebhookModule {
+}

package/nestjs/src/lib/webhook/webhook.discord.service.d.ts

@@ -0,0 +1,18 @@
+import { type Request } from 'express';
+import { type DiscordInteractionType, type UntypedDiscordInteraction } from './webhook.discord';
+import { type Handler } from '@dereekb/util';
+import { DiscordWebhookServiceConfig } from './webhook.discord.config';
+/**
+ * Service that handles Discord interaction webhook events.
+ *
+ * Verifies incoming webhook signatures and dispatches interactions to registered handlers.
+ */
+export declare class DiscordWebhookService {
+    private readonly logger;
+    private readonly _verifier;
+    readonly handler: Handler<UntypedDiscordInteraction, DiscordInteractionType>;
+    readonly configure: import("@dereekb/util").HandlerConfigurer<import("./webhook.discord").DiscordInteractionHandlerConfigurer, UntypedDiscordInteraction, import("discord.js").InteractionType, boolean>;
+    constructor(discordWebhookServiceConfig: DiscordWebhookServiceConfig);
+    updateForWebhook(req: Request, rawBody: Buffer): Promise<void>;
+    updateForDiscordInteraction(interaction: UntypedDiscordInteraction): Promise<void>;
+}

package/nestjs/src/lib/webhook/webhook.discord.verify.d.ts

@@ -0,0 +1,46 @@
+import { type Request } from 'express';
+import { type DiscordPublicKey } from '@dereekb/discord';
+export interface DiscordWebhookEventVerificationConfig {
+    /**
+     * The Ed25519 public key from the Discord Developer Portal.
+     */
+    readonly publicKey: DiscordPublicKey;
+}
+export type DiscordWebhookEventVerificationResult = DiscordWebhookEventVerificationSuccessResult | DiscordWebhookEventVerificationErrorResult;
+export interface DiscordWebhookEventVerificationSuccessResult {
+    readonly valid: true;
+    /**
+     * The parsed JSON body of the verified interaction.
+     */
+    readonly body: unknown;
+}
+export interface DiscordWebhookEventVerificationErrorResult {
+    readonly valid: false;
+}
+/**
+ * Function that verifies a Discord interaction webhook request using Ed25519 signatures.
+ */
+export type DiscordWebhookEventVerifier = (req: Request, rawBody: Buffer) => Promise<DiscordWebhookEventVerificationResult>;
+/**
+ * Creates a verifier for Discord interaction webhook requests.
+ *
+ * Discord signs interaction webhook requests with Ed25519. The signed message is
+ * the concatenation of the x-signature-timestamp header and the raw request body.
+ * The signature is provided in the x-signature-ed25519 header as a hex string.
+ *
+ * Uses Node.js built-in crypto with JWK key import — no external dependencies required.
+ *
+ * @param config - Verification config containing the application's public key.
+ * @returns A DiscordWebhookEventVerifier function that validates Ed25519-signed requests.
+ *
+ * @example
+ * ```ts
+ * const verifier = discordWebhookEventVerifier({ publicKey: 'your-hex-public-key' });
+ * const result = await verifier(req, rawBody);
+ *
+ * if (result.valid) {
+ *   // result.body contains the parsed interaction
+ * }
+ * ```
+ */
+export declare function discordWebhookEventVerifier(config: DiscordWebhookEventVerificationConfig): DiscordWebhookEventVerifier;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@dereekb/discord",
+  "version": "13.33.0",
+  "sideEffects": false,
+  "exports": {
+    "./nestjs": {
+      "module": "./nestjs/index.esm.js",
+      "types": "./nestjs/index.d.ts",
+      "import": "./nestjs/index.cjs.mjs",
+      "default": "./nestjs/index.cjs.js"
+    },
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "peerDependencies": {
+    "@dereekb/nestjs": "13.33.0",
+    "@dereekb/rxjs": "13.33.0",
+    "@dereekb/util": "13.33.0",
+    "@nestjs/common": "^11.1.19",
+    "@nestjs/config": "^4.0.4",
+    "discord.js": "^14.26.3",
+    "express": "^5.2.1",
+    "make-error": "^1.3.6"
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib';