feat!:(2.0 global services) (#156)

* style: prettier line feed changes

* style: prettier line feed changes

* feat: prototyping module manager

* feat: removing unused types

* feat: update location of module typings

* revert: port back to original interaction type checkers

* revert: port back to original interaction type checkers

* revert: remove unneeded type predicates

* feat: moving modules to its own contained class

* feat: getting global plugins some typings and adding contracts

* chore: fixing up and cleaning code

* feat: adding ModuleConfiguration helper fn and default module manager

* feat: solidifying contract

* revert: delete files

* chore: saving for later

* feat: prototyping module manager

* feat: removing unused types

* feat: update location of module typings

* revert: port back to original interaction type checkers

* revert: port back to original interaction type checkers

* revert: remove unneeded type predicates

* feat: moving modules to its own contained class

* feat: getting global plugins some typings and adding contracts

* chore: fixing up and cleaning code

* feat: adding ModuleConfiguration helper fn and default module manager

* feat: solidifying contract

* revert: delete files

* chore: saving for later

* feat: more merge conflicts

* feat: starting from scratch, add new typings

* feat: refactor ScopedPlugin typing

* feat: strengthening contracts

* chore: edit eslint

* feat: add addDependencies

* feat: add iti di

* feat: constfn util

* revert: delete old files

* remove: ModuleConfiguration

* feat: add sanity checker

* feat: add new error and update dependency

* feat: add sanity check for iti

* feat: add function helpers for di

* feat: add POC for sern di IOC

* feat: refactor DependenciesMap

* revert: remove old code

* feat: refactor makeDependencies fn

* chore(deps): update dependency @typescript-eslint/parser to v5.36.1 (#127)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

* chore(deps): update dependency @typescript-eslint/eslint-plugin to v5.36.1 (#126)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>

* docs: Fix the code example (#128)

* chore(deps): update dependency @typescript-eslint/eslint-plugin to v5.36.2 (#130)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>

* chore(deps): update dependency @typescript-eslint/parser to v5.36.2 (#131)

Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>

* feat: allow constructable modules (#133)

* Update readFile.ts

* Update userDefinedEventsHandling.ts

* Update readyHandler.ts

* fix: ts error

Co-authored-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>

* revert: feat of allow constructable modules (#138)

Revert "feat: allow constructable modules (#133)"

This reverts commit 03936eb2ea.

* feat: update CODEOWNERS

* feat: classmodules@arcs (#143)

* feat: add class based commands

* docs: add deprecation warnings

* feat: add deprecation warnings

* feat: add more deprecation warnings

* feat: add prototype ClassModule abstract class

* feat: add EventModuleClass prototype, change names

* feat: more flexible contract

* feat: EventExecutable

* fix: typo

* feat: made abstract classes because of defaults

* fix: typings

* feat: update Context typings, update to djs v15

* chore: update typescript dependency

* chore: bump version

* chore: update ignore

* chore: prettier

* docs: change readme to be docusaurus compliant

* chore(main): release 1.2.0 (#145)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

* fix(autocomplete): now support multiple autocomplete options (#147)

* chore(main): release 1.2.1 (#148)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

* feat: update location of module typings

* feat: getting global plugins some typings and adding contracts

* feat: adding ModuleConfiguration helper fn and default module manager

* feat: solidifying contract

* feat: removing unused types

* feat: update location of module typings

* feat: moving modules to its own contained class

* feat: getting global plugins some typings and adding contracts

* feat: solidifying contract

* revert: delete files

* chore: saving for later

* feat: more merge conflicts

* feat: starting from scratch, add new typings

* feat: strengthening contracts

* feat: add sanity check for iti

* feat: refactor DependenciesMap

* feat: adding POC back

* docs: add some deprecation warnings

* feat: remove client and sernEmitter

* feat: rebase global_services

* chore: oops rebase pkgjson fix

* fix: typings

* feat: iti update and getting di working

* feat: adding contracts and default provider

* feat: update typings and change logger

* fix: MapDeps typings and useContainer typings

* feat: moving handlers to 2.0

* feat: injecting crash handler

* feat: alpha logging injection?

* feat: injecting modulemanager in interactionhandler

* fix: typos and fixups

* fix: typos and fixups

* feat: moduleManager injection

* fix: crash on no module

* feat: i think optional dependencies work

* feat: add more optional support

* feat: make exclusion optional

* perf: simplify typings and reduce compile time

* fix: some typings adjustment, deprecating a field

* perf: simplifying plugin typings

* feat: remove addExternal

* feat: more simplifying typings

* perf: allow any and interfacify some types

* revert: remove horrendous Override type

* revert: delete interaction type predicates

* fix: unchecked cast to EventEmitter

* perf: remove unneeded creation of instance members

* feat: init test dir

* refactor: rename fn and short circuit name fn

* refactor: insert function

* feat: starting event module onEvent plugins and log payload

* feat: basic eventmodule event plugins?

* refactor: DRY

* feat: unify warning typing

* fix: typings

* feat: more progress on new eventModules

* feat: event modules with plugins!!?!?

* feat: making sernEmitter create default!!, readjust typings

* feat: inject sernEmitter emits and catch possible errors

* feat: add optionality to Logger dep type

* feat: context upgrade, fix circular emissions, crap ton of shit

* feat!: Module -> AnyModule, Added new SelectMenuInteractions, Changed some CommandType names

* feat: rudimentary onClick handler

* feat!: rename select menu command types, no distinguishing between text and alias

* docs: adding docs

* fix: forgot to change

* fix: logging undefined

* revert: remove spreadparams

* feat: export useContainerRaw function and fix smol bug

* feat: add iti DI disposeAll on crash

* fix: deferred execute

* feat!: rename BasePlugin -> Plugin

* feat: commandplugins for event modules, ill test later

* refactor: rename

* refactor: remove import

* feat: add deprecation warnings

* feat: update documentation comments

* perf: static'ify command plugin and event plugin typings

* refactor: remove redundant assignment

* feat: switch to pnpm

* chore: update pnpm lock

* fix: errors crashing and completing subscription

* feat: update example

* fix: overriding dependencies no matter what

* fix: bad rxjs docs

* refactor: destructuring

* feat: update typings for addDisposer

* feat: update packageManager field in package.json

* feat: grammar

Co-authored-by: jacoobes <jacobnguyend@gmail.com>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>
Co-authored-by: Arcs <73959934+HighArcs@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>

.eslintrc

@@ -6,6 +6,8 @@
         "@typescript-eslint/no-non-null-assertion": "off",
         "quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
         "semi": ["error", "always"],
-        "@typescript-eslint/no-empty-interface": 0
+        "@typescript-eslint/no-empty-interface": 0,
+        "@typescript-eslint/ban-types" : 0,
+        "@typescript-eslint/no-explicit-any": "off"
     }
 }

README.md

@@ -58,11 +58,20 @@ const client = new Client({
     GatewayIntentBits.GuildMessages
   ]
 });
+export const useContainer = Sern.makeDependencies({
+    build: root => root
+        .add({ '@sern/client': single(client)  })
+        .add({ '@sern/logger': single(new DefaultLogging()) })
+});
 
+//View docs for all options
 Sern.init({
-  client,   
+	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
-  defaultPrefix,   
+	commands: 'src/commands',
-  commands : 'src/commands',
+	// events: 'src/events' (optional),
+	containerConfig : {
+		get: useContainer
+	}
 });
 
 client.login(token);

package.json

@@ -1,6 +1,7 @@
 {
     "name": "@sern/handler",
-    "version": "1.2.1",
+    "packageManager": "pnpm@7.18.2",
+    "version": "2.0.0",
     "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
     "main": "dist/cjs/index.cjs",
     "module": "dist/esm/index.mjs",
@@ -17,7 +18,8 @@
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
         "build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
-        "publish": "npm run build && npm publish"
+        "publish": "npm run build && npm publish",
+        "pretty": "prettier --write ."
     },
     "keywords": [
         "sern-handler",
@@ -31,6 +33,7 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
+        "iti": "^0.5.0",
         "rxjs": "^7.5.6",
         "ts-pattern": "^4.0.2",
         "ts-results-es": "^3.5.0"
@@ -41,10 +44,10 @@
         "eslint": "8.25.0",
         "prettier": "2.7.1",
         "tsup": "^6.1.3",
-        "typescript": "^4.8.3"
+        "typescript": "4.9.4"
     },
     "peerDependencies": {
-        "discord.js": "^14.5.x"
+        "discord.js": ">= ^14.7.x"
     },
     "repository": {
         "type": "git",

src/handler/contracts/errorHandling.ts

@@ -0,0 +1,49 @@
+import type { Observable } from 'rxjs';
+import type { Logging } from './logging';
+import { useContainerRaw } from '../dependencies/provider';
+import util from 'util';
+export interface ErrorHandling {
+    /**
+     * Number of times the process should throw an error until crashing and exiting
+     */
+    keepAlive : number
+
+    /**
+     * Utility function to crash
+     * @param error
+     */
+    crash(error : Error) : never
+
+    /**
+     * A function that is called on every crash. Updates keepAlive
+     * @param error
+     */
+    updateAlive(error: Error): void
+}
+
+export class DefaultErrorHandling implements ErrorHandling {
+    keepAlive = 5;
+    crash(error: Error): never {
+        throw error;
+    }
+    updateAlive(e: Error) {
+        this.keepAlive--;
+    }
+}
+
+export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
+    return (pload: unknown, caught: Observable<C>) => {
+        // This is done to fit the ErrorHandling contract
+        const err = pload instanceof Error ? pload : Error(util.format(pload));
+        if(crashHandler.keepAlive == 0) {
+            useContainerRaw()?.disposeAll().then(() => {
+                logging?.info({ message: 'Cleaning container and crashing' });
+            });
+            crashHandler.crash(err);
+        }
+        //formatted payload
+        logging?.error({ message: util.format(pload) });
+        crashHandler.updateAlive(err);
+        return caught;
+    };
+}

src/handler/contracts/index.ts

@@ -0,0 +1,3 @@
+export { ErrorHandling, DefaultErrorHandling } from './errorHandling';
+export { Logging, DefaultLogging } from './logging';
+export { ModuleManager, DefaultModuleManager } from './moduleManager';

src/handler/contracts/logging.ts

@@ -0,0 +1,28 @@
+import type { LogPayload } from '../../types/handler';
+
+export interface Logging<T = unknown> {
+    error(payload : LogPayload<T>) : void;
+    warning(payload : LogPayload<T>) : void;
+    info(payload : LogPayload<T>) : void
+    debug(payload : LogPayload<T>) : void
+}
+
+export class DefaultLogging implements Logging {
+    private date = () => new Date();
+    debug(payload: LogPayload): void {
+        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    error(payload: LogPayload): void {
+        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    info(payload: LogPayload): void {
+        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    warning(payload: LogPayload): void {
+        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+}

src/handler/contracts/moduleManager.ts

@@ -0,0 +1,20 @@
+import type { CommandModuleDefs } from '../../types/module';
+import type { CommandType } from '../structures/enums';
+import type { ModuleStore } from '../structures/moduleStore';
+
+
+export interface ModuleManager {
+    get<T extends CommandType>(strat : (ms: ModuleStore) => CommandModuleDefs[T] | undefined) : CommandModuleDefs[T] | undefined
+    set(strat: (ms: ModuleStore) => void) : void
+}
+
+export class DefaultModuleManager implements ModuleManager {
+    constructor(private moduleStore: ModuleStore) {}
+    get<T extends CommandType>(strat: (ms: ModuleStore) => CommandModuleDefs[T] | undefined) {
+        return strat(this.moduleStore);
+    }
+
+    set(strat: (ms: ModuleStore) => void): void {
+        strat(this.moduleStore);
+    }
+}

src/handler/dependencies/index.ts

@@ -0,0 +1,3 @@
+export {
+    useContainer
+} from './provider';

src/handler/dependencies/provider.ts

@@ -0,0 +1,83 @@
+import type { Container } from 'iti';
+import { SernError } from '../structures/errors';
+import { BehaviorSubject } from 'rxjs';
+import * as assert from 'assert';
+import type { Dependencies, MapDeps } from '../../types/handler';
+import SernEmitter from '../sernEmitter';
+import { _const, ok } from '../utilities/functions';
+import { DefaultErrorHandling, DefaultModuleManager, Logging } from '../contracts';
+import { ModuleStore } from '../structures/moduleStore';
+import { Ok, Result } from 'ts-results-es';
+import { DefaultLogging } from '../contracts';
+
+export const containerSubject = new BehaviorSubject<Container<Dependencies, Partial<Dependencies>> | null>(null);
+export function composeRoot<T extends Dependencies>(root: Container<Partial<T>, Partial<Dependencies>>, exclusion: Set<keyof Dependencies>) {
+    const client = root.get('@sern/client');
+    assert.ok(client !== undefined, SernError.MissingRequired);
+    //A utility function checking if a dependency has been declared excluded
+    const excluded = (key: keyof Dependencies) => exclusion.has(key);
+    //Wraps a fetch to the container in a Result, deferring the action
+    const get = <T>(key : keyof Dependencies) => Result.wrap(() => root.get(key) as T);
+    const getOr = (key: keyof Dependencies, elseAction: () => unknown) => {
+        //Gets dependency but if an Err, map to a function that upserts.
+        const dep = get(key).mapErr(() => elseAction);
+        if(dep.err) {
+            //Defers upsert until final check here
+            return dep.val();
+        }
+    };
+    const xGetOr = (key: keyof Dependencies, action: () => unknown) => {
+        if(excluded(key)) {
+            get(key) //if dev created a dependency but excluded, deletes on root composition
+                .andThen(() => Ok(root.delete(key)))
+                .unwrapOr(ok());
+        } else {
+            getOr(key, action);
+        }
+
+    };
+    xGetOr('@sern/emitter', () => root.upsert({
+            '@sern/emitter' : _const(new SernEmitter())
+        })
+    );
+    //An "optional" dependency
+    xGetOr('@sern/logger', () => {
+        root.upsert({
+                '@sern/logger' : _const(new DefaultLogging())
+            });
+        }
+    );
+    xGetOr('@sern/store', () => root.upsert({
+            '@sern/store' : _const(new ModuleStore())
+        })
+    );
+    xGetOr('@sern/modules', () => root.upsert((ctx) => ({
+            '@sern/modules' : _const(new DefaultModuleManager(ctx['@sern/store'] as ModuleStore))
+        }))
+    );
+    xGetOr('@sern/errors', () => root.upsert({
+            '@sern/errors': _const(new DefaultErrorHandling())
+        })
+    );
+    //If logger exists, log info, else do nothing.
+    get<Logging>('@sern/logger')
+        .map((logger => logger.info({ message: 'All dependencies loaded successfully' })))
+        .unwrapOr(ok());
+}
+
+
+export function useContainer<T extends Dependencies>() {
+    const container = containerSubject.getValue()! as unknown as Container<T, {}>;
+    assert.ok(container !== null, 'useContainer was called before Sern#init');
+    //weird edge case, why can i not use _const here?
+    return <V extends (keyof T)[]>(...keys: [...V]) =>
+        keys.map(key => Result.wrap(() => container.get(key)).unwrapOr(undefined)) as MapDeps<T, V>;
+}
+
+/**
+ * Returns the underlying data structure holding all dependencies.
+ * Exposes some methods from iti
+ */
+export function useContainerRaw() {
+    return containerSubject.getValue();
+}

src/handler/events/dispatchers.ts

@@ -1,32 +1,36 @@
-import type {
-    BothCommand,
-    ButtonCommand,
-    ContextMenuMsg,
-    ContextMenuUser,
-    ModalSubmitCommand,
-    SelectMenuCommand,
-    SlashCommand,
-} from '../structures/module';
 import Context from '../structures/context';
-import type { SlashOptions } from '../../types/handler';
+import type { Payload, SlashOptions } from '../../types/handler';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
+import { arrAsync } from '../utilities/arrAsync';
 import { controller } from '../sern';
 import type {
     ButtonInteraction,
     ModalSubmitInteraction,
-    SelectMenuInteraction,
     AutocompleteInteraction,
     ChatInputCommandInteraction,
     Interaction,
     UserContextMenuCommandInteraction,
     MessageContextMenuCommandInteraction,
 } from 'discord.js';
-import { isAutocomplete } from '../utilities/predicates';
 import { SernError } from '../structures/errors';
 import treeSearch from '../utilities/treeSearch';
+import type {
+    BothCommand,
+    ButtonCommand, ContextMenuMsg,
+    ContextMenuUser,
+    ModalSubmitCommand,
+    StringSelectCommand,
+    SlashCommand, UserSelectCommand, ChannelSelectCommand, MentionableSelectCommand, RoleSelectCommand,
+} from '../../types/module';
+import type SernEmitter from '../sernEmitter';
+import { EventEmitter } from 'events';
+import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from '../structures/events';
+import * as assert from 'assert';
+import { reducePlugins } from '../utilities/functions';
+import { concatMap, from, fromEvent, map, of } from 'rxjs';
+import type { MessageComponentInteraction } from 'discord.js';
 
 export function applicationCommandDispatcher(interaction: Interaction) {
-    if (isAutocomplete(interaction)) {
+    if (interaction.isAutocomplete()) {
         return dispatchAutocomplete(interaction);
     } else {
         const ctx = Context.wrap(interaction as ChatInputCommandInteraction);
@@ -34,7 +38,7 @@ export function applicationCommandDispatcher(interaction: Interaction) {
         return (mod: BothCommand | SlashCommand) => ({
             mod,
             execute: () => mod.execute(ctx, args),
-            eventPluginRes: asyncResolveArray(
+            eventPluginRes: arrAsync(
                 mod.onEvent.map(plugs => plugs.execute([ctx, args], controller)),
             ),
         });
@@ -48,7 +52,7 @@ export function dispatchAutocomplete(interaction: AutocompleteInteraction) {
             return {
                 mod,
                 execute: () => selectedOption.command.execute(interaction),
-                eventPluginRes: asyncResolveArray(
+                eventPluginRes: arrAsync(
                     selectedOption.command.onEvent.map(e => e.execute(interaction, controller)),
                 ),
             };
@@ -63,7 +67,7 @@ export function modalCommandDispatcher(interaction: ModalSubmitInteraction) {
     return (mod: ModalSubmitCommand) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
@@ -73,18 +77,19 @@ export function buttonCommandDispatcher(interaction: ButtonInteraction) {
     return (mod: ButtonCommand) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
 }
 
-export function selectMenuCommandDispatcher(interaction: SelectMenuInteraction) {
+export function selectMenuCommandDispatcher(interaction: MessageComponentInteraction) {
-    return (mod: SelectMenuCommand) => ({
+    //safe casts because command type runtime check
+    return (mod: StringSelectCommand | UserSelectCommand | ChannelSelectCommand | MentionableSelectCommand | RoleSelectCommand) => ({
         mod,
-        execute: () => mod.execute(interaction),
+        execute: () => mod.execute(interaction as never),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
+            mod.onEvent.map(plugs => plugs.execute([interaction as never], controller)),
         ),
     });
 }
@@ -93,7 +98,7 @@ export function ctxMenuUserDispatcher(interaction: UserContextMenuCommandInterac
     return (mod: ContextMenuUser) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
@@ -103,8 +108,63 @@ export function ctxMenuMsgDispatcher(interaction: MessageContextMenuCommandInter
     return (mod: ContextMenuMsg) => ({
         mod,
         execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
+        eventPluginRes: arrAsync(
             mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
         ),
     });
 }
+
+export function sernEmitterDispatcher(e: SernEmitter) {
+    return(cmd: SernEventCommand & { name: string }) => ({
+        source: e,
+        cmd,
+        execute: fromEvent(e, cmd.name)
+            .pipe( map( event => ({
+                event,
+                executeEvent: of(event).pipe(concatMap(event =>
+                        reducePlugins(from(
+                        arrAsync(
+                            cmd.onEvent.map(plug => plug.execute([event as Payload], controller))
+                        ))
+                    )))
+            })))
+    });
+}
+
+export function discordEventDispatcher(e: EventEmitter) {
+    return (cmd: DiscordEventCommand & { name: string }) => ({
+        source: e,
+        cmd,
+        execute: fromEvent(e, cmd.name)
+                .pipe( map( event => ({
+                    event,
+                    executeEvent: of(event).pipe(concatMap( event =>
+                        reducePlugins(from(
+                        arrAsync(
+                            // god forbid I use any!!!
+                            cmd.onEvent.map(plug => plug.execute([event as any], controller))
+                        ))
+                      )))
+                })))
+    });
+}
+
+export function externalEventDispatcher(e: (e:ExternalEventCommand) => unknown) {
+    return (cmd: ExternalEventCommand & { name: string}) => {
+        const external = e(cmd);
+        assert.ok(external instanceof EventEmitter, `${e} is not an EventEmitter`);
+        return {
+            source: external,
+            cmd,
+            execute: fromEvent(external, cmd.name)
+                    .pipe(map(event => ({
+                        event,
+                        executeEvent : of(event).pipe(concatMap(event =>
+                            reducePlugins(from(arrAsync(
+                                cmd.onEvent.map(plug => plug.execute([event], controller))
+                            )))
+                        )),
+                    })))
+        };
+    };
+}

src/handler/events/eventsHandler.ts

@@ -1,10 +1,31 @@
 import type Wrapper from '../structures/wrapper';
 import { Subject, type Observable } from 'rxjs';
+import type { EventEmitter } from 'events';
+import type SernEmitter from '../sernEmitter';
+import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
 
 export abstract class EventsHandler<T> {
     protected payloadSubject = new Subject<T>();
     protected abstract discordEvent: Observable<unknown>;
-    protected constructor(protected wrapper: Wrapper) {}
+    protected client: EventEmitter;
+    protected emitter: SernEmitter;
+    protected crashHandler: ErrorHandling;
+    protected logger?: Logging;
+    protected modules: ModuleManager;
+    protected constructor({ containerConfig }: Wrapper) {
+        const [
+            client,
+            emitter,
+            crash,
+            modules,
+            logger,
+        ] = containerConfig.get('@sern/client', '@sern/emitter', '@sern/errors', '@sern/modules', '@sern/logger');
+        this.logger = logger as Logging|undefined;
+        this.modules = modules as ModuleManager;
+        this.client = client as EventEmitter;
+        this.emitter = emitter as SernEmitter;
+        this.crashHandler = crash as ErrorHandling;
+    }
     protected abstract init(): void;
     protected abstract setState(state: T): void;
 }

src/handler/events/interactionHandler.ts

@@ -2,14 +2,6 @@ import type { Interaction } from 'discord.js';
 import { catchError, concatMap, from, fromEvent, map, Observable } from 'rxjs';
 import type Wrapper from '../structures/wrapper';
 import { EventsHandler } from './eventsHandler';
-import {
-    isApplicationCommand,
-    isAutocomplete,
-    isMessageComponent,
-    isModalSubmit,
-} from '../utilities/predicates';
-import * as Files from '../utilities/readFile';
-import type { CommandModule } from '../structures/module';
 import { SernError } from '../structures/errors';
 import { CommandType, PayloadType } from '../structures/enums';
 import { match, P } from 'ts-pattern';
@@ -24,69 +16,69 @@ import {
 import type {
     ButtonInteraction,
     ModalSubmitInteraction,
-    SelectMenuInteraction,
     UserContextMenuCommandInteraction,
     MessageContextMenuCommandInteraction,
 } from 'discord.js';
 import { executeModule } from './observableHandling';
+import type { CommandModule } from '../../types/module';
+import { handleError } from '../contracts/errorHandling';
+import type { ModuleStore } from '../structures/moduleStore';
+import type { MessageComponentInteraction } from 'discord.js';
 
 export default class InteractionHandler extends EventsHandler<{
     event: Interaction;
     mod: CommandModule;
 }> {
     protected override discordEvent: Observable<Interaction>;
-
+    constructor(wrapper: Wrapper) {
-    constructor(protected wrapper: Wrapper) {
         super(wrapper);
-        this.discordEvent = <Observable<Interaction>>fromEvent(wrapper.client, 'interactionCreate');
+        this.discordEvent = <Observable<Interaction>>fromEvent(this.client, 'interactionCreate');
         this.init();
 
         this.payloadSubject
             .pipe(
                 map(this.processModules),
-                concatMap(({ mod, execute, eventPluginRes }) => {
+                concatMap(({ mod, execute, eventPluginRes }) =>
-                    //resolve all the Results from event plugins
+                    from(eventPluginRes).pipe(map(res => ({ mod, res, execute }))) //resolve all the Results from event plugins
-                    return from(eventPluginRes).pipe(map(res => ({ mod, res, execute })));
+                ),
-                }),
                 concatMap(payload => executeModule(wrapper, payload)),
-                catchError((err, caught) => {
+                catchError(handleError(this.crashHandler, this.logger)),
-                    wrapper.sernEmitter?.emit('error', err);
-                    return caught;
-                }),
             )
             .subscribe();
     }
 
     override init() {
+        const get = (cb: (ms: ModuleStore) => CommandModule|undefined) => {
+           return this.modules.get(cb);
+        };
         this.discordEvent.subscribe({
             next: event => {
-                if (isMessageComponent(event)) {
+                if (event.isMessageComponent()) {
-                    const mod = Files.MessageCompCommands[event.componentType].get(event.customId);
+                    const mod = get(ms  =>
+                        ms.InteractionHandlers[event.componentType].get(event.customId));
                     this.setState({ event, mod });
-                } else if (isApplicationCommand(event) || isAutocomplete(event)) {
+                } else if (event.isCommand() || event.isAutocomplete()) {
-                    const mod =
+                    const mod = get(ms =>
-                        Files.ApplicationCommands[event.commandType].get(event.commandName) ??
+                        ms.ApplicationCommands[event.commandType].get(event.commandName) ??
-                        Files.BothCommands.get(event.commandName);
+                        ms.BothCommands.get(event.commandName)
+                    );
                     this.setState({ event, mod });
-                } else if (isModalSubmit(event)) {
+                } else if (event.isModalSubmit()) {
-                    /**
+                    const mod = get((ms) => ms.InteractionHandlers[5].get(event.customId));
-                     * maybe move modal submits into message component object maps?
-                     */
-                    const mod = Files.ModalSubmitCommands.get(event.customId);
                     this.setState({ event, mod });
                 } else {
                     throw Error('This interaction is not supported yet');
                 }
             },
             error: reason => {
-                this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason });
+                this.emitter.emit('error', { type: PayloadType.Failure, reason });
             },
         });
     }
 
     protected setState(state: { event: Interaction; mod: CommandModule | undefined }): void {
         if (state.mod === undefined) {
-            this.wrapper?.sernEmitter?.emit('warning', 'Found no module for this interaction');
+            this.emitter.emit('warning',{ type: PayloadType.Warning, reason: 'Found no module for this interaction' });
         } else {
             //if statement above checks already, safe cast
             this.payloadSubject.next(state as { event: Interaction; mod: CommandModule });
@@ -105,19 +97,23 @@ export default class InteractionHandler extends EventsHandler<{
             )
             .with({ type: CommandType.Button }, buttonCommandDispatcher(event as ButtonInteraction))
             .with(
-                { type: CommandType.MenuSelect },
+                { type: P.union(
-                selectMenuCommandDispatcher(event as SelectMenuInteraction),
+                        CommandType.RoleSelect,
+                        CommandType.StringSelect,
+                        CommandType.UserSelect,
+                        CommandType.MentionableSelect,
+                        CommandType.ChannelSelect
+                    ) },
+                selectMenuCommandDispatcher(event as MessageComponentInteraction),
             )
             .with(
-                { type: CommandType.MenuUser },
+                { type: CommandType.CtxUser },
                 ctxMenuUserDispatcher(event as UserContextMenuCommandInteraction),
             )
             .with(
-                { type: CommandType.MenuMsg },
+                { type: CommandType.CtxMsg },
                 ctxMenuMsgDispatcher(event as MessageContextMenuCommandInteraction),
             )
-            .otherwise(() => {
+            .otherwise(() => this.crashHandler.crash(Error(SernError.MismatchModule)));
-                throw Error(SernError.MismatchModule);
-            });
     }
 }

src/handler/events/messageHandler.ts

@@ -5,11 +5,12 @@ import type { Message } from 'discord.js';
 import { executeModule, ignoreNonBot, isOneOfCorrectModules } from './observableHandling';
 import { fmt } from '../utilities/messageHelpers';
 import Context from '../structures/context';
-import * as Files from '../utilities/readFile';
-import type { TextCommand } from '../structures/module';
 import { CommandType, PayloadType } from '../structures/enums';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
+import { arrAsync } from '../utilities/arrAsync';
 import { controller } from '../sern';
+import type { CommandModule, TextCommand } from '../../types/module';
+import { handleError } from '../contracts/errorHandling';
+import type { ModuleStore } from '../structures/moduleStore';
 
 export default class MessageHandler extends EventsHandler<{
     ctx: Context;
@@ -17,29 +18,22 @@ export default class MessageHandler extends EventsHandler<{
     mod: TextCommand;
 }> {
     protected discordEvent: Observable<Message>;
-    public constructor(wrapper: Wrapper) {
+    public constructor(protected wrapper: Wrapper) {
         super(wrapper);
-        this.discordEvent = <Observable<Message>>fromEvent(wrapper.client, 'messageCreate');
+        this.discordEvent = <Observable<Message>>fromEvent(this.client, 'messageCreate');
         this.init();
         this.payloadSubject
             .pipe(
                 switchMap(({ mod, ctx, args }) => {
-                    const res = asyncResolveArray(
+                    const res = arrAsync(
-                        mod.onEvent.map(ePlug => {
+                            mod.onEvent.map(ep => ep.execute([ctx, args], controller)),
-                            return ePlug.execute([ctx, args], controller);
-                        }),
                     );
-                    const execute = () => {
+                    const execute = () => mod.execute(ctx, args);
-                        return mod.execute(ctx, args);
-                    };
                     //resolves the promise and re-emits it back into source
                     return from(res).pipe(map(res => ({ mod, execute, res })));
                 }),
                 concatMap(payload => executeModule(wrapper, payload)),
-                catchError((err, caught) => {
+                catchError(handleError(this.crashHandler, this.logger)),
-                    wrapper.sernEmitter?.emit('error', err);
-                    return caught;
-                }),
             )
             .subscribe();
     }
@@ -47,6 +41,9 @@ export default class MessageHandler extends EventsHandler<{
     protected init(): void {
         if (this.wrapper.defaultPrefix === undefined) return; //for now, just ignore if prefix doesn't exist
         const { defaultPrefix } = this.wrapper;
+        const get = (cb: (ms: ModuleStore) => CommandModule | undefined) => {
+              return this.modules.get(cb);
+        };
         this.discordEvent
             .pipe(
                 ignoreNonBot(this.wrapper.defaultPrefix),
@@ -55,10 +52,10 @@ export default class MessageHandler extends EventsHandler<{
                     return {
                         ctx: Context.wrap(message),
                         args: <['text', string[]]>['text', rest],
-                        mod:
+                        mod: get(ms =>
-                            Files.TextCommands.text.get(prefix) ??
+                            ms.TextCommands.get(prefix) ??
-                            Files.BothCommands.get(prefix) ??
+                            ms.BothCommands.get(prefix)
-                            Files.TextCommands.aliases.get(prefix),
+                        ),
                     };
                 }),
                 concatMap(element =>
@@ -71,7 +68,7 @@ export default class MessageHandler extends EventsHandler<{
             .subscribe({
                 next: value => this.setState(value),
                 error: reason =>
-                    this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason }),
+                    this.emitter.emit('error', { type: PayloadType.Failure, reason }),
             });
     }
 

src/handler/events/observableHandling.ts

@@ -1,11 +1,16 @@
 import type { Message } from 'discord.js';
-import { concatMap, from, Observable, of, tap, throwError } from 'rxjs';
+import { concatMap, from, map, Observable, of, switchMap, tap, throwError, toArray } from 'rxjs';
 import { SernError } from '../structures/errors';
-import type { Module, CommandModuleDefs, CommandModule } from '../structures/module';
 import { Result } from 'ts-results-es';
 import type { CommandType } from '../structures/enums';
 import type Wrapper from '../structures/wrapper';
-import { PayloadType } from '../structures/enums';
+import { PayloadType, PluginType } from '../structures/enums';
+import type { CommandModule, CommandModuleDefs, AnyModule } from '../../types/module';
+import { _const } from '../utilities/functions';
+import type SernEmitter from '../sernEmitter';
+import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
+import type { Awaitable } from 'discord.js';
+import { processCommandPlugins } from './userDefinedEventsHandling';
 
 export function ignoreNonBot(prefix: string) {
     return (src: Observable<Message>) =>
@@ -31,7 +36,7 @@ export function ignoreNonBot(prefix: string) {
  * If the current value in Result stream is an error, calls callback.
  * @param cb
  */
-export function errTap<T extends Module>(cb: (err: SernError) => void) {
+export function errTap<T extends AnyModule>(cb: (err: SernError) => void) {
     return (src: Observable<Result<{ mod: T; absPath: string }, SernError>>) =>
         new Observable<{ mod: T; absPath: string }>(subscriber => {
             return src.subscribe({
@@ -55,12 +60,12 @@ export function isOneOfCorrectModules<T extends readonly CommandType[]>(...input
             return src.subscribe({
                 next(mod) {
                     if (mod === undefined) {
-                        return throwError(() => SernError.UndefinedModule);
+                        return throwError(_const(SernError.UndefinedModule));
                     }
                     if (inputs.some(type => (mod.type & type) !== 0)) {
                         subscriber.next(mod as CommandModuleDefs[T[number]]);
                     } else {
-                        return throwError(() => SernError.MismatchModule);
+                        return throwError(_const(SernError.MismatchModule));
                     }
                 },
                 error: e => subscriber.error(e),
@@ -78,10 +83,9 @@ export function executeModule(
         res: Result<void, void>[];
     },
 ) {
+    const emitter = wrapper.containerConfig.get('@sern/emitter')[0] as SernEmitter;
     if (payload.res.every(el => el.ok)) {
-        const executeFn = Result.wrapAsync<unknown, Error | string>(() =>
+        const executeFn = Result.wrapAsync<unknown, Error | string>(() => Promise.resolve(payload.execute()));
-            Promise.resolve(payload.execute()),
-        );
         return from(executeFn).pipe(
             concatMap(res => {
                 if (res.err) {
@@ -93,7 +97,7 @@ export function executeModule(
                 }
                 return of(res.val).pipe(
                     tap(() =>
-                        wrapper.sernEmitter?.emit('module.activate', {
+                        emitter.emit('module.activate', {
                             type: PayloadType.Success,
                             module: payload.mod,
                         }),
@@ -102,7 +106,7 @@ export function executeModule(
             }),
         );
     } else {
-        wrapper.sernEmitter?.emit('module.activate', {
+        emitter.emit('module.activate', {
             type: PayloadType.Failure,
             module: payload.mod,
             reason: SernError.PluginFailure,
@@ -110,3 +114,30 @@ export function executeModule(
         return of(undefined);
     }
 }
+
+export function resolvePlugins({ mod, cmdPluginRes }: {
+    mod: DefinedCommandModule | DefinedEventModule;
+    cmdPluginRes: {
+        execute: Awaitable<Result<void, void>>;
+        type: PluginType.Command;
+    }[];
+}) {
+    if (mod.plugins.length === 0) {
+        return of({ mod, pluginRes: [] });
+    }
+    // modules with no event plugins are ignored in the previous
+    return from(cmdPluginRes).pipe(
+        switchMap(pl =>
+            from(pl.execute).pipe(
+                map(execute => ({ ...pl, execute })),
+                toArray(),
+            ),
+        ),
+        map(pluginRes => ({ mod, pluginRes })),
+    );
+}
+
+export function processPlugins(payload: { mod: DefinedCommandModule | DefinedEventModule; absPath: string }) {
+    const cmdPluginRes = processCommandPlugins(payload);
+    return of({ mod: payload.mod, cmdPluginRes });
+}

src/handler/events/readyHandler.ts

@@ -1,18 +1,18 @@
 import { EventsHandler } from './eventsHandler';
 import type Wrapper from '../structures/wrapper';
-import { concatMap, fromEvent, Observable, map, take, of, from, toArray, switchMap } from 'rxjs';
+import { concatMap, fromEvent, Observable, map, take } from 'rxjs';
-import type { CommandModule } from '../structures/module';
 import * as Files from '../utilities/readFile';
-import { errTap } from './observableHandling';
+import { errTap, processPlugins, resolvePlugins } from './observableHandling';
-import type { DefinedCommandModule } from '../../types/handler';
+import { CommandType, PayloadType } from '../structures/enums';
-import { basename } from 'path';
-import { CommandType, PayloadType, PluginType } from '../structures/enums';
-import { processCommandPlugins } from './userDefinedEventsHandling';
-import type { Awaitable } from 'discord.js';
 import { SernError } from '../structures/errors';
 import { match } from 'ts-pattern';
-import { type Result, Err, Ok } from 'ts-results-es';
+import { Result } from 'ts-results-es';
 import { ApplicationCommandType, ComponentType } from 'discord.js';
+import type { CommandModule } from '../../types/module';
+import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
+import type { ModuleManager } from '../contracts';
+import type { ModuleStore } from '../structures/moduleStore';
+import { _const, err, nameOrFilename, ok } from '../utilities/functions';
 
 export default class ReadyHandler extends EventsHandler<{
     mod: DefinedCommandModule;
@@ -21,12 +21,12 @@ export default class ReadyHandler extends EventsHandler<{
     protected discordEvent!: Observable<{ mod: CommandModule; absPath: string }>;
     constructor(wrapper: Wrapper) {
         super(wrapper);
-        const ready$ = fromEvent(this.wrapper.client, 'ready').pipe(take(1));
+        const ready$ = fromEvent(this.client, 'ready').pipe(take(1));
         this.discordEvent = ready$.pipe(
             concatMap(() =>
-                Files.buildData<CommandModule>(this.wrapper.commands).pipe(
+                Files.buildData<CommandModule>(wrapper.commands).pipe(
                     errTap(reason =>
-                        wrapper.sernEmitter?.emit('module.register', {
+                        this.emitter.emit('module.register', {
                             type: PayloadType.Failure,
                             module: undefined,
                             reason,
@@ -38,22 +38,21 @@ export default class ReadyHandler extends EventsHandler<{
         this.init();
         this.payloadSubject
             .pipe(
-                concatMap(payload => this.processPlugins(payload)),
+                concatMap(processPlugins),
-                concatMap(payload => this.resolvePlugins(payload)),
+                concatMap(resolvePlugins),
-            )
+            ).subscribe(payload => {
-            .subscribe(payload => {
                 const allPluginsSuccessful = payload.pluginRes.every(({ execute }) => execute.ok);
                 if (allPluginsSuccessful) {
-                    const res = registerModule(payload.mod);
+                    const res = registerModule(this.modules, payload.mod);
                     if (res.err) {
-                        throw Error(SernError.InvalidModuleType);
+                        this.crashHandler.crash(Error(SernError.InvalidModuleType));
                     }
-                    wrapper.sernEmitter?.emit('module.register', {
+                    this.emitter.emit('module.register', {
                         type: PayloadType.Success,
                         module: payload.mod,
                     });
                 } else {
-                    wrapper.sernEmitter?.emit('module.register', {
+                    this.emitter.emit('module.register', {
                         type: PayloadType.Failure,
                         module: payload.mod,
                         reason: SernError.PluginFailure,
@@ -68,45 +67,13 @@ export default class ReadyHandler extends EventsHandler<{
         return {
             absPath,
             mod: {
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
+                name: nameOrFilename(mod.name, absPath),
                 description: mod?.description ?? '...',
                 ...mod,
             },
         };
     }
 
-    private resolvePlugins({
-        mod,
-        cmdPluginRes,
-    }: {
-        mod: DefinedCommandModule;
-        cmdPluginRes: {
-            name: string;
-            description: string;
-            execute: Awaitable<Result<void, void>>;
-            type: PluginType.Command;
-        }[];
-    }) {
-        if (mod.plugins.length === 0) {
-            return of({ mod, pluginRes: [] });
-        }
-        // modules with no event plugins are ignored in the previous
-        return from(cmdPluginRes).pipe(
-            switchMap(pl =>
-                from(pl.execute).pipe(
-                    map(execute => ({ ...pl, execute })),
-                    toArray(),
-                ),
-            ),
-            map(pluginRes => ({ mod, pluginRes })),
-        );
-    }
-
-    private processPlugins(payload: { mod: DefinedCommandModule; absPath: string }) {
-        const cmdPluginRes = processCommandPlugins(this.wrapper, payload);
-        return of({ mod: payload.mod, cmdPluginRes });
-    }
-
     protected init() {
         this.discordEvent.pipe(map(ReadyHandler.intoDefinedModule)).subscribe({
             next: value => this.setState(value),
@@ -118,42 +85,50 @@ export default class ReadyHandler extends EventsHandler<{
     }
 }
 
-function registerModule(mod: DefinedCommandModule): Result<void, void> {
+function registerModule(manager: ModuleManager, mod: DefinedCommandModule | DefinedEventModule): Result<void, void> {
     const name = mod.name;
-    return match<DefinedCommandModule>(mod)
+    const insert = (cb: (ms: ModuleStore) => void) => {
+        const set = Result.wrap(_const(manager.set(cb)));
+        return set.ok ? ok() : err();
+    };
+    return match<DefinedCommandModule | DefinedEventModule>(mod)
         .with({ type: CommandType.Text }, mod => {
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
+            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
-            Files.TextCommands.text.set(name, mod);
+            return insert(ms => ms.TextCommands.set(name, mod));
-            return Ok.EMPTY;
-        })
-        .with({ type: CommandType.Slash }, mod => {
-            Files.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod);
-            return Ok.EMPTY;
         })
+        .with({ type: CommandType.Slash }, mod =>
+            insert(ms => ms.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod))
+        )
         .with({ type: CommandType.Both }, mod => {
-            Files.BothCommands.set(name, mod);
+            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
-            mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
+            return insert( ms => ms.BothCommands.set(name, mod));
-            return Ok.EMPTY;
         })
-        .with({ type: CommandType.MenuUser }, mod => {
+        .with({ type: CommandType.CtxUser }, mod =>
-            Files.ApplicationCommands[ApplicationCommandType.User].set(name, mod);
+             insert(ms => ms.ApplicationCommands[ApplicationCommandType.User].set(name, mod))
-            return Ok.EMPTY;
+        )
-        })
+        .with({ type: CommandType.CtxMsg }, mod =>
-        .with({ type: CommandType.MenuMsg }, mod => {
+             insert(ms => ms.ApplicationCommands[ApplicationCommandType.Message].set(name, mod))
-            Files.ApplicationCommands[ApplicationCommandType.Message].set(name, mod);
+        )
-            return Ok.EMPTY;
+        .with({ type: CommandType.Button }, mod =>
-        })
+             insert(ms => ms.InteractionHandlers[ComponentType.Button].set(name, mod))
-        .with({ type: CommandType.Button }, mod => {
+        )
-            Files.MessageCompCommands[ComponentType.Button].set(name, mod);
+        .with({ type: CommandType.StringSelect }, mod =>
-            return Ok.EMPTY;
+             insert(ms => ms.InteractionHandlers[ComponentType.StringSelect].set(name, mod))
-        })
+        )
-        .with({ type: CommandType.MenuSelect }, mod => {
+        .with( { type: CommandType.MentionableSelect }, mod =>
-            Files.MessageCompCommands[ComponentType.SelectMenu].set(name, mod);
+            insert (ms => ms.InteractionHandlers[ComponentType.MentionableSelect].set(name, mod))
-            return Ok.EMPTY;
+        )
-        })
+        .with( { type: CommandType.ChannelSelect }, mod =>
-        .with({ type: CommandType.Modal }, mod => {
+            insert ( ms => ms.InteractionHandlers[ComponentType.ChannelSelect].set(name, mod))
-            Files.ModalSubmitCommands.set(name, mod);
+        )
-            return Ok.EMPTY;
+        .with( { type: CommandType.UserSelect }, mod =>
-        })
+            insert ( ms => ms.InteractionHandlers[ComponentType.UserSelect].set(name, mod))
-        .otherwise(() => Err.EMPTY);
+        )
+        .with( { type: CommandType.RoleSelect}, mod =>
+            insert ( ms => ms.InteractionHandlers[ComponentType.RoleSelect].set(name, mod))
+        )
+        .with({ type: CommandType.Modal }, mod =>
+            insert(ms => ms.ModalSubmit.set(name, mod))
+        )
+        .otherwise(err);
 }

src/handler/events/userDefinedEventsHandling.ts

@@ -1,87 +1,108 @@
-import { from, fromEvent, map } from 'rxjs';
+import { catchError, concatMap, filter, from, iif, map, of, tap, toArray } from 'rxjs';
-import * as Files from '../utilities/readFile';
+import { buildData } from '../utilities/readFile';
-import { buildData, ExternalEventEmitters } from '../utilities/readFile';
 import { controller } from '../sern';
-import type {
+import type { DefinedCommandModule, DefinedEventModule, Dependencies } from '../../types/handler';
-    DefinedCommandModule,
+import { PayloadType, PluginType } from '../structures/enums';
-    DefinedEventModule,
-    EventInput,
-    SpreadParams,
-} from '../../types/handler';
-import type { EventModule } from '../structures/module';
-import { PayloadType } from '../structures/enums';
 import type Wrapper from '../structures/wrapper';
-import { basename } from 'path';
+import { isDiscordEvent, isExternalEvent, isSernEvent } from '../utilities/predicates';
+import { errTap, processPlugins, resolvePlugins } from './observableHandling';
+import type { AnyModule, EventModule } from '../../types/module';
+import type { EventEmitter } from 'events';
+import type SernEmitter from '../sernEmitter';
+import { nameOrFilename, reducePlugins } from '../utilities/functions';
 import { match } from 'ts-pattern';
-import { isDiscordEvent, isSernEvent } from '../utilities/predicates';
+import { discordEventDispatcher, externalEventDispatcher, sernEmitterDispatcher } from './dispatchers';
-import { errTap } from './observableHandling';
+import type { ErrorHandling, Logging } from '../contracts';
+import { SernError } from '../structures/errors';
+import { handleError } from '../contracts/errorHandling';
+import type { Awaitable } from 'discord.js';
+import type { Result } from 'ts-results-es';
 
 /**
  * Utility function to process command plugins for all Modules
- * @param wrapper
  * @param payload
  */
-export function processCommandPlugins<T extends DefinedCommandModule>(
+export function processCommandPlugins<T extends DefinedCommandModule | DefinedEventModule>(
-    wrapper: Wrapper,
     payload: { mod: T; absPath: string },
-) {
+): {type: PluginType.Command, execute: Awaitable<Result<void,void>>}[]  {
     return payload.mod.plugins.map(plug => ({
-        ...plug,
+        type: plug.type,
-        name: plug?.name ?? 'Unnamed Plugin',
+        execute: plug.execute(payload as any, controller),
-        description: plug?.description ?? '...',
-        execute: plug.execute(wrapper, payload, controller),
     }));
 }
 
-export function processEvents(wrapper: Wrapper, events: EventInput) {
+export function processEvents({ containerConfig, events }: Wrapper) {
-    const eventStream$ = eventObservable$(wrapper, events);
+    const [
-    const normalize$ = eventStream$.pipe(
+        client,
-        map(({ mod, absPath }) => {
+        error,
-            return <DefinedEventModule>{
+        sernEmitter,
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
+        logging
-                description: mod?.description ?? '...',
+    ] = containerConfig.get('@sern/client', '@sern/errors', '@sern/emitter', '@sern/logger') as [EventEmitter, ErrorHandling, SernEmitter, Logging?];
+    const lazy = (k: string) => containerConfig.get(k as keyof Dependencies)[0];
+    const eventStream$ = eventObservable$(events!, sernEmitter);
+    const emitSuccess$ = (mod: AnyModule) =>
+        of({ type: PayloadType.Failure, module: mod, reason: SernError.PluginFailure })
+        .pipe(tap( it => sernEmitter.emit('module.register', it)));
+    const emitFailure$ = (mod: AnyModule) =>
+        of({ type: PayloadType.Success, module: mod, } as const)
+        .pipe(tap(it => sernEmitter.emit('module.register', it)));
+    const eventCreation$ = eventStream$.pipe(
+        map(({ mod, absPath }) => ({
+            mod : {
+                name: nameOrFilename(mod.name, absPath),
                 ...mod,
-            };
+            } as DefinedEventModule,
-        }),
+            absPath
+        })),
+        concatMap(processPlugins),
+        concatMap(resolvePlugins),
+        //Reduces pluginRes (generated from above) into a single boolean
+        concatMap(({pluginRes, mod}) => from(pluginRes)
+            .pipe(
+                map(pl => pl.execute),
+                toArray(),
+                reducePlugins,
+                map(success => ({ success, mod }))
+            )),
+        concatMap(({ success, mod }) =>
+            iif(() => success,
+                emitFailure$(mod),
+                emitSuccess$(mod)
+            ).pipe(
+                filter(res => res.type === PayloadType.Success),
+                map(() => mod)
+            )
+        ),
     );
-    normalize$.subscribe(e => {
+    eventCreation$.subscribe(e => {
-        const emitter = isSernEvent(e)
+        const payload = match(e)
-            ? wrapper?.sernEmitter
+            .when(isSernEvent, sernEmitterDispatcher(sernEmitter))
-            : isDiscordEvent(e)
+            .when(isDiscordEvent, discordEventDispatcher(client))
-            ? wrapper.client
+            .when(isExternalEvent, externalEventDispatcher(e => lazy(e.emitter)))
-            : ExternalEventEmitters.get(e.emitter);
+            .otherwise(() => error.crash(Error(SernError.InvalidModuleType)));
-        if (emitter === undefined) {
+       payload
-            throw new Error(`Cannot find event emitter as it is undefined`);
+            .execute
-        }
+            .pipe(
-        //Would add sern event emitter for events loaded, attached onto sern emitter, but could lead to unwanted behavior!
+                concatMap(({event, executeEvent}) =>
-        fromEvent(emitter, e.name, e.execute as SpreadParams<typeof e.execute>).subscribe();
+                    executeEvent
+                    .pipe( tap(success => {
+                        if(success)
+                            payload.cmd.execute(event as never);
+                    }), catchError(handleError(error, logging)))
+                ),
+            ).subscribe();
     });
 }
 
-function eventObservable$({ sernEmitter }: Wrapper, events: EventInput) {
+function eventObservable$(events: string, emitter: SernEmitter) {
-    return match(events)
+        return buildData<EventModule>(events)
-        .when(Array.isArray, (arr: { mod: EventModule; absPath: string }[]) => {
+            .pipe(
-            return from(arr);
+                errTap(reason =>
-        })
+                   emitter.emit('module.register', {
-        .when(
+                        type: PayloadType.Failure,
-            e => typeof e === 'string',
+                        module: undefined,
-            (eventsDir: string) => {
+                        reason,
-                return buildData<EventModule>(eventsDir).pipe(
+                    }),
-                    errTap(reason =>
+                ),
-                        sernEmitter?.emit('module.register', {
+            );
-                            type: PayloadType.Failure,
-                            module: undefined,
-                            reason,
-                        }),
-                    ),
-                );
-            },
-        )
-        .when(
-            e => typeof e === 'function',
-            (evs: () => { mod: EventModule; absPath: string }[]) => {
-                return from(evs());
-            },
-        )
-        .run();
 }

src/handler/plugins/plugin.ts

@@ -11,136 +11,99 @@
  * Plugins are reminiscent of middleware in express.
  */
 
-import type { AutocompleteInteraction, Awaitable, Client, ClientEvents } from 'discord.js';
+import type { AutocompleteInteraction, Awaitable, ClientEvents } from 'discord.js';
 import type { Result, Ok, Err } from 'ts-results-es';
-import type { CommandType, DefinitelyDefined, Override, SernEventsMapping } from '../../index';
+import type { CommandType, SernEventsMapping } from '../../index';
 import { EventType, PluginType } from '../../index';
-import type { BaseModule, CommandModuleDefs, EventModuleDefs } from '../structures/module';
+import type { CommandModuleDefs, EventModuleDefs } from '../../types/module';
-import type { EventEmitter } from 'events';
 import type {
     DiscordEventCommand,
     ExternalEventCommand,
     SernEventCommand,
 } from '../structures/events';
-import type SernEmitter from '../sernEmitter';
-import type Wrapper from '../structures/wrapper';
 
 export interface Controller {
     next: () => Ok<void>;
     stop: () => Err<void>;
 }
+export interface Plugin {
+    /** @deprecated will be removed in the next update */
+    name?: string;
+    /** @deprecated will be removed in the next update */
+    description?: string;
+    type: PluginType
+}
 
-type BasePlugin = Override<
+export interface CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> extends Plugin {
-    BaseModule,
+    type: PluginType.Command;
-    {
+    execute: (
-        type: PluginType;
+        payload: {
-    }
+            mod: CommandModuleDefs[T] & { name : string; description : string };
->;
+            absPath: string;
-
+        },
-export type CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
+        controller: Controller,
-    [K in T]: Override<
+    ) => Awaitable<Result<void, void>>;
-        BasePlugin,
+}
-        {
+export interface DiscordEmitterPlugin extends Plugin {
-            type: PluginType.Command;
-            execute: (
-                wrapper: Wrapper,
-                payload: {
-                    mod: DefinitelyDefined<CommandModuleDefs[T], 'name' | 'description'>;
-                    absPath: string;
-                },
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
-
-export type DiscordEmitterPlugin = Override<
-    BasePlugin,
-    {
         type: PluginType.Command;
         execute: (
-            wrapper: Client,
+            payload: { mod: DiscordEventCommand & { name: string }; absPath: string },
-            module: DefinitelyDefined<DiscordEventCommand, 'name' | 'description'>,
             controller: Controller,
         ) => Awaitable<Result<void, void>>;
-    }
+}
->;
-export type ExternalEmitterPlugin<T extends EventEmitter = EventEmitter> = Override<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: T,
-            module: DefinitelyDefined<ExternalEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
 
-export type SernEmitterPlugin = Override<
+export interface ExternalEmitterPlugin extends Plugin {
-    BasePlugin,
+    type: PluginType.Command;
-    {
+    execute: (
-        type: PluginType.Command;
+        payload: { mod: ExternalEventCommand &  { name : string }; absPath: string } ,
-        execute: (
+        controller: Controller,
-            wrapper: SernEmitter,
+    ) => Awaitable<Result<void, void>>;
-            module: DefinitelyDefined<SernEventCommand, 'name' | 'description'>,
+}
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
 
-export type AutocompletePlugin = Override<
+export interface SernEmitterPlugin extends Plugin {
-    BaseModule,
+    type: PluginType.Command;
-    {
+    execute: (
-        type: PluginType.Event;
+        payload: { mod : SernEventCommand & { name : string }; absPath: string },
-        execute: (
+        controller: Controller,
-            autocmp: AutocompleteInteraction,
+    ) => Awaitable<Result<void, void>>;
-            controlller: Controller,
+}
-        ) => Awaitable<Result<void, void>>;
-    }
->;
 
-export type EventPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
+export interface AutocompletePlugin extends Plugin {
-    [K in T]: Override<
+    type: PluginType.Event;
-        BasePlugin,
+    execute: (
-        {
+        autocmp: AutocompleteInteraction,
-            type: PluginType.Event;
+        controlller: Controller,
-            execute: (
+    ) => Awaitable<Result<void, void>>;
-                event: Parameters<CommandModuleDefs[K]['execute']>,
+}
-                controller: Controller,
-            ) => Awaitable<Result<void, void>>;
-        }
-    >;
-}[T];
 
-export type SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> = Override<
-    BasePlugin,
-    {
-        name?: T;
-        type: PluginType.Event;
-        execute: (
-            args: SernEventsMapping[T],
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
 
-export type ExternalEventPlugin = Override<
+export interface EventPlugin<K extends keyof CommandModuleDefs = keyof CommandModuleDefs> extends Plugin {
-    BasePlugin,
+    type: PluginType.Event;
-    {
+    execute: (
-        type: PluginType.Event;
+        event: Parameters<CommandModuleDefs[K]['execute']>,
-        execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
+        controller: Controller,
-    }
+    ) => Awaitable<Result<void, void>>;
->;
+}
 
-export type DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> = Override<
+export interface SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> extends Plugin {
-    BasePlugin,
+    name?: T;
-    {
+    type: PluginType.Event;
-        name?: T;
+    execute: (
-        type: PluginType.Event;
+        args: SernEventsMapping[T],
-        execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
+        controller: Controller,
-    }
+    ) => Awaitable<Result<void, void>>;
->;
+}
+
+export interface ExternalEventPlugin extends Plugin {
+    type: PluginType.Event;
+    execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
+}
+
+export interface DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> extends Plugin {
+    name?: T;
+    type: PluginType.Event;
+    execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
+}
 
 export type CommandModuleNoPlugins = {
     [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;

src/handler/sern.ts

@@ -1,16 +1,8 @@
 import type Wrapper from './structures/wrapper';
-import { Err, Ok } from 'ts-results-es';
-import { ExternalEventEmitters } from './utilities/readFile';
-import type { EventEmitter } from 'events';
 import { processEvents } from './events/userDefinedEventsHandling';
-import type {
-    CommandModule,
-    CommandModuleDefs,
-    EventModule,
-    EventModuleDefs,
-} from './structures/module';
 import { CommandType, EventType, PluginType } from './structures/enums';
 import type {
+    Plugin,
     CommandPlugin,
     EventModuleCommandPluginDefs,
     EventModuleEventPluginDefs,
@@ -18,11 +10,15 @@ import type {
     InputCommandModule,
     InputEventModule,
 } from './plugins/plugin';
-import { SernError } from './structures/errors';
 import InteractionHandler from './events/interactionHandler';
 import ReadyHandler from './events/readyHandler';
 import MessageHandler from './events/messageHandler';
-
+import type { CommandModule, CommandModuleDefs, EventModule, EventModuleDefs } from '../types/module';
+import { Container, createContainer } from 'iti';
+import type { Dependencies, OptionalDependencies } from '../types/handler';
+import { composeRoot, containerSubject, useContainer } from './dependencies/provider';
+import type { Logging } from './contracts';
+import { err, ok, partition } from './utilities/functions';
 /**
  *
  * @param wrapper Options to pass into sern.
@@ -30,58 +26,35 @@ import MessageHandler from './events/messageHandler';
  * @example
  * ```ts title="src/index.ts"
  * Sern.init({
- *     client,
  *     defaultPrefix: '!',
  *     commands: 'dist/commands',
+ *     events: 'dist/events',
+ *     containerConfig : {
+ *         get: useContainer
+ *     }
  * })
  * ```
  */
 export function init(wrapper: Wrapper) {
+    const logger = wrapper.containerConfig.get('@sern/logger')[0] as Logging | undefined;
+    const startTime = performance.now();
     const { events } = wrapper;
     if (events !== undefined) {
-        processEvents(wrapper, events);
+        processEvents(wrapper);
     }
     new ReadyHandler(wrapper);
     new MessageHandler(wrapper);
     new InteractionHandler(wrapper);
-}
+    const endTime = performance.now();
-
+    logger?.info({ message: `sern : ${(endTime-startTime).toFixed(2)} ms` });
-/**
- * @deprecated - use Sern#makeDependencies instead
- * @param emitter Any external event emitter.
- * The object will be stored in a map, and then fetched by the name of the instance's class.
- * As there are infinite possibilities to adding external event emitters,
- * Most types aren't provided and are as narrow as possibly can.
- * @example
- * ```ts title="src/index.ts"
- * //Add this before initiating Sern!
- * Sern.addExternal(new Level())
- * ```
- * @example
- * ```ts title="events/level.ts"
- *  export default eventModule({
- *      emitter: 'Level',
- *      type : EventType.External,
- *      name: 'error',
- *      execute(args) {
- *          console.log(args)
- *      }
- *  })
- * ```
- */
-export function addExternal<T extends EventEmitter>(emitter: T) {
-    if (ExternalEventEmitters.has(emitter.constructor.name)) {
-        throw Error(`${emitter.constructor.name} already exists!`);
-    }
-    ExternalEventEmitters.set(emitter.constructor.name, emitter);
 }
 
 /**
  * The object passed into every plugin to control a command's behavior
  */
 export const controller = {
-    next: () => Ok.EMPTY,
+    next: ok,
-    stop: () => Err.EMPTY,
+    stop: err,
 };
 
 /**
@@ -89,16 +62,7 @@ export const controller = {
  * @param mod
  */
 export function commandModule(mod: InputCommandModule): CommandModule {
-    const onEvent: EventPlugin[] = [];
+    const [onEvent, plugins] = partition(mod.plugins ?? [], el => (el as Plugin).type === PluginType.Event);
-    const plugins: CommandPlugin[] = [];
-    for (const pl of mod.plugins ?? []) {
-        if (pl.type === PluginType.Event) {
-            onEvent.push(pl);
-        } else {
-            plugins.push(pl as CommandPlugin);
-        }
-    }
-
     return {
         ...mod,
         onEvent,
@@ -110,20 +74,25 @@ export function commandModule(mod: InputCommandModule): CommandModule {
  * @param mod
  */
 export function eventModule(mod: InputEventModule): EventModule {
-    const onEvent: EventModuleEventPluginDefs[EventType][] = [];
+    const [onEvent, plugins] = partition(mod.plugins ?? [], el => (el as Plugin).type === PluginType.Event);
-    const plugins: EventModuleCommandPluginDefs[EventType][] = [];
+        return {
-    const hasPlugins = mod.plugins && mod.plugins.length > 0;
-    if (hasPlugins) {
-        throw Error(
-            SernError.NotSupportedYet + `: Plugins on event listeners are not supported yet`,
-        );
-    }
-    return {
         ...mod,
         onEvent,
         plugins,
     } as EventModule;
 }
+/**
+ * @param conf a configuration for creating your project dependencies
+ */
+export function makeDependencies<T extends Dependencies>(conf: {
+    exclude?: Set<OptionalDependencies>,
+    build: (root: Container<Record<string,any>, {}>) => Container<Partial<T>, T>,
+}) {
+    const container = conf.build(createContainer());
+    composeRoot(container, conf.exclude ?? new Set());
+    containerSubject.next(container as unknown as Container<Dependencies, {}>);
+    return useContainer<T>();
+}
 
 export abstract class CommandExecutable<Type extends CommandType> {
     abstract type: Type;

src/handler/sernEmitter.ts

@@ -27,7 +27,7 @@ class SernEmitter extends EventEmitter {
     /**
      * Listening to sern events with on. This event stays on until a crash or a normal exit
      * @param eventName
-     * @param args the arguments for emitting the  { eventName }
+     * @param args the arguments for emitting the eventName
      */
     public override emit<T extends keyof SernEventsMapping>(
         eventName: T,

src/handler/structures/context.ts

@@ -1,48 +1,36 @@
-import type { APIGuildMember } from 'discord-api-types/v10';
 import type {
     ChatInputCommandInteraction,
     Client,
-    Guild,
-    GuildMember,
     InteractionReplyOptions,
     Message,
     Snowflake,
-    TextBasedChannel,
     MessageReplyOptions,
     User,
 } from 'discord.js';
-import { type Option, None, Some } from 'ts-results-es';
+import { Result as Either, Ok as Left, Err as Right } from 'ts-results-es';
-import type { Nullish, ReplyOptions } from '../../types/handler';
+import type { ReplyOptions } from '../../types/handler';
 import { SernError } from './errors';
 
-function firstSome<T>(...args: Option<T>[]): Nullish<T> {
-    for (const op of args) {
-        if (op.some) return op.val;
-    }
-    return null;
-}
 
-//Could I refactor with Either monad?
+function safeUnwrap<T>(res: Either<T, T>) {
+    return res.val;
+}
 /**
  * Provides values shared between
  * Message and ChatInputCommandInteraction
  */
 export default class Context {
     private constructor(
-        private oMsg: Option<Message> = None,
+        private ctx: Either<Message, ChatInputCommandInteraction>,
-        private oInterac: Option<ChatInputCommandInteraction> = None,
+    ) {}
-    ) {
-        this.oMsg = oMsg;
-        this.oInterac = oInterac;
-    }
 
     /**
      * Getting the Message object. Crashes if module type is
      * CommandType.Slash or the event fired in a Both command was
      * ChatInputCommandInteraction
      */
-    public get message() {
+    public get message()  {
-        return this.oMsg.expect(SernError.MismatchEvent);
+        return this.ctx.expect(SernError.MismatchEvent);
     }
     /**
      * Getting the ChatInputCommandInteraction object. Crashes if module type is
@@ -50,96 +38,95 @@ export default class Context {
      * Message
      */
     public get interaction() {
-        return this.oInterac.expect(SernError.MismatchEvent);
+        return this.ctx.expectErr(SernError.MismatchEvent);
     }
 
     public get id(): Snowflake {
-        return firstSome(
+        return safeUnwrap(
-            this.oInterac.map(i => i.id),
+            this.ctx
-            this.oMsg.map(m => m.id),
+            .map(m => m.id)
-        )!;
+            .mapErr(i => i.id));
     }
 
-    public get channel(): Nullish<TextBasedChannel> {
+    public get channel() {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.channel),
+            .map(m => m.channel)
-            this.oInterac.map(i => i.channel),
+            .mapErr(i => i.channel));
+    }
+    /**
+     * If context is holding a message, message.author
+     * else, interaction.user
+     */
+    public get user(): User {
+        return safeUnwrap(this.ctx
+            .map(m => m.author)
+            .mapErr(i => i.user)
         );
     }
 
-    public get user(): User {
-        return firstSome(
-            this.oMsg.map(m => m.author),
-            this.oInterac.map(i => i.user),
-        )!;
-    }
-
     public get createdTimestamp(): number {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.createdTimestamp),
+            .map(m => m.createdTimestamp)
-            this.oInterac.map(i => i.createdTimestamp),
+            .mapErr(i => i.createdTimestamp)
-        )!;
+        );
     }
 
-    public get guild(): Guild {
+    public get guild() {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.guild),
+            .map(m => m.guild)
-            this.oInterac.map(i => i.guild),
+            .mapErr(i => i.guild)
-        )!;
+        );
     }
 
-    public get guildId(): Snowflake {
+    public get guildId() {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.guildId),
+            .map(m => m.guildId)
-            this.oInterac.map(i => i.guildId),
+            .mapErr(i => i.guildId)
-        )!;
+        );
     }
 
     /*
      * interactions can return APIGuildMember if the guild it is emitted from is not cached
      */
-    public get member(): Nullish<GuildMember | APIGuildMember> {
+    public get member() {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.member),
+            .map(m => m.member)
-            this.oInterac.map(i => i.member),
+            .mapErr(i => i.member)
         );
     }
 
     public get client(): Client {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.client),
+            .map(m => m.client)
-            this.oInterac.map(i => i.client),
+            .mapErr(i => i.client)
-        )!;
+        );
     }
 
     public get inGuild(): boolean {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oMsg.map(m => m.inGuild()),
+            .map(m=>m.inGuild())
-            this.oInterac.map(i => i.inGuild()),
+            .mapErr(i => i.inGuild())
-        )!;
+        );
+    }
+    public isMessage() {
+        return this.ctx.map(() => true).unwrapOr(false);
+    }
+
+    public isSlash() {
+        return !this.isMessage();
     }
 
     static wrap(wrappable: ChatInputCommandInteraction | Message): Context {
         if ('token' in wrappable) {
-            return new Context(None, Some(wrappable));
+            return new Context(Right(wrappable));
         }
-        return new Context(Some(wrappable), None);
+        return new Context(Left(wrappable));
     }
 
-    public isEmpty() {
-        return this.oMsg.none && this.oInterac.none;
-    }
-    //Make queueable
     public reply(content: ReplyOptions) {
-        return firstSome(
+        return safeUnwrap(this.ctx
-            this.oInterac.map(i => {
+            .map( m => m.reply(content as string | MessageReplyOptions))
-                return i
+            .mapErr(i => i.reply(content as string | InteractionReplyOptions).then(() => i.fetchReply()))
-                    .reply(content as string | InteractionReplyOptions)
+        );
-                    .then(() => i.fetchReply());
-            }),
-            this.oMsg.map(m => {
-                return m.reply(content as string | MessageReplyOptions);
-            }),
-        )!;
     }
 }

src/handler/structures/enums.ts

@@ -1,4 +1,5 @@
 /**
+ * A bitfield that discriminates command modules
  * @enum { number }
  * @example
  * ```ts
@@ -16,38 +17,46 @@ export enum CommandType {
     /**
      * The CommandType for text commands
      */
-    Text = 0b00000000001,
+    Text = 1,
     /**
      * The CommandType for slash commands
      */
-    Slash = 0b00000000010,
+    Slash = 2,
     /**
      * The CommandType for hybrid commands, text and slash
      */
-    Both = 0b0000011,
+    Both = 3,
     /**
      * The CommandType for UserContextMenuInteraction commands
      */
-    MenuUser = 0b00000000100,
+    CtxUser = 4,
     /**
      * The CommandType for MessageContextMenuInteraction commands
      */
-    MenuMsg = 0b0000001000,
+    CtxMsg = 8,
     /**
      * The CommandType for ButtonInteraction commands
      */
-    Button = 0b00000010000,
+    Button = 16,
     /**
-     * The CommandType for SelectMenuInteraction commands
+     * The CommandType for StringSelectMenuInteraction commands
      */
-    MenuSelect = 0b00000100000,
+    StringSelect = 32,
     /**
      * The CommandType for ModalSubmitInteraction commands
      */
-    Modal = 0b00001000000,
+    Modal = 64,
+    /**
+     * The CommandType for the other SelectMenuInteractions
+     */
+    ChannelSelect = 256,
+    MentionableSelect = 512,
+    RoleSelect= 1024,
+    UserSelect= 2048
 }
 
 /**
+ * A bitfield that discriminates event modules
  * @enum { number }
  * @example
  * ```ts
@@ -65,19 +74,20 @@ export enum EventType {
     /**
      * The EventType for handling discord events
      */
-    Discord = 0b01,
+    Discord = 1,
     /**
      * The EventType for handling sern events
      */
-    Sern = 0b10,
+    Sern = 2,
     /**
      * The EventType for handling external events.
      * Could be for example, `process` events, database events
      */
-    External = 0b11,
+    External = 3,
 }
 
 /**
+ * A bitfield that discriminates plugins
  * @enum { number }
  * @example
  * ```ts
@@ -94,11 +104,11 @@ export enum PluginType {
     /**
      * The PluginType for CommandPlugins
      */
-    Command = 0b01,
+    Command = 1,
     /**
      * The PluginType for EventPlugins
      */
-    Event = 0b10,
+    Event = 2,
 }
 /**
  * @enum { string }

src/handler/structures/errors.ts

@@ -31,4 +31,8 @@ export enum SernError {
      * Unsupported feature attempted to access at this time
      */
     NotSupportedYet = `This feature is not supported yet`,
+    /**
+     * Required Dependency not found
+     */
+    MissingRequired = `@sern/client is required but was not found`
 }

src/handler/structures/events.ts

@@ -1,5 +1,4 @@
-import type { Override, SernEventsMapping } from '../../types/handler';
+import type { SernEventsMapping } from '../../types/handler';
-import type { BaseModule } from './module';
 import type {
     DiscordEmitterPlugin,
     DiscordEventPlugin,
@@ -10,44 +9,30 @@ import type {
 } from '../plugins/plugin';
 import type { Awaitable, ClientEvents } from 'discord.js';
 import type { EventType } from './enums';
+import type { Module } from '../../types/module';
 
-/*
+
- * Mapped type to generate all sern event modules
+export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> extends Module {
- */
+    name?: T;
-export type SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> =
+    type: EventType.Sern;
-    Override<
+    onEvent: SernEventPlugin[];
-        BaseModule,
+    plugins: SernEmitterPlugin[];
-        {
+    execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
-            name?: T;
+}
-            type: EventType.Sern;
+
-            onEvent: SernEventPlugin[];
+export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> extends Module {
-            plugins: SernEmitterPlugin[];
+    name?: T;
-            execute(...args: SernEventsMapping[T]): Awaitable<void | unknown>;
+    type: EventType.Discord;
-        }
+    onEvent: DiscordEventPlugin[];
-    >;
+    plugins: DiscordEmitterPlugin[];
-/*
+    execute(...args: ClientEvents[T]): Awaitable<unknown>;
- * Mapped type to generate all discord event modules
+}
- */
+
-export type DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> = Override<
+export interface ExternalEventCommand extends Module {
-    BaseModule,
+    name?: string
-    {
+    emitter: string;
-        name?: T;
+    type: EventType.External;
-        type: EventType.Discord;
+    onEvent: ExternalEventPlugin[];
-        onEvent: DiscordEventPlugin[];
+    plugins: ExternalEmitterPlugin[];
-        plugins: DiscordEmitterPlugin[];
+    execute(...args: unknown[]): Awaitable<unknown>;
-        execute(...args: ClientEvents[T]): Awaitable<void | unknown>;
+}
-    }
->;
-/*
- * Type for any event emitter that can be handled by sern
- */
-export type ExternalEventCommand = Override<
-    BaseModule,
-    {
-        emitter: string;
-        type: EventType.External;
-        onEvent: ExternalEventPlugin[];
-        plugins: ExternalEmitterPlugin[];
-        execute(...args: unknown[]): Awaitable<void | unknown>;
-    }
->;

src/handler/structures/module.ts

@@ -1,210 +0,0 @@
-import type {
-    ApplicationCommandAttachmentOption,
-    ApplicationCommandChannelOptionData,
-    ApplicationCommandChoicesData,
-    ApplicationCommandNonOptionsData,
-    ApplicationCommandNumericOptionData,
-    ApplicationCommandOptionData,
-    ApplicationCommandOptionType,
-    ApplicationCommandSubCommandData,
-    ApplicationCommandSubGroupData,
-    AutocompleteInteraction,
-    Awaitable,
-    BaseApplicationCommandOptionsData,
-    ButtonInteraction,
-    MessageContextMenuCommandInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    UserContextMenuCommandInteraction,
-} from 'discord.js';
-import type { Args, Override, SlashOptions } from '../../types/handler';
-import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../plugins/plugin';
-import type Context from './context';
-import { CommandType, EventType, PluginType } from './enums';
-import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from './events';
-
-export interface BaseModule {
-    type: CommandType | PluginType;
-    name?: string;
-    description?: string;
-    execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-}
-
-export type TextCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Text;
-        onEvent: EventPlugin<CommandType.Text>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        alias?: string[];
-        execute: (ctx: Context, args: ['text', string[]]) => Awaitable<void | unknown>;
-    }
->;
-
-export type SlashCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Slash;
-        onEvent: EventPlugin<CommandType.Slash>[]; //maybe allow BothPlugins for this also?
-        plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<void | unknown>;
-    }
->;
-
-export type BothCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Both;
-        onEvent: EventPlugin<CommandType.Both>[];
-        plugins: CommandPlugin[];
-        alias?: string[];
-        options?: SernOptionsData[];
-        execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuUser = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuUser;
-        onEvent: EventPlugin<CommandType.MenuUser>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ContextMenuMsg = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuMsg;
-        onEvent: EventPlugin<CommandType.MenuMsg>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ButtonCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Button;
-        onEvent: EventPlugin<CommandType.Button>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ButtonInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type SelectMenuCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.MenuSelect;
-        onEvent: EventPlugin<CommandType.MenuSelect>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: SelectMenuInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-export type ModalSubmitCommand = Override<
-    BaseModule,
-    {
-        type: CommandType.Modal;
-        onEvent: EventPlugin<CommandType.Modal>[];
-        plugins: CommandPlugin[];
-        execute: (ctx: ModalSubmitInteraction) => Awaitable<void | unknown>;
-    }
->;
-
-// Autocomplete commands are a little different
-// They can't have command plugins as they are
-// in conjunction with chat input commands
-export type AutocompleteCommand = Override<
-    BaseModule,
-    {
-        name?: never;
-        description?: never;
-        type?: never;
-        onEvent: AutocompletePlugin[];
-        execute: (ctx: AutocompleteInteraction) => Awaitable<void | unknown>;
-    }
->;
-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
-export type CommandModule =
-    | TextCommand
-    | SlashCommand
-    | BothCommand
-    | ContextMenuUser
-    | ContextMenuMsg
-    | ButtonCommand
-    | SelectMenuCommand
-    | ModalSubmitCommand;
-
-export type Module = CommandModule | EventModule;
-
-//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
-// Explicit Module Definitions for mapping
-export type CommandModuleDefs = {
-    [CommandType.Text]: TextCommand;
-    [CommandType.Slash]: SlashCommand;
-    [CommandType.Both]: BothCommand;
-    [CommandType.MenuMsg]: ContextMenuMsg;
-    [CommandType.MenuUser]: ContextMenuUser;
-    [CommandType.Button]: ButtonCommand;
-    [CommandType.MenuSelect]: SelectMenuCommand;
-    [CommandType.Modal]: ModalSubmitCommand;
-};
-
-export type EventModuleDefs = {
-    [EventType.Sern]: SernEventCommand;
-    [EventType.Discord]: DiscordEventCommand;
-    [EventType.External]: ExternalEventCommand;
-};
-
-//TODO: support deeply nested Autocomplete
-// objective: construct union of ApplicationCommandOptionData change any Autocomplete data
-// into Sern autocomplete data.
-
-export type SernAutocompleteData = Override<
-    BaseApplicationCommandOptionsData,
-    {
-        autocomplete: true;
-        type:
-            | ApplicationCommandOptionType.String
-            | ApplicationCommandOptionType.Number
-            | ApplicationCommandOptionType.Integer;
-        command: AutocompleteCommand;
-    }
->;
-
-/**
- * Type that replaces autocomplete with {@link SernAutocompleteData}
- */
-export type BaseOptions =
-    | ApplicationCommandChoicesData
-    | ApplicationCommandNonOptionsData
-    | ApplicationCommandChannelOptionData
-    | ApplicationCommandNumericOptionData
-    | ApplicationCommandAttachmentOption
-    | SernAutocompleteData;
-
-export type SernSubCommandData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.Subcommand;
-        options?: BaseOptions[];
-    }
->;
-
-export type SernSubCommandGroupData = Override<
-    Omit<BaseApplicationCommandOptionsData, 'required'>,
-    {
-        type: ApplicationCommandOptionType.SubcommandGroup;
-        options?: SernSubCommandData[];
-    }
->;
-
-export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
-    U extends ApplicationCommandSubCommandData
-        ? SernSubCommandData
-        : U extends ApplicationCommandSubGroupData
-        ? SernSubCommandGroupData
-        : BaseOptions;

src/handler/structures/moduleStore.ts

@@ -0,0 +1,26 @@
+import type { CommandModule } from '../../types/module';
+import { ApplicationCommandType, ComponentType } from 'discord.js';
+
+/**
+ * Storing all command modules
+ * This dependency is usually injected into ModuleManager
+ */
+export class ModuleStore {
+     readonly BothCommands = new Map<string, CommandModule>();
+     readonly ApplicationCommands = {
+        [ApplicationCommandType.User]: new Map<string, CommandModule>(),
+        [ApplicationCommandType.Message]: new Map<string, CommandModule>(),
+        [ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
+    };
+    readonly ModalSubmit = new Map<string, CommandModule>();
+    readonly TextCommands = new Map<string, CommandModule>();
+    readonly InteractionHandlers = {
+        [ComponentType.Button]: new Map<string, CommandModule>(),
+        [ComponentType.StringSelect]: new Map<string, CommandModule>(),
+        [ComponentType.ChannelSelect] : new Map<string, CommandModule>(),
+        [ComponentType.MentionableSelect] : new Map<string, CommandModule>(),
+        [ComponentType.RoleSelect] : new Map<string, CommandModule>(),
+        [ComponentType.UserSelect] : new Map<string, CommandModule>(),
+    };
+}
+

src/handler/structures/structxports.ts

@@ -1,28 +1,10 @@
 import Context from './context';
-import type {
-    BothCommand,
-    Module,
-    SlashCommand,
-    TextCommand,
-    SernOptionsData,
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
-} from './module';
 import type Wrapper from './wrapper';
+import { ModuleStore } from './moduleStore';
 
 export * from './enums';
 export {
     Context,
-    SlashCommand,
-    TextCommand,
-    BothCommand,
-    Module,
     Wrapper,
-    SernOptionsData,
+    ModuleStore
-    BaseOptions,
-    SernAutocompleteData,
-    SernSubCommandData,
-    SernSubCommandGroupData,
 };

src/handler/structures/wrapper.ts

@@ -1,24 +1,15 @@
-import type { Client } from 'discord.js';
+import type { Dependencies } from '../../types/handler';
-import type SernEmitter from '../sernEmitter';
-import type { EventModule } from './module';
 
 /**
  * An object to be passed into Sern#init() function.
  * @typedef {object} Wrapper
  */
 interface Wrapper {
-    //@deprecated - Use Sern#makeDependencies instead
-    readonly client: Client;
-    //@deprecated - Use Sern#makeDependencies instead
-    readonly sernEmitter?: SernEmitter;
     readonly defaultPrefix?: string;
     readonly commands: string;
-    readonly events?:
+    readonly events?: string;
-        | string
+    readonly containerConfig : {
-        //@deprecated - array and function options will be removed
+        get: (...keys: (keyof Dependencies)[]) => unknown[];
-        | { mod: EventModule; absPath: string }[]
+    }
-        //@deprecated - array and function options will be removed
-        | (() => { mod: EventModule; absPath: string }[]);
 }
-
 export default Wrapper;

src/handler/utilities/arrAsync.ts

@@ -1,6 +1,6 @@
 import type { Awaitable } from 'discord.js';
 
-export async function asyncResolveArray<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
+export async function arrAsync<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
     const arr: T[] = [];
     for await (const el of promiseLike) {
         arr.push(el);

src/handler/utilities/functions.ts

@@ -0,0 +1,42 @@
+import * as Files from './readFile';
+import { basename } from 'path';
+import { Err, Ok, Result } from 'ts-results-es';
+import { Observable, of, switchMap } from 'rxjs';
+/**
+ * A function that returns whatever value is provided.
+ * Used for singleton in iti
+ * @param value
+ */
+export const _const = <T>(value: T) => () => value;
+/**
+ * A function that returns another function
+ * Used for transient in iti
+ * @param value
+ */
+export const transient = <T>( value : T) => () => _const(value);
+
+export function nameOrFilename(modName: string | undefined, absPath: string) {
+    return modName ?? Files.fmtFileName(basename(absPath));
+}
+
+//function wrappers for empty ok / err
+export const ok = _const(Ok.EMPTY);
+export const err = _const(Err.EMPTY);
+
+
+export function partition<T, V>(arr: (T & V)[], condition: (e: (T & V)) => boolean) : [T[], V[]] {
+    const t : T[] = [];
+    const v : V[] = [];
+    for(const el of arr) {
+        if(condition(el)) {
+            t.push(el as T);
+        } else {
+            v.push(el as V);
+        }
+    }
+    return [ t, v ];
+}
+
+ export function reducePlugins(src: Observable<Result<void, void>[]>) : Observable<boolean> {
+    return src.pipe(switchMap(s => of(s.every((a) => a.ok))));
+ }

src/handler/utilities/predicates.ts

@@ -1,24 +1,9 @@
-import type { CommandModuleDefs, EventModule, Module } from '../structures/module';
+import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from '../structures/events';
-import {
+import { CommandModule, EventType } from '../..';
-    AutocompleteInteraction,
+import type { AnyModule, CommandModuleDefs, EventModule } from '../../types/module';
-    Interaction,
-    InteractionType,
-    type ModalSubmitInteraction,
-    type ButtonInteraction,
-    type SelectMenuInteraction,
-    type ChatInputCommandInteraction,
-    type UserContextMenuCommandInteraction,
-    type MessageContextMenuCommandInteraction,
-} from 'discord.js';
-import type {
-    DiscordEventCommand,
-    ExternalEventCommand,
-    SernEventCommand,
-} from '../structures/events';
-import { EventType } from '../..';
 
 export function correctModuleType<T extends keyof CommandModuleDefs>(
-    plug: Module | undefined,
+    plug: AnyModule | undefined,
     type: T,
 ): plug is CommandModuleDefs[T] {
     // Another way to check if type is equivalent,
@@ -26,45 +11,13 @@ export function correctModuleType<T extends keyof CommandModuleDefs>(
     return plug !== undefined && (plug.type & type) !== 0;
 }
 
-export function isApplicationCommand(
-    interaction: Interaction,
-): interaction is
-    | ChatInputCommandInteraction
-    | UserContextMenuCommandInteraction
-    | MessageContextMenuCommandInteraction {
-    return interaction.type === InteractionType.ApplicationCommand;
-}
 
-export function isModalSubmit(interaction: Interaction): interaction is ModalSubmitInteraction {
+export function isDiscordEvent(el: EventModule | CommandModule): el is DiscordEventCommand {
-    return interaction.type === InteractionType.ModalSubmit;
-}
-export function isAutocomplete(interaction: Interaction): interaction is AutocompleteInteraction {
-    return interaction.type === InteractionType.ApplicationCommandAutocomplete;
-}
-export function isMessageComponent(
-    interaction: Interaction,
-): interaction is ButtonInteraction | SelectMenuInteraction {
-    return interaction.type === InteractionType.MessageComponent;
-}
-
-export function isDiscordEvent(el: EventModule): el is DiscordEventCommand {
     return el.type === EventType.Discord;
 }
-export function isSernEvent(el: EventModule): el is SernEventCommand {
+export function isSernEvent(el: EventModule | CommandModule): el is SernEventCommand {
     return el.type === EventType.Sern;
 }
-
+export function isExternalEvent(el: EventModule | CommandModule): el is ExternalEventCommand {
-export function isExternalEvent(el: EventModule): el is ExternalEventCommand {
     return el.type === EventType.External && 'emitter' in el;
 }
-
-// export function isEventPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is EventPlugin<T> {
-//     return e.type === PluginType.Event;
-// }
-// export function isCommandPlugin<T extends CommandType>(
-//     e: CommandModulePlugin<T>,
-// ): e is CommandPlugin<T> {
-//     return !isEventPlugin(e);
-// }

src/handler/utilities/readFile.ts

@@ -1,34 +1,9 @@
-import { ApplicationCommandType, ComponentType } from 'discord.js';
 import { readdirSync, statSync } from 'fs';
 import { join } from 'path';
 import { type Observable, from, concatAll } from 'rxjs';
-import type { CommandModule } from '../structures/module';
 import { SernError } from '../structures/errors';
 import { type Result, Err, Ok } from 'ts-results-es';
-import type { EventEmitter } from 'events';
 
-//Maybe move this? this probably doesnt belong in utlities/
-export const BothCommands = new Map<string, CommandModule>();
-export const ApplicationCommands = {
-    [ApplicationCommandType.User]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.Message]: new Map<string, CommandModule>(),
-    [ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
-} as { [K in ApplicationCommandType]: Map<string, CommandModule> };
-
-export const MessageCompCommands = {
-    [ComponentType.Button]: new Map<string, CommandModule>(),
-    [ComponentType.SelectMenu]: new Map<string, CommandModule>(),
-    [ComponentType.TextInput]: new Map<string, CommandModule>(),
-};
-export const TextCommands = {
-    text: new Map<string, CommandModule>(),
-    aliases: new Map<string, CommandModule>(),
-};
-export const ModalSubmitCommands = new Map<string, CommandModule>();
-/**
- * keeps all external emitters stored here
- */
-export const ExternalEventEmitters = new Map<string, EventEmitter>();
 
 // Courtesy @Townsy45
 function readPath(dir: string, arrayOfFiles: string[] = []): string[] {

src/handler/utilities/treeSearch.ts

@@ -1,42 +1,42 @@
-import type { SernAutocompleteData, SernOptionsData } from '../structures/module';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
 
 export default function treeSearch(
     iAutocomplete: AutocompleteInteraction,
     options: SernOptionsData[] | undefined,
-): SernAutocompleteData {
+): SernAutocompleteData | undefined {
     if (options === undefined) return undefined;
     const _options = options.slice(); // required to prevent direct mutation of options
-    let autocompleteData: SernAutocompleteData;
+    let autocompleteData: SernAutocompleteData | undefined;
 
     while (_options.length > 0) {
         const cur = _options.pop()!;
         switch (cur.type) {
             case ApplicationCommandOptionType.Subcommand:
-                {
+            {
-                    for (const option of cur.options ?? []) {
+                for (const option of cur.options ?? []) {
-                        _options.push(option);
+                    _options.push(option);
-                    }
                 }
+            }
                 break;
             case ApplicationCommandOptionType.SubcommandGroup:
-                {
+            {
-                    for (const command of cur.options ?? []) {
+                for (const command of cur.options ?? []) {
-                        _options.push(command);
+                    _options.push(command);
-                    }
                 }
+            }
                 break;
             default:
-                {
+            {
-                    if (cur.autocomplete) {
+                if (cur.autocomplete) {
-                        const choice = iAutocomplete.options.getFocused(true);
+                    const choice = iAutocomplete.options.getFocused(true);
-                        if (cur.name === choice.name && cur.autocomplete) {
+                    if (cur.name === choice.name && cur.autocomplete) {
-                            autocompleteData = cur;
+                        autocompleteData = cur;
-                        }
                     }
                 }
+            }
                 break;
         }
     }
     return autocompleteData;
-}
+}

src/index.ts

@@ -2,6 +2,10 @@ import SernEmitter from './handler/sernEmitter';
 export { eventModule, commandModule, EventExecutable, CommandExecutable } from './handler/sern';
 export * as Sern from './handler/sern';
 export * from './types/handler';
+export * from './types/module';
 export * from './handler/structures/structxports';
 export * from './handler/plugins/plugin';
+export * from './handler/contracts/index';
 export { SernEmitter };
+export { _const as single, transient as many } from './handler/utilities/functions';
+export { useContainerRaw } from './handler/dependencies/provider';

src/types/handler.ts

@@ -1,9 +1,12 @@
 import type { CommandInteractionOptionResolver } from 'discord.js';
-import type { CommandModule, EventModule, Module } from '../handler/structures/module';
 import type { PayloadType } from '../handler/structures/enums';
 import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-export type Nullish<T> = T | undefined | null;
+import type { EventEmitter } from 'events';
-
+import type { CommandModule, EventModule, AnyModule } from './module';
+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';
 // Thanks to @kelsny
 export type ParseType<T> = {
     [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
@@ -13,46 +16,42 @@ export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
 
 export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
 
-// Source: https://dev.to/vborodulin/ts-how-to-override-properties-with-type-intersection-554l
-export type Override<T1, T2> = Omit<T1, keyof T2> & T2;
-
-export type DefinitelyDefined<T, K extends keyof T = keyof T> = {
-    [L in K]-?: T[L] extends Record<string, unknown>
-        ? DefinitelyDefined<T[L], keyof T[L]>
-        : Required<T>[L];
-} & T;
-
-export type EventInput =
-    | string
-    | { mod: EventModule; absPath: string }[]
-    | (() => { mod: EventModule; absPath: string }[]);
-
-/**
- * Turns a function with a union of array of args into a single union
- *  [ T , V , B ] | [ A ] => T | V | B | A
- */
-export type SpreadParams<T extends (...args: never) => unknown> = (
-    args: Parameters<T>[number],
-) => unknown;
-
 /**
  * After modules are transformed, name and description are given default values if none
  * are provided to Module. This type represents that transformation
  */
-export type DefinedModule = DefinitelyDefined<Module, 'name' | 'description'>;
+export type DefinedCommandModule = CommandModule & { name: string; description: string };
-export type DefinedCommandModule = DefinitelyDefined<CommandModule, 'name' | 'description'>;
+export type DefinedEventModule = EventModule & { name: string };
-export type DefinedEventModule = DefinitelyDefined<EventModule, 'name' | 'description'>;
+export type AnyDefinedModule = DefinedCommandModule | DefinedEventModule
 export type Payload =
-    | { type: PayloadType.Success; module: Module }
+    | { type: PayloadType.Success; module: AnyModule }
-    | { type: PayloadType.Failure; module?: Module; reason: string | Error };
+    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: PayloadType.Warning; reason: string};
 export type SernEventsMapping = {
-    ['module.register']: [Payload];
+    'module.register': [Payload];
-    ['module.activate']: [Payload];
+    'module.activate': [Payload];
-    ['error']: [Payload];
+    'error': [Payload];
-    ['warning']: [string];
+    'warning': [Payload];
 };
+export type LogPayload<T = unknown> = { message: T }
+export type Singleton<T> = () => T
+export type Transient<T> = () => () => T;
 
-export type ReplyOptions =
+export interface Dependencies {
-    | string
+    '@sern/client': Singleton<EventEmitter>;
-    | Omit<InteractionReplyOptions, 'fetchReply'>
+    '@sern/logger'?: Singleton<Logging>;
-    | MessageReplyOptions;
+    '@sern/emitter': Singleton<SernEmitter>;
+    '@sern/store' : Singleton<ModuleStore>;
+    '@sern/modules' : Singleton<ModuleManager>;
+    '@sern/errors': Singleton<ErrorHandling>;
+}
+
+export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;
+
+export type MapDeps<
+    Deps extends Dependencies,
+    T extends readonly unknown[]
+    > = T extends [infer First extends keyof Deps, ...infer Rest extends readonly unknown[]]
+    ? [ UnpackFunction<Deps[First]>, ...(MapDeps<Deps, Rest> extends [never] ? [] : MapDeps<Deps,Rest>)] : [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';

src/types/module.ts

@@ -0,0 +1,215 @@
+import type {
+    ApplicationCommandAttachmentOption,
+    ApplicationCommandChannelOptionData,
+    ApplicationCommandChoicesData,
+    ApplicationCommandNonOptionsData,
+    ApplicationCommandNumericOptionData,
+    ApplicationCommandOptionData,
+    ApplicationCommandOptionType,
+    ApplicationCommandSubCommandData,
+    ApplicationCommandSubGroupData,
+    AutocompleteInteraction,
+    Awaitable,
+    BaseApplicationCommandOptionsData,
+    ButtonInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+    ChannelSelectMenuInteraction,
+    MentionableSelectMenuInteraction,
+    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 { EventType } from '../handler/structures/enums';
+import type { UserSelectMenuInteraction } from 'discord.js';
+
+export interface Module {
+    type?: CommandType | EventType;
+    name?: string;
+    description?: string;
+    execute: (...args: any[]) => 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[];
+    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[];
+    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[];
+    execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
+}
+
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
+export type CommandModule =
+    | TextCommand
+    | SlashCommand
+    | BothCommand
+    | ContextMenuUser
+    | ContextMenuMsg
+    | ButtonCommand
+    | StringSelectCommand
+    | MentionableSelectCommand
+    | UserSelectCommand
+    | ChannelSelectCommand
+    | RoleSelectCommand
+    | ModalSubmitCommand;
+
+export type AnyModule = CommandModule | EventModule;
+
+//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
+// Explicit Module Definitions for mapping
+export type CommandModuleDefs = {
+    [CommandType.Text]: TextCommand;
+    [CommandType.Slash]: SlashCommand;
+    [CommandType.Both]: BothCommand;
+    [CommandType.CtxMsg]: ContextMenuMsg;
+    [CommandType.CtxUser]: ContextMenuUser;
+    [CommandType.Button]: ButtonCommand;
+    [CommandType.StringSelect]: StringSelectCommand;
+    [CommandType.RoleSelect] : RoleSelectCommand;
+    [CommandType.ChannelSelect] : ChannelSelectCommand;
+    [CommandType.MentionableSelect] : MentionableSelectCommand;
+    [CommandType.UserSelect] : UserSelectCommand;
+    [CommandType.Modal]: ModalSubmitCommand;
+};
+
+export type EventModuleDefs = {
+    [EventType.Sern]: SernEventCommand;
+    [EventType.Discord]: DiscordEventCommand;
+    [EventType.External]: ExternalEventCommand;
+};
+
+export interface SernAutocompleteData extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
+    autocomplete: true;
+    type:
+        | ApplicationCommandOptionType.String
+        | ApplicationCommandOptionType.Number
+        | ApplicationCommandOptionType.Integer;
+    command: AutocompleteCommand;
+}
+
+/**
+ * Type that replaces autocomplete with {@link SernAutocompleteData}
+ */
+export type BaseOptions =
+    | ApplicationCommandChoicesData
+    | ApplicationCommandNonOptionsData
+    | ApplicationCommandChannelOptionData
+    | ApplicationCommandNumericOptionData
+    | ApplicationCommandAttachmentOption
+    | SernAutocompleteData;
+
+export interface SernSubCommandData extends BaseApplicationCommandOptionsData {
+    type: ApplicationCommandOptionType.Subcommand;
+    required?: never;
+    options?: BaseOptions[];
+}
+
+export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsData {
+    type: ApplicationCommandOptionType.SubcommandGroup;
+    required?: never;
+    options?: SernSubCommandData[];
+}
+
+export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
+    U extends ApplicationCommandSubCommandData
+        ? SernSubCommandData
+        : U extends ApplicationCommandSubGroupData
+        ? SernSubCommandGroupData
+        : BaseOptions;

test/cjs/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "importsNotUsedAsValues": "error",
+    "baseUrl": ".",
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/secrets.json", "src"]
+}

test/esm/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "importsNotUsedAsValues": "error",
+    "baseUrl": ".",
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/secrets.json", "src"]
+}

tsconfig-base.json

@@ -4,6 +4,7 @@
         "strict": true,
         "esModuleInterop": true,
         "noImplicitAny": true,
+        "experimentalDecorators": true,
         "strictNullChecks": true,
         "importsNotUsedAsValues": "error",
         "moduleResolution": "node",

tsup.config.js

@@ -1,38 +1,38 @@
 import { defineConfig } from 'tsup';
-
+const shared = {
+    entry: ['src/index.ts'],
+    external: ['discord.js'],
+    platform: 'node',
+    clean: true,
+    sourcemap: false
+};
 export default defineConfig([
     {
-        entry: ['src/index.ts'],
         format: 'esm',
-        sourcemap: false,
         target: 'node16',
         tsconfig: './tsconfig-esm.json',
         outDir: './dist/esm',
-        platform: 'node',
         external: ['discord.js'],
-        clean: true,
         treeshake: true,
         outExtension() {
             return {
                 js: '.mjs',
             };
         },
+        ...shared
     },
     {
-        entry: ['src/index.ts'],
         format: 'cjs',
         splitting: false,
-        sourcemap: false,
         external: ['discord.js'],
-        clean: true,
         target: 'node16',
         tsconfig: './tsconfig-cjs.json',
         outDir: './dist/cjs',
-        platform: 'node',
         outExtension() {
             return {
                 js: '.cjs',
             };
         },
+        ...shared
     },
 ]);