@dereekb/nestjs 13.1.0 → 13.2.1

package/discord/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/discord/index.cjs.js

@@ -0,0 +1,491 @@
+'use strict';
+
+var util = require('@dereekb/util');
+var discord_js = require('discord.js');
+var nestjs = require('@dereekb/nestjs');
+var common = require('@nestjs/common');
+var crypto = require('crypto');
+var config = require('@nestjs/config');
+var fetch = require('@dereekb/util/fetch');
+
+/**
+ * Casts an untyped Discord interaction to a typed one.
+ *
+ * @param interaction - the raw interaction to cast
+ */
+function discordWebhookInteraction(interaction) {
+    return interaction;
+}
+const discordInteractionHandlerFactory = util.handlerFactory((x) => x.type);
+const discordInteractionHandlerConfigurerFactory = util.handlerConfigurerFactory({
+    configurerForAccessor: (accessor) => {
+        // eslint-disable-next-line
+        const fnWithKey = util.handlerMappedSetFunctionFactory(accessor, discordWebhookInteraction);
+        const configurer = {
+            ...accessor,
+            handleApplicationCommand: fnWithKey(discord_js.InteractionType.ApplicationCommand),
+            handleMessageComponent: fnWithKey(discord_js.InteractionType.MessageComponent),
+            handleModalSubmit: fnWithKey(discord_js.InteractionType.ModalSubmit),
+            handleAutocomplete: fnWithKey(discord_js.InteractionType.ApplicationCommandAutocomplete)
+        };
+        return configurer;
+    }
+});
+
+/**
+ * Default environment variable for the Discord application public key.
+ */
+const DISCORD_PUBLIC_KEY_ENV_VAR = 'DISCORD_PUBLIC_KEY';
+/**
+ * Configuration for the DiscordWebhookService.
+ */
+class DiscordWebhookServiceConfig {
+    discordWebhook;
+    static assertValidConfig(config) {
+        if (!config.discordWebhook.publicKey) {
+            throw new Error('No Discord public key specified.');
+        }
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * 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
+ *
+ * @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
+ * }
+ * ```
+ */
+function discordWebhookEventVerifier(config) {
+    const { publicKey: publicKeyHex } = config;
+    // Import the raw 32-byte Ed25519 public key via JWK format.
+    const publicKey = crypto.createPublicKey({
+        key: {
+            kty: 'OKP',
+            crv: 'Ed25519',
+            x: Buffer.from(publicKeyHex, 'hex').toString('base64url')
+        },
+        format: 'jwk'
+    });
+    return async (request, rawBody) => {
+        const signature = request.headers['x-signature-ed25519'];
+        const timestamp = request.headers['x-signature-timestamp'];
+        let result;
+        if (!signature || !timestamp) {
+            result = { valid: false };
+        }
+        else {
+            const message = Buffer.concat([Buffer.from(timestamp), rawBody]);
+            const signatureBuffer = Buffer.from(signature, 'hex');
+            let valid = false;
+            try {
+                valid = crypto.verify(null, message, publicKey, signatureBuffer);
+            }
+            catch {
+                valid = false;
+            }
+            if (valid) {
+                const body = JSON.parse(rawBody.toString('utf-8'));
+                result = { valid: true, body };
+            }
+            else {
+                result = { valid: false };
+            }
+        }
+        return result;
+    };
+}
+
+/**
+ * Service that handles Discord interaction webhook events.
+ *
+ * Verifies incoming webhook signatures and dispatches interactions to registered handlers.
+ */
+exports.DiscordWebhookService = class DiscordWebhookService {
+    logger = new common.Logger('DiscordWebhookService');
+    _verifier;
+    handler = discordInteractionHandlerFactory();
+    configure = discordInteractionHandlerConfigurerFactory(this.handler);
+    constructor(discordWebhookServiceConfig) {
+        this._verifier = discordWebhookEventVerifier({
+            publicKey: discordWebhookServiceConfig.discordWebhook.publicKey
+        });
+    }
+    async updateForWebhook(req, rawBody) {
+        const result = await this._verifier(req, rawBody);
+        if (!result.valid) {
+            this.logger.warn('Received invalid Discord interaction event.', req);
+        }
+        else {
+            await this.updateForDiscordInteraction(result.body);
+        }
+    }
+    async updateForDiscordInteraction(interaction) {
+        const result = await this.handler(interaction);
+        if (!result) {
+            this.logger.warn('Received unexpected/unhandled Discord interaction.', interaction);
+        }
+    }
+};
+exports.DiscordWebhookService = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(DiscordWebhookServiceConfig))
+], exports.DiscordWebhookService);
+
+exports.DiscordWebhookController = class DiscordWebhookController {
+    _discordWebhookService;
+    constructor(discordWebhookService) {
+        this._discordWebhookService = discordWebhookService;
+    }
+    async handleDiscordWebhook(req, rawBody) {
+        await this._discordWebhookService.updateForWebhook(req, rawBody);
+    }
+};
+__decorate([
+    common.Post(),
+    __param(0, common.Req()),
+    __param(1, nestjs.RawBody())
+], exports.DiscordWebhookController.prototype, "handleDiscordWebhook", null);
+exports.DiscordWebhookController = __decorate([
+    common.Controller('/webhook/discord'),
+    __param(0, common.Inject(exports.DiscordWebhookService))
+], exports.DiscordWebhookController);
+
+/**
+ * Factory that creates a DiscordWebhookServiceConfig from environment variables.
+ */
+function discordWebhookServiceConfigFactory(configService) {
+    const config = {
+        discordWebhook: {
+            publicKey: configService.get(DISCORD_PUBLIC_KEY_ENV_VAR)
+        }
+    };
+    DiscordWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * 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.
+ */
+exports.DiscordWebhookModule = class DiscordWebhookModule {
+};
+exports.DiscordWebhookModule = __decorate([
+    common.Module({
+        imports: [config.ConfigModule],
+        controllers: [exports.DiscordWebhookController],
+        providers: [
+            {
+                provide: DiscordWebhookServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: discordWebhookServiceConfigFactory
+            },
+            exports.DiscordWebhookService
+        ],
+        exports: [exports.DiscordWebhookService]
+    })
+], exports.DiscordWebhookModule);
+
+/**
+ * Default environment variable for the Discord bot token.
+ */
+const DISCORD_BOT_TOKEN_ENV_VAR = 'DISCORD_BOT_TOKEN';
+/**
+ * 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.
+ */
+const DISCORD_DEFAULT_INTENTS = [discord_js.GatewayIntentBits.Guilds, discord_js.GatewayIntentBits.GuildMessages, discord_js.GatewayIntentBits.MessageContent];
+/**
+ * Configuration for the DiscordApi service.
+ */
+class DiscordServiceConfig {
+    discord;
+    static assertValidConfig(config) {
+        if (!config.discord.botToken) {
+            throw new Error('No Discord bot token specified.');
+        }
+    }
+}
+
+/**
+ * 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).
+ */
+exports.DiscordApi = class DiscordApi {
+    config;
+    logger = new common.Logger('DiscordApi');
+    /**
+     * The underlying discord.js Client instance.
+     */
+    client;
+    constructor(config) {
+        this.config = config;
+        const { clientOptions } = config.discord;
+        this.client = new discord_js.Client({
+            intents: DISCORD_DEFAULT_INTENTS,
+            ...clientOptions
+        });
+    }
+    async onModuleInit() {
+        const { autoLogin = true, botToken } = this.config.discord;
+        let result;
+        if (autoLogin) {
+            result = this.client
+                .login(botToken)
+                .then(() => { })
+                .catch((e) => {
+                this.logger.error('Failed to log in to Discord', e);
+            });
+        }
+        else {
+            result = Promise.resolve();
+        }
+        return result;
+    }
+    async onModuleDestroy() {
+        return this.client.destroy();
+    }
+    /**
+     * 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!');
+     * ```
+     */
+    async sendMessage(channelId, content) {
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel || !(channel instanceof discord_js.TextChannel)) {
+            throw new Error(`Channel ${channelId} not found or is not a text channel.`);
+        }
+        return channel.send(content);
+    }
+    /**
+     * 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();
+     * ```
+     */
+    onMessage(handler) {
+        this.client.on(discord_js.Events.MessageCreate, handler);
+        return () => this.client.off(discord_js.Events.MessageCreate, handler);
+    }
+};
+exports.DiscordApi = __decorate([
+    common.Injectable(),
+    __param(0, common.Inject(DiscordServiceConfig))
+], exports.DiscordApi);
+
+/**
+ * Factory that creates a DiscordServiceConfig from environment variables.
+ */
+function discordServiceConfigFactory(configService) {
+    const config = {
+        discord: {
+            botToken: configService.get(DISCORD_BOT_TOKEN_ENV_VAR),
+            autoLogin: true
+        }
+    };
+    DiscordServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that provides the DiscordApi service.
+ *
+ * Reads the bot token from the DISCORD_BOT_TOKEN environment variable.
+ */
+exports.DiscordModule = class DiscordModule {
+};
+exports.DiscordModule = __decorate([
+    common.Module({
+        imports: [config.ConfigModule],
+        providers: [
+            {
+                provide: DiscordServiceConfig,
+                inject: [config.ConfigService],
+                useFactory: discordServiceConfigFactory
+            },
+            exports.DiscordApi
+        ],
+        exports: [exports.DiscordApi]
+    })
+], exports.DiscordModule);
+
+/**
+ * Default number of messages per page when fetching Discord channel messages.
+ */
+const DISCORD_DEFAULT_MESSAGES_PER_PAGE = 100;
+/**
+ * Creates a page factory that wraps a Discord message fetch function with automatic cursor-based pagination.
+ *
+ * Discord paginates via `before`/`after` snowflake IDs. This factory automatically reads the last
+ * message's ID from each response and sets it as the `before` cursor for the next request.
+ * When the number of returned messages is less than the requested limit, pagination stops.
+ *
+ * @param fetch - The Discord fetch function to paginate over
+ * @param config - Optional config for reading message IDs
+ * @param defaults - Optional default configuration for the page factory
+ * @returns A page factory that produces iterable page fetchers
+ *
+ * @example
+ * ```typescript
+ * const pageFactory = discordFetchMessagePageFactory(fetchChannelMessages);
+ *
+ * const fetchPage = pageFactory({ limit: 50 });
+ * const firstPage = await fetchPage.fetchNext();
+ *
+ * if (firstPage.hasNext) {
+ *   const secondPage = await firstPage.fetchNext();
+ * }
+ * ```
+ */
+function discordFetchMessagePageFactory(fetch$1, config, defaults) {
+    const readMessageId = config?.readMessageId ?? ((message) => message.id);
+    return fetch.fetchPageFactory({
+        ...defaults,
+        fetch: fetch$1,
+        readFetchPageResultInfo(result) {
+            const count = result.data.length;
+            const lastMessage = util.lastValue(result.data);
+            const nextCursor = lastMessage ? readMessageId(lastMessage) : undefined;
+            return {
+                hasNext: count > 0,
+                nextPageCursor: nextCursor
+            };
+        },
+        buildInputForNextPage(pageResult, input, options) {
+            const nextCursor = pageResult.nextPageCursor;
+            const effectiveLimit = options.maxItemsPerPage ?? input.limit ?? DISCORD_DEFAULT_MESSAGES_PER_PAGE;
+            const resultCount = pageResult.result?.data.length ?? 0;
+            // Discord signals no more results when fewer items than the limit are returned
+            if (!nextCursor || resultCount < effectiveLimit) {
+                return undefined;
+            }
+            return {
+                ...input,
+                before: nextCursor,
+                after: undefined,
+                around: undefined,
+                limit: effectiveLimit
+            };
+        }
+    });
+}
+
+/**
+ * Returns default ClientOptions for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent intents.
+ *
+ * @example
+ * ```ts
+ * const options = discordDefaultClientOptions();
+ * // options.intents === [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
+ * ```
+ */
+function discordDefaultClientOptions() {
+    return {
+        intents: DISCORD_DEFAULT_INTENTS
+    };
+}
+/**
+ * Returns ClientOptions with additional intents merged with the defaults.
+ *
+ * @param additionalIntents - extra intents to include beyond the defaults
+ *
+ * @example
+ * ```ts
+ * const options = discordClientOptionsWithIntents([GatewayIntentBits.DirectMessages]);
+ * // options.intents includes Guilds, GuildMessages, MessageContent, and DirectMessages
+ * ```
+ */
+function discordClientOptionsWithIntents(additionalIntents) {
+    return {
+        intents: [...DISCORD_DEFAULT_INTENTS, ...additionalIntents]
+    };
+}
+
+exports.DISCORD_BOT_TOKEN_ENV_VAR = DISCORD_BOT_TOKEN_ENV_VAR;
+exports.DISCORD_DEFAULT_INTENTS = DISCORD_DEFAULT_INTENTS;
+exports.DISCORD_DEFAULT_MESSAGES_PER_PAGE = DISCORD_DEFAULT_MESSAGES_PER_PAGE;
+exports.DISCORD_PUBLIC_KEY_ENV_VAR = DISCORD_PUBLIC_KEY_ENV_VAR;
+exports.DiscordServiceConfig = DiscordServiceConfig;
+exports.DiscordWebhookServiceConfig = DiscordWebhookServiceConfig;
+exports.discordClientOptionsWithIntents = discordClientOptionsWithIntents;
+exports.discordDefaultClientOptions = discordDefaultClientOptions;
+exports.discordFetchMessagePageFactory = discordFetchMessagePageFactory;
+exports.discordInteractionHandlerConfigurerFactory = discordInteractionHandlerConfigurerFactory;
+exports.discordInteractionHandlerFactory = discordInteractionHandlerFactory;
+exports.discordServiceConfigFactory = discordServiceConfigFactory;
+exports.discordWebhookEventVerifier = discordWebhookEventVerifier;
+exports.discordWebhookInteraction = discordWebhookInteraction;
+exports.discordWebhookServiceConfigFactory = discordWebhookServiceConfigFactory;

package/discord/index.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/discord/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";