feat!: simpler plugins (#193)

* feat: experimental plugin changes

* more refactors and name changes

* feat: update name usage and update dispatchers.ts

* fix:naming

* feat: slightly safer typings than any[]

* fix: forgot to destructure arguments

* feat: add special function

* fix: typings

* feat: SUPER SIMPLIFY!!!

* refactor: move promisifiedPlugins closer to call site

* refactor: typings

* refactor: typings

* refactor: consolidate resolving initplugins into one function

* refactor: better types

* revert: remove unneeded function

* revert: remove unneeded function

* feat: dispatch work, simplify

* feat: move some observableHandling function to operators for clarity

* feat: simplify and document

* feat: simplifying sern and docs

* fix: typings

* docs: clarity of function name

* docs: add documentation for executeModule

* feat: contextArgs overloads

* docs: found out why

* fix: typings

* feat: shorten operators signature

* refactor: switch to correct convention

* refactor: take(1) -> first()

* refactor: revert

* refactor: safer typings (less any) and more accurate typings

* style: prettier and short type aliases

* fix: typings

* fix: typings

* docs: add deprecations

* refactor: organization and moving stuff

* pretty: prettey

* docs: describe file

* chore: update dependencies and version

* docs: fix link for docasaurus

* refactor: using a more appropriate operator function for closing an observable on crash

* fix!: changing single and many

* refactor: typings and simplifying composeRoot

* fix: re-add logger into handleError

* docs: comment

* docs: new section

* feat: help mitigate breaking changes

* feat: help mitigate breaking changes

* feat: help mitigate breaking changes and function overloads

* feat: deprecate instead of remove

* feat: partial remove and deprecate old symbols

* revert: trying to accommodate old plugins is too difficult

* docs: add many as deprecated

* docs: update

* feat: partial backwards compatability

* refactor: renaming, docs, and exports more clean

* refactor: context got a lot simpler

* refactor: imports

* docs: explain methods

src/types/handler.ts

@@ -7,6 +7,7 @@ import type { UnpackFunction } from 'iti';
 import type { ErrorHandling, Logging, ModuleManager } from '../handler/contracts';
 import type { ModuleStore } from '../handler/structures/moduleStore';
 import type SernEmitter from '../handler/sernEmitter';
+import type { Container } from 'iti';
 // Thanks to @kelsny
 export type ParseType<T> = {
     [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
@@ -20,9 +21,7 @@ export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' |
  * After modules are transformed, name and description are given default values if none
  * are provided to Module. This type represents that transformation
  */
-export type DefinedCommandModule = CommandModule & { name: string; description: string };
-export type DefinedEventModule = EventModule & { name: string };
-export type AnyDefinedModule = DefinedCommandModule | DefinedEventModule;
+export type AnyDefinedModule = Processed<CommandModule | EventModule>;
 export type Payload =
     | { type: PayloadType.Success; module: AnyModule }
     | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
@@ -50,7 +49,7 @@ export type ReplyOptions =
     | string
     | Omit<InteractionReplyOptions, 'fetchReply'>
     | MessageReplyOptions;
-
+//prettier-ignore
 export type MapDeps<Deps extends Dependencies, T extends readonly unknown[]> = T extends [
     infer First extends keyof Deps,
     ...infer Rest extends readonly unknown[],
@@ -62,3 +61,9 @@ export type MapDeps<Deps extends Dependencies, T extends readonly unknown[]> = T
     : [never];
 //Basically, '@sern/client' | '@sern/store' | '@sern/modules' | '@sern/error' | '@sern/emitter' will be provided defaults, and you can exclude the rest
 export type OptionalDependencies = '@sern/logger';
+export type Processed<T> = T & { name: string; description: string };
+export type Deprecated<Message extends string> = [never, Message]
+export interface DependencyConfiguration<T extends Dependencies> {
+ exclude?: Set<OptionalDependencies>;
+ build: (root: Container<Omit<Dependencies, '@sern/client'>, {}>) => Container<T, {}>
+}

src/types/module.ts

@@ -20,121 +20,118 @@ import type {
     RoleSelectMenuInteraction,
     StringSelectMenuInteraction,
 } from 'discord.js';
-import type {
-    DiscordEventCommand,
-    ExternalEventCommand,
-    SernEventCommand,
-} from '../handler/structures/events';
 import { CommandType } from '../handler/structures/enums';
 import type { Args, SlashOptions } from './handler';
 import type Context from '../handler/structures/context';
-import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../handler/plugins/plugin';
+import type { InitPlugin, ControlPlugin } from './plugin';
 import { EventType } from '../handler/structures/enums';
 import type { UserSelectMenuInteraction } from 'discord.js';
+import type { AnyCommandPlugin, AnyEventPlugin } from './plugin';
+import type { SernEventsMapping } from './handler';
+import type { ClientEvents } from 'discord.js';
 
 export interface Module {
-    type?: CommandType | EventType;
+    type: CommandType | EventType;
     name?: string;
+    onEvent: ControlPlugin[];
+    plugins: InitPlugin[];
     description?: string;
-    execute: (...args: any[]) => any;
+    execute: (...args: any[]) => Awaitable<any>;
 }
 
 export interface TextCommand extends Module {
     type: CommandType.Text;
-    onEvent: EventPlugin<CommandType.Text>[];
-    plugins: CommandPlugin[];
     alias?: string[];
     execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
 }
 
 export interface SlashCommand extends Module {
     type: CommandType.Slash;
-    onEvent: EventPlugin<CommandType.Slash>[];
-    plugins: CommandPlugin[];
+    description: string;
     options?: SernOptionsData[];
     execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
 }
 
 export interface BothCommand extends Module {
     type: CommandType.Both;
-    onEvent: EventPlugin<CommandType.Both>[];
-    plugins: CommandPlugin[];
     alias?: string[];
+    description: string;
     options?: SernOptionsData[];
     execute: (ctx: Context, args: Args) => Awaitable<unknown>;
 }
 
 export interface ContextMenuUser extends Module {
     type: CommandType.CtxUser;
-    onEvent: EventPlugin<CommandType.CtxUser>[];
-    plugins: CommandPlugin[];
     execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
 }
 
 export interface ContextMenuMsg extends Module {
     type: CommandType.CtxMsg;
-    onEvent: EventPlugin<CommandType.CtxMsg>[];
-    plugins: CommandPlugin[];
     execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
 }
 
 export interface ButtonCommand extends Module {
     type: CommandType.Button;
-    onEvent: EventPlugin<CommandType.Button>[];
-    plugins: CommandPlugin[];
     execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
 }
 
 export interface StringSelectCommand extends Module {
     type: CommandType.StringSelect;
-    onEvent: EventPlugin<CommandType.StringSelect>[];
-    plugins: CommandPlugin[];
     execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
 }
 
 export interface ChannelSelectCommand extends Module {
     type: CommandType.ChannelSelect;
-    onEvent: EventPlugin<CommandType.ChannelSelect>[];
-    plugins: CommandPlugin[];
     execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
 }
 
 export interface RoleSelectCommand extends Module {
     type: CommandType.RoleSelect;
-    onEvent: EventPlugin<CommandType.RoleSelect>[];
-    plugins: CommandPlugin[];
     execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
 }
 
 export interface MentionableSelectCommand extends Module {
     type: CommandType.MentionableSelect;
-    onEvent: EventPlugin<CommandType.MentionableSelect>[];
-    plugins: CommandPlugin[];
     execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
 }
 
 export interface UserSelectCommand extends Module {
     type: CommandType.UserSelect;
-    onEvent: EventPlugin<CommandType.UserSelect>[];
-    plugins: CommandPlugin[];
     execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
 }
 
 export interface ModalSubmitCommand extends Module {
     type: CommandType.Modal;
-    onEvent: EventPlugin<CommandType.Modal>[];
-    plugins: CommandPlugin[];
     execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
 }
 
-export interface AutocompleteCommand extends Module {
-    name?: never;
-    description?: never;
-    type?: never;
-    onEvent: AutocompletePlugin[];
+export interface AutocompleteCommand
+    extends Omit<Module, 'name' | 'type' | 'plugins' | 'description'> {
+    onEvent: ControlPlugin[];
     execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
 }
 
+export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
+    extends Module {
+    name?: T;
+    type: EventType.Sern;
+    execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
+}
+
+export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents>
+    extends Module {
+    name?: T;
+    type: EventType.Discord;
+    execute(...args: ClientEvents[T]): Awaitable<unknown>;
+}
+
+export interface ExternalEventCommand extends Module {
+    name?: string;
+    emitter: string;
+    type: EventType.External;
+    execute(...args: unknown[]): Awaitable<unknown>;
+}
+
 export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
 export type CommandModule =
     | TextCommand
@@ -185,6 +182,21 @@ export interface SernAutocompleteData
     command: AutocompleteCommand;
 }
 
+export type CommandModuleNoPlugins = {
+    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
+};
+export type EventModulesNoPlugins = {
+    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
+};
+
+export type InputEvent = {
+    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: AnyEventPlugin[] };
+}[EventType];
+
+export type InputCommand = {
+    [T in CommandType]: CommandModuleNoPlugins[T] & { plugins?: AnyCommandPlugin[] };
+}[CommandType];
+
 /**
  * Type that replaces autocomplete with {@link SernAutocompleteData}
  */

src/types/plugin.ts

@@ -0,0 +1,71 @@
+/*
+ * Plugins can be inserted on all commands and are emitted
+ *
+ * 1. On ready event, where all commands are loaded.
+ * 2. On corresponding observable (when command triggers)
+ *
+ * The goal of plugins is to organize commands and
+ * provide extensions to repetitive patterns
+ * examples include refreshing modules,
+ * categorizing commands, cool-downs, permissions, etc.
+ * Plugins are reminiscent of middleware in express.
+ */
+
+import type { Awaitable } from 'discord.js';
+import type { Err, Ok, Result } from 'ts-results-es';
+import type { PluginType } from '../handler/structures/enums';
+import type { CommandModule, EventModule } from './module';
+import type { CommandArgs, InitArgs } from '../handler/plugins';
+import type { Deprecated, Processed } from './handler';
+import type { CommandType } from '../handler/structures/enums';
+export type PluginResult = Awaitable<VoidResult>;
+export type VoidResult = Result<void, void>;
+
+export interface Controller {
+    next: () => Ok<void>
+    stop: () => Err<void>
+}
+export interface Plugin<Args extends any[] = any[]> {
+    type: PluginType;
+    execute: (...args: Args) => PluginResult;
+}
+
+export interface InitPlugin<Args extends any[] = any[]> {
+    type: PluginType.Init;
+    execute: (...args: Args) => PluginResult;
+}
+export interface ControlPlugin<Args extends any[] = any[]> {
+    type: PluginType.Control;
+    execute: (...args: Args) => PluginResult;
+}
+
+export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
+export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;
+
+/**
+ * @deprecated
+ * Use the newer helper functions and import { controller } from '@sern/handler'
+ */
+export interface CommandPlugin<T extends CommandType = CommandType> {
+    name?: string;
+    description?: string;
+    type: PluginType.Command;
+    execute: (m: InitArgs<Processed<CommandModule>>, controller?: Deprecated<'Please import controller instead'>) => PluginResult;
+}
+/**
+ * @deprecated
+ * Use the newer helper functions
+ */
+export interface EventPlugin<T extends CommandType> {
+    name?: string;
+    description?: string;
+    type: PluginType.Event;
+    execute: (args : CommandArgs<T, PluginType.Event>, controller?: Controller) => PluginResult
+}
+export type DiscordEmitterPlugin = Deprecated<'Please view alternatives: '>;
+export type ExternalEmitterPlugin = Deprecated<'Please view alternatives: '>;
+export type SernEmitterPlugin = Deprecated<'Please view alternatives: '>;
+export type AutocompletePlugin = Deprecated<'Please view alternatives: '>;
+export type SernEventPlugin = Deprecated<'Please view alternatives: '>;
+export type ExternalEventPlugin = Deprecated<'Please view alternatives: '>;
+export type DiscordEventPlugin = Deprecated<'Please view alternatives: '>;