necord 3.0.8 → 4.0.0

package/dist/interfaces/necord-metadata.interface.d.ts

@@ -0,0 +1,38 @@
+import { ApplicationCommandData, ApplicationCommandOptionChoice, ApplicationCommandOptionData, ApplicationCommandSubCommandData, ApplicationCommandSubGroupData, AutocompleteInteraction, ChatInputApplicationCommandData, CommandInteractionOptionResolver, MessageApplicationCommandData, MessageComponentType, UserApplicationCommandData } from 'discord.js';
+import { NecordEvents } from './necord-events.interface';
+import { Module } from '@nestjs/core/injector/module';
+import { Type } from '@nestjs/common';
+export declare type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export interface BaseMetadata {
+    metadata?: {
+        [key: string]: any;
+        host?: Module;
+        class?: Type;
+        handler?: Function;
+        execute?: Function;
+    };
+}
+export interface ListenerMetadata<T extends keyof NecordEvents = keyof NecordEvents> extends BaseMetadata {
+    type: 'once' | 'on';
+    event: T;
+}
+export interface ComponentMetadata extends BaseMetadata {
+    type: Exclude<MessageComponentType, 'ACTION_ROW'>;
+    customId: string;
+}
+export interface TextCommandMetadata extends BaseMetadata {
+    name: string;
+    description?: string;
+}
+export declare type ContextMenuMetadata = (UserApplicationCommandData | MessageApplicationCommandData) & BaseMetadata;
+export declare type SlashCommandMetadata = ChatInputApplicationCommandData & BaseMetadata;
+export declare type ApplicationCommandMetadata = ApplicationCommandData & BaseMetadata;
+export declare type CommandOptionData = Exclude<ApplicationCommandOptionData, ApplicationCommandSubCommandData | ApplicationCommandSubGroupData>;
+export declare type OptionMetadata<T extends CommandOptionData['type'] = any> = Extract<CommandOptionData & {
+    type: T;
+}, ApplicationCommandOptionData> & {
+    methodName?: keyof CommandInteractionOptionResolver;
+};
+export interface TransformOptions {
+    transformOptions(interaction: AutocompleteInteraction, focused: ApplicationCommandOptionChoice): ApplicationCommandOptionChoice[] | Promise<ApplicationCommandOptionChoice[]>;
+}

package/dist/interfaces/{module-options.interface.d.ts → necord-options.interface.d.ts}

@@ -1,9 +1,8 @@
 import { ModuleMetadata, Type } from '@nestjs/common';
 import { ClientOptions as DiscordClientOptions } from 'discord.js';
 export interface NecordModuleOptions extends DiscordClientOptions {
-    token?: string;
-    validate?: boolean;
-    registerApplicationCommands?: boolean | string;
+    token: string;
+    prefix?: string | Function;
 }
 export interface NecordOptionsFactory {
     createNecordOptions(): Promise<NecordModuleOptions> | NecordModuleOptions;

package/dist/necord-explorer.d.ts

@@ -0,0 +1,29 @@
+import { InstanceWrapper } from '@nestjs/core/injector/instance-wrapper';
+import { DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { ExternalContextCreator } from '@nestjs/core/helpers/external-context-creator';
+import { ApplicationCommandMetadata, ComponentMetadata, ListenerMetadata, TextCommandMetadata } from './interfaces';
+declare type OptionMetadata = string | {
+    key: string;
+    fn: (key: string, targets: any[]) => unknown;
+};
+export declare class NecordExplorer {
+    private readonly discoveryService;
+    private readonly externalContextCreator;
+    private readonly metadataScanner;
+    private readonly reflector;
+    private readonly necordParamsFactory;
+    private readonly wrappers;
+    constructor(discoveryService: DiscoveryService, externalContextCreator: ExternalContextCreator, metadataScanner: MetadataScanner, reflector: Reflector);
+    explore(): {
+        listeners: ListenerMetadata<keyof import("./interfaces").NecordEvents>[];
+        components: ComponentMetadata[];
+        appCommands: ApplicationCommandMetadata[];
+        textCommands: TextCommandMetadata[];
+    };
+    private flatMap;
+    filterProvider<T = any>(wrapper: InstanceWrapper, metadataKey: string): T | undefined;
+    filterProperties({ instance, host }: InstanceWrapper, metadataKey: string, optionalMetadataKeys?: OptionMetadata[]): any[];
+    private extractOptionalMetadata;
+    private createContextCallback;
+}
+export {};

package/dist/necord-explorer.js

@@ -0,0 +1,116 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NecordExplorer = void 0;
+const discord_js_1 = require("discord.js");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const external_context_creator_1 = require("@nestjs/core/helpers/external-context-creator");
+const context_1 = require("./context");
+const constants_1 = require("@nestjs/core/injector/constants");
+const necord_constants_1 = require("./necord.constants");
+let NecordExplorer = class NecordExplorer {
+    constructor(discoveryService, externalContextCreator, metadataScanner, reflector) {
+        this.discoveryService = discoveryService;
+        this.externalContextCreator = externalContextCreator;
+        this.metadataScanner = metadataScanner;
+        this.reflector = reflector;
+        this.necordParamsFactory = new context_1.NecordParamsFactory();
+        this.wrappers = this.discoveryService.getProviders().filter(wrapper => {
+            const { instance } = wrapper;
+            const prototype = instance ? Object.getPrototypeOf(instance) : null;
+            return instance && prototype && wrapper.isDependencyTreeStatic();
+        });
+    }
+    explore() {
+        const listeners = this.flatMap(wrapper => this.filterProperties(wrapper, necord_constants_1.LISTENERS_METADATA));
+        const components = this.flatMap(wrapper => this.filterProperties(wrapper, necord_constants_1.MESSAGE_COMPONENT_METADATA));
+        const textCommands = this.flatMap(wrapper => this.filterProperties(wrapper, necord_constants_1.TEXT_COMMAND_METADATA));
+        const appCommands = this.flatMap(wrapper => {
+            var _a;
+            const commandGroup = this.filterProvider(wrapper, necord_constants_1.GROUP_METADATA);
+            const subGroups = new discord_js_1.Collection();
+            const subCommands = [];
+            const commands = [];
+            const metadataKey = necord_constants_1.APPLICATION_COMMAND_METADATA;
+            const optionalKeys = [
+                necord_constants_1.GROUP_METADATA,
+                necord_constants_1.OPTIONS_METADATA,
+                necord_constants_1.AUTOCOMPLETE_METADATA,
+                {
+                    key: necord_constants_1.GUILDS_METADATA,
+                    fn: (key, targets) => this.reflector.getAllAndOverride(key, targets)
+                }
+            ];
+            for (const command of this.filterProperties(wrapper, metadataKey, optionalKeys)) {
+                command.options = Object.values((_a = command.metadata[necord_constants_1.OPTIONS_METADATA]) !== null && _a !== void 0 ? _a : []);
+                if (!commandGroup || command.type !== 1) {
+                    commands.push(command);
+                }
+                const subGroup = command.metadata[necord_constants_1.GROUP_METADATA];
+                subGroup
+                    ? subGroups.ensure(subGroup.name, () => subGroup).options.push(command)
+                    : subCommands.push(command);
+            }
+            if (commandGroup) {
+                commandGroup.metadata = this.extractOptionalMetadata([necord_constants_1.GUILDS_METADATA], wrapper.instance);
+                commandGroup.options = [...subGroups.values(), ...subCommands];
+            }
+            return commands.concat(commandGroup);
+        });
+        return {
+            listeners,
+            components,
+            appCommands,
+            textCommands
+        };
+    }
+    flatMap(callback) {
+        return this.wrappers.flatMap(callback).filter(Boolean);
+    }
+    filterProvider(wrapper, metadataKey) {
+        return this.reflector.get(metadataKey, wrapper.instance.constructor);
+    }
+    filterProperties({ instance, host }, metadataKey, optionalMetadataKeys = []) {
+        const prototype = Object.getPrototypeOf(instance);
+        return this.metadataScanner.scanFromPrototype(instance, prototype, name => {
+            const item = this.reflector.get(metadataKey, instance[name]);
+            if (!item)
+                return;
+            return Object.assign(item, {
+                metadata: Object.assign({ host, class: instance.constructor, handler: prototype[name], execute: this.createContextCallback(instance, prototype, name) }, this.extractOptionalMetadata(optionalMetadataKeys, instance, name))
+            });
+        });
+    }
+    extractOptionalMetadata(keys, instance, propertyKey) {
+        const defaultTarget = propertyKey ? instance[propertyKey] : instance.constructor;
+        const defaultTargets = [instance[propertyKey], instance.constructor].filter(Boolean);
+        return keys.reduce((acc, option) => {
+            const isOptionString = typeof option === 'string';
+            const key = isOptionString ? option : option.key;
+            const value = isOptionString
+                ? this.reflector.get(key, defaultTarget)
+                : option.fn(key, defaultTargets);
+            return Object.assign(Object.assign({}, acc), { [key]: value });
+        }, {});
+    }
+    createContextCallback(instance, prototype, methodName) {
+        return this.externalContextCreator.create(instance, prototype[methodName], methodName, necord_constants_1.PARAM_ARGS_METADATA, this.necordParamsFactory, constants_1.STATIC_CONTEXT, undefined, { guards: true, filters: true, interceptors: true }, 'necord');
+    }
+};
+NecordExplorer = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.DiscoveryService,
+        external_context_creator_1.ExternalContextCreator,
+        core_1.MetadataScanner,
+        core_1.Reflector])
+], NecordExplorer);
+exports.NecordExplorer = NecordExplorer;

package/dist/necord-interaction.update.d.ts

@@ -0,0 +1,9 @@
+import { NecordRegistry } from './necord-registry';
+export declare class NecordInteractionUpdate {
+    private readonly registry;
+    private readonly logger;
+    constructor(registry: NecordRegistry);
+    private onReady;
+    private onInteractionCreate;
+    private transformOptions;
+}

package/dist/necord-interaction.update.js

@@ -0,0 +1,123 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var NecordInteractionUpdate_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NecordInteractionUpdate = void 0;
+const common_1 = require("@nestjs/common");
+const decorators_1 = require("./decorators");
+const necord_registry_1 = require("./necord-registry");
+const necord_constants_1 = require("./necord.constants");
+const core_1 = require("@nestjs/core");
+const constants_1 = require("@nestjs/core/injector/constants");
+let NecordInteractionUpdate = NecordInteractionUpdate_1 = class NecordInteractionUpdate {
+    constructor(registry) {
+        this.registry = registry;
+        this.logger = new common_1.Logger(NecordInteractionUpdate_1.name);
+    }
+    onReady([client]) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (client.application.partial) {
+                yield client.application.fetch();
+            }
+            const commands = new Map([[undefined, []]]);
+            for (const command of this.registry.getApplicationCommands()) {
+                const guilds = (_a = command.metadata[necord_constants_1.GUILDS_METADATA]) !== null && _a !== void 0 ? _a : [undefined];
+                for (const guild of guilds) {
+                    const cmds = (_b = commands.get(guild)) !== null && _b !== void 0 ? _b : [];
+                    commands.set(guild, cmds.concat(command));
+                }
+            }
+            this.logger.log(`Started refreshing application commands.`);
+            yield Promise.all([...commands.entries()].map(([key, cmds]) => client.application.commands.set(cmds, key)));
+            this.logger.log(`Successfully reloaded application commands.`);
+        });
+    }
+    onInteractionCreate([interaction]) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (interaction.isMessageComponent()) {
+                return (_a = this.registry
+                    .getMessageComponent(interaction.componentType, interaction.customId)) === null || _a === void 0 ? void 0 : _a.metadata.execute([interaction], interaction.isSelectMenu() ? interaction.values : undefined);
+            }
+            if (interaction.isContextMenu()) {
+                const options = interaction.isUserContextMenu()
+                    ? {
+                        user: interaction.options.getUser('user', false),
+                        member: interaction.options.getMember('user', false)
+                    }
+                    : { message: interaction.options.getMessage('message', false) };
+                return (_b = this.registry
+                    .getContextMenu(interaction.targetType, interaction.commandName)) === null || _b === void 0 ? void 0 : _b.metadata.execute([interaction], options);
+            }
+            if (interaction.isCommand() || interaction.isAutocomplete()) {
+                const rootCommand = interaction.commandName;
+                const groupCommand = interaction.options.getSubcommandGroup(false);
+                const subCommand = interaction.options.getSubcommand(false);
+                const command = this.registry.getSlashCommand(...[rootCommand, groupCommand, subCommand].filter(Boolean));
+                if (!command)
+                    return;
+                if (interaction.isCommand()) {
+                    return command === null || command === void 0 ? void 0 : command.metadata.execute([interaction], this.transformOptions(command, interaction));
+                }
+                const module = command.metadata.host;
+                const autocompleteMetadata = command.metadata[necord_constants_1.AUTOCOMPLETE_METADATA];
+                const { instance: moduleRef } = module.getProviderByKey(core_1.ModuleRef);
+                if (!module || !autocompleteMetadata || !moduleRef)
+                    return;
+                const autocomplete = yield moduleRef
+                    .resolve(autocompleteMetadata, constants_1.STATIC_CONTEXT, { strict: true })
+                    .catch(() => moduleRef.create(autocompleteMetadata));
+                const options = yield (autocomplete === null || autocomplete === void 0 ? void 0 : autocomplete.transformOptions(interaction, interaction.options.getFocused(true)));
+                return interaction.respond(options !== null && options !== void 0 ? options : []);
+            }
+        });
+    }
+    transformOptions(command, interaction) {
+        var _a;
+        const rawOptions = (_a = command.metadata[necord_constants_1.OPTIONS_METADATA]) !== null && _a !== void 0 ? _a : {};
+        return Object.entries(rawOptions).reduce((acc, [parameter, option]) => {
+            acc[parameter] = interaction.options[option.methodName].call(interaction.options, option.name, !!option.required);
+            return acc;
+        }, {});
+    }
+};
+__decorate([
+    (0, decorators_1.Once)('ready'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NecordInteractionUpdate.prototype, "onReady", null);
+__decorate([
+    (0, decorators_1.On)('interactionCreate'),
+    __param(0, (0, decorators_1.Context)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], NecordInteractionUpdate.prototype, "onInteractionCreate", null);
+NecordInteractionUpdate = NecordInteractionUpdate_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [necord_registry_1.NecordRegistry])
+], NecordInteractionUpdate);
+exports.NecordInteractionUpdate = NecordInteractionUpdate;

package/dist/necord-registry.d.ts

@@ -0,0 +1,24 @@
+import { Client } from 'discord.js';
+import { ApplicationCommandMetadata, ComponentMetadata, ContextMenuMetadata, ListenerMetadata, SlashCommandMetadata, TextCommandMetadata } from './interfaces';
+export declare class NecordRegistry {
+    private readonly client;
+    private static readonly GENERATE_KEY;
+    private readonly textCommands;
+    private readonly messageComponents;
+    private readonly applicationCommands;
+    private readonly applicationCommandsData;
+    constructor(client: Client);
+    registerListeners(listeners: ListenerMetadata[]): void;
+    addTextCommands(textCommands: TextCommandMetadata[]): void;
+    getTextCommands(): TextCommandMetadata[];
+    getTextCommand(name: string): TextCommandMetadata;
+    addApplicationCommands(appCommands: ApplicationCommandMetadata[]): void;
+    getApplicationCommands(): ApplicationCommandMetadata[];
+    getContextMenu(type: 'USER' | 'MESSAGE', name: string): ContextMenuMetadata;
+    getSlashCommand(...args: string[]): SlashCommandMetadata;
+    addMessageComponents(messageComponents: ComponentMetadata[]): void;
+    getMessageComponents(): ComponentMetadata[];
+    getMessageComponent(componentType: ComponentMetadata['type'], customId: string): ComponentMetadata;
+    getButton(customId: string): ComponentMetadata;
+    getSelectMenu(customId: string): ComponentMetadata;
+}

package/dist/necord-registry.js

@@ -0,0 +1,78 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var NecordRegistry_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NecordRegistry = void 0;
+const discord_js_1 = require("discord.js");
+const common_1 = require("@nestjs/common");
+let NecordRegistry = NecordRegistry_1 = class NecordRegistry {
+    constructor(client) {
+        this.client = client;
+        this.textCommands = new discord_js_1.Collection();
+        this.messageComponents = new discord_js_1.Collection();
+        this.applicationCommands = new discord_js_1.Collection();
+        this.applicationCommandsData = [];
+    }
+    registerListeners(listeners) {
+        listeners.forEach(listener => {
+            this.client[listener.type](listener.event, (...args) => listener.metadata.execute(args));
+        });
+    }
+    addTextCommands(textCommands) {
+        textCommands.forEach(command => this.textCommands.set(command.name, command));
+    }
+    getTextCommands() {
+        return [...this.textCommands.values()];
+    }
+    getTextCommand(name) {
+        return this.textCommands.get(name);
+    }
+    addApplicationCommands(appCommands) {
+        const recursive = (command, tree) => {
+            const options = 'options' in command ? command.options : [];
+            options.every(option => option.type !== 1 && option.type !== 2)
+                ? this.applicationCommands.set(NecordRegistry_1.GENERATE_KEY(...tree), command)
+                : options.map((command) => recursive(command, tree.concat(command.name)));
+        };
+        appCommands.forEach(command => recursive(command, [command.type, command.name]));
+        this.applicationCommandsData.push(...appCommands);
+    }
+    getApplicationCommands() {
+        return this.applicationCommandsData;
+    }
+    getContextMenu(type, name) {
+        return this.applicationCommands.get(NecordRegistry_1.GENERATE_KEY(type, name));
+    }
+    getSlashCommand(...args) {
+        return this.applicationCommands.get(NecordRegistry_1.GENERATE_KEY(1, ...args));
+    }
+    addMessageComponents(messageComponents) {
+        messageComponents.forEach(component => this.messageComponents.set(NecordRegistry_1.GENERATE_KEY(component.type, component.customId), component));
+    }
+    getMessageComponents() {
+        return [...this.messageComponents.values()];
+    }
+    getMessageComponent(componentType, customId) {
+        return this.messageComponents.get(NecordRegistry_1.GENERATE_KEY(componentType, customId));
+    }
+    getButton(customId) {
+        return this.getMessageComponent('BUTTON', customId);
+    }
+    getSelectMenu(customId) {
+        return this.getMessageComponent('SELECT_MENU', customId);
+    }
+};
+NecordRegistry.GENERATE_KEY = (...args) => args.map(String).join(':');
+NecordRegistry = NecordRegistry_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [discord_js_1.Client])
+], NecordRegistry);
+exports.NecordRegistry = NecordRegistry;

package/dist/necord.constants.d.ts

@@ -1,8 +1,11 @@
 export declare const NECORD_MODULE_OPTIONS = "necord:module_options";
 export declare const PARAM_ARGS_METADATA = "__routeArguments__";
+export declare const TEXT_COMMAND_METADATA = "necord:text_command_meta";
 export declare const APPLICATION_COMMAND_METADATA = "necord:application_command_meta";
 export declare const MESSAGE_COMPONENT_METADATA = "necord:message_component_meta";
 export declare const LISTENERS_METADATA = "necord:listeners_meta";
+export declare const AUTOCOMPLETE_METADATA = "necord:autocomplete_metadata";
 export declare const GROUP_METADATA = "necord:group_meta";
-export declare const SUBGROUP_METADATA = "necord:subgroup_meta";
 export declare const OPTIONS_METADATA = "necord:options_meta";
+export declare const GUILDS_METADATA = "necord:guilds_meta";
+export declare const PERMISSIONS_METADATA = "necord:permissions_meta";

package/dist/necord.constants.js

@@ -1,12 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OPTIONS_METADATA = exports.SUBGROUP_METADATA = exports.GROUP_METADATA = exports.LISTENERS_METADATA = exports.MESSAGE_COMPONENT_METADATA = exports.APPLICATION_COMMAND_METADATA = exports.PARAM_ARGS_METADATA = exports.NECORD_MODULE_OPTIONS = void 0;
+exports.PERMISSIONS_METADATA = exports.GUILDS_METADATA = exports.OPTIONS_METADATA = exports.GROUP_METADATA = exports.AUTOCOMPLETE_METADATA = exports.LISTENERS_METADATA = exports.MESSAGE_COMPONENT_METADATA = exports.APPLICATION_COMMAND_METADATA = exports.TEXT_COMMAND_METADATA = exports.PARAM_ARGS_METADATA = exports.NECORD_MODULE_OPTIONS = void 0;
 const constants_1 = require("@nestjs/common/constants");
 exports.NECORD_MODULE_OPTIONS = 'necord:module_options';
 exports.PARAM_ARGS_METADATA = constants_1.ROUTE_ARGS_METADATA;
+exports.TEXT_COMMAND_METADATA = 'necord:text_command_meta';
 exports.APPLICATION_COMMAND_METADATA = 'necord:application_command_meta';
 exports.MESSAGE_COMPONENT_METADATA = 'necord:message_component_meta';
 exports.LISTENERS_METADATA = 'necord:listeners_meta';
+exports.AUTOCOMPLETE_METADATA = 'necord:autocomplete_metadata';
 exports.GROUP_METADATA = 'necord:group_meta';
-exports.SUBGROUP_METADATA = 'necord:subgroup_meta';
 exports.OPTIONS_METADATA = 'necord:options_meta';
+exports.GUILDS_METADATA = 'necord:guilds_meta';
+exports.PERMISSIONS_METADATA = 'necord:permissions_meta';

package/dist/necord.module.d.ts

@@ -1,10 +1,14 @@
 import { DynamicModule, OnApplicationBootstrap, OnApplicationShutdown } from '@nestjs/common';
 import { Client } from 'discord.js';
 import { NecordModuleAsyncOptions, NecordModuleOptions } from './interfaces';
+import { NecordRegistry } from './necord-registry';
+import { NecordExplorer } from './necord-explorer';
 export declare class NecordModule implements OnApplicationBootstrap, OnApplicationShutdown {
     private readonly options;
     private readonly client;
-    constructor(options: NecordModuleOptions, client: Client);
+    private readonly explorer;
+    private readonly registry;
+    constructor(options: NecordModuleOptions, client: Client, explorer: NecordExplorer, registry: NecordRegistry);
     onApplicationBootstrap(): Promise<string>;
     onApplicationShutdown(signal?: string): void;
     static forRoot(options: NecordModuleOptions): DynamicModule;

package/dist/necord.module.js

@@ -27,15 +27,26 @@ const common_1 = require("@nestjs/common");
 const discord_js_1 = require("discord.js");
 const core_1 = require("@nestjs/core");
 const necord_constants_1 = require("./necord.constants");
-const services_1 = require("./services");
+const necord_registry_1 = require("./necord-registry");
+const necord_explorer_1 = require("./necord-explorer");
+const necord_interaction_update_1 = require("./necord-interaction.update");
 const necord_update_1 = require("./necord.update");
 let NecordModule = NecordModule_1 = class NecordModule {
-    constructor(options, client) {
+    constructor(options, client, explorer, registry) {
         this.options = options;
         this.client = client;
+        this.explorer = explorer;
+        this.registry = registry;
     }
     onApplicationBootstrap() {
-        return this.client.login(this.options.token);
+        return __awaiter(this, void 0, void 0, function* () {
+            const { listeners, components, appCommands, textCommands } = this.explorer.explore();
+            this.registry.registerListeners(listeners);
+            this.registry.addTextCommands(textCommands);
+            this.registry.addMessageComponents(components);
+            this.registry.addApplicationCommands(appCommands);
+            return this.client.login(this.options.token);
+        });
     }
     onApplicationShutdown(signal) {
         return this.client.destroy();
@@ -101,16 +112,12 @@ NecordModule = NecordModule_1 = __decorate([
     (0, common_1.Global)(),
     (0, common_1.Module)({
         imports: [core_1.DiscoveryModule],
-        providers: [
-            services_1.CommandsService,
-            services_1.ComponentsService,
-            services_1.ListenersService,
-            services_1.ExplorerService,
-            services_1.MetadataAccessorService,
-            necord_update_1.NecordUpdate
-        ]
+        providers: [necord_explorer_1.NecordExplorer, necord_update_1.NecordUpdate, necord_interaction_update_1.NecordInteractionUpdate, necord_registry_1.NecordRegistry],
+        exports: [necord_registry_1.NecordRegistry]
     }),
     __param(0, (0, common_1.Inject)(necord_constants_1.NECORD_MODULE_OPTIONS)),
-    __metadata("design:paramtypes", [Object, discord_js_1.Client])
+    __metadata("design:paramtypes", [Object, discord_js_1.Client,
+        necord_explorer_1.NecordExplorer,
+        necord_registry_1.NecordRegistry])
 ], NecordModule);
 exports.NecordModule = NecordModule;

package/dist/necord.update.d.ts

@@ -1,7 +1,21 @@
+import { Client } from 'discord.js';
+import { NecordModuleOptions } from './interfaces';
+import { NecordRegistry } from './necord-registry';
 export declare class NecordUpdate {
-    private readonly logger;
-    onWarn(message: string): void;
-    onError(error: Error): void;
-    onDebug(message: string): void;
-    private static isDebugMode;
+    private readonly options;
+    private readonly client;
+    private readonly registry;
+    private readonly prefix;
+    constructor(options: NecordModuleOptions, client: Client, registry: NecordRegistry);
+    private onMessageCreate;
+    private emit;
+    private onChannelUpdate;
+    private onGuildMemberUpdate;
+    private onGuildUpdate;
+    private onMessageUpdate;
+    private onPresenceUpdate;
+    private onRoleUpdate;
+    private onThreadUpdate;
+    private onUserUpdate;
+    private onVoiceStateUpdate;
 }