chore(main): release 2.5.2 (#234)

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@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"
     }
 }

.github/CODEOWNERS

@@ -1 +1 @@
-src/* @jacoobes
+* @jacoobes

.github/workflows/continuous-integration.yml

@@ -5,6 +5,8 @@ on:
   push:
     branches:
       main
+    paths:
+      - '**.ts'
   pull_request_target:
     branches:
       main
@@ -17,19 +19,22 @@ jobs:
 
     steps:
       - name: Check out Git repository
-        uses: actions/checkout@2541b1294d2704b0964813337f33b291d3f8596b # tag=v3
+        uses: actions/checkout@ac593985615ec2ede58e132d2e21d2b1cbd6127c # v3
 
       - name: Set up Node.js
-        uses: actions/setup-node@2fddd8803e2f5c9604345a0b591c3020ee971a93 # tag=v3
+        uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3
         with:
           node-version: 17
 
+      - name: Install pnpm
+        run: npm i -g pnpm
+
       # Prettier must be in `package.json`
       - name: Install Node.js dependencies
-        run: npm i -g prettier && npm i
+        run:  pnpm i
 
       - name: Run Prettier
-        run: prettier --write .
+        run: pnpm run pretty
 
       - name: Create Pull Request
         id: cpr

.github/workflows/npm-publish.yml

@@ -1,30 +1,27 @@
 name: NPM / Publish
 
 on:
-  release:
+  workflow_run:
-    types: [created]
+    workflows: ["release-please"]
+    types: [completed]
 
 jobs:
-  build:
+  test-and-publish:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          node-version: 17
-      - run: npm ci
+      - uses: pnpm/action-setup@v2
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
         with:
-          node-version: 16
+          run_install: |
-          registry-url: https://registry.npmjs.org/
+            - recursive: true
-      - run: npm ci
+              args: [--strict-peer-dependencies]
-      - run: npm publish
+      - run: pnpm install
-        env:
+      - run: pnpm test
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
+      - run: pnpm build
+      - uses: JS-DevTools/npm-publish@v1
+        with:
+          token: ${{ secrets.NPM_TOKEN }}
+          access: "public"

.prettierignore

@@ -1,2 +1,3 @@
 .github/
-*.md
+*.md
+dist/

CHANGELOG.md

@@ -1,5 +1,97 @@
 # Changelog
 
+## [2.5.2](https://github.com/sern-handler/handler/compare/v2.5.1...v2.5.2) (2023-02-16)
+
+
+### Reverts
+
+* version ([facee79](https://github.com/sern-handler/handler/commit/facee79c904ad663d3c57ce56fb825419fcc12f9))
+
+## [2.5.1](https://github.com/sern-handler/handler/compare/v2.5.0...v2.5.1) (2023-02-12)
+
+
+### Features
+
+* Adding my bot to readme ([#210](https://github.com/sern-handler/handler/issues/210)) ([96f4281](https://github.com/sern-handler/handler/commit/96f42811218e4898a47e75a8138ccd452ae2c5c2))
+* Adding the WIP to my bot ([86fa531](https://github.com/sern-handler/handler/commit/86fa531eb620d2ac649bad6decb29d5c55a25445))
+
+
+### Bug Fixes
+
+* autocomplete ([1860b89](https://github.com/sern-handler/handler/commit/1860b898f3a231840e2a8b781e007ef9d6f587a4))
+
+
+### Miscellaneous Chores
+
+* release 2.5.1 ([c78936a](https://github.com/sern-handler/handler/commit/c78936a22574da4af71826f5b5f72f354a4eb06a))
+
+## [2.5.0](https://github.com/sern-handler/handler/compare/v2.1.1...v2.5.0) (2023-01-30)
+
+
+### ⚠ BREAKING CHANGES
+
+* simpler plugins ([#193](https://github.com/sern-handler/handler/issues/193))
+
+### Features
+
+* simpler plugins ([#193](https://github.com/sern-handler/handler/issues/193)) ([33f1446](https://github.com/sern-handler/handler/commit/33f14467ec413e003a82503c8a77cb42a6194281))
+
+
+### Miscellaneous Chores
+
+* release 2.5.0 ([b4b195d](https://github.com/sern-handler/handler/commit/b4b195dc9586736760d0b78caa8589f3d6131f8a))
+
+## [2.1.1](https://github.com/sern-handler/handler/compare/v2.1.0...v2.1.1) (2022-12-31)
+
+
+### Bug Fixes
+
+* modals remapping ([a13df6f](https://github.com/sern-handler/handler/commit/a13df6fb424d256476284da49024dbe56e82baab))
+
+## [2.1.0](https://github.com/sern-handler/handler/compare/v2.0.0...v2.1.0) (2022-12-30)
+
+
+### Features
+
+* grammar ([c30aac4](https://github.com/sern-handler/handler/commit/c30aac476cdc2094de34f9f67b5805204cc5e4dd))
+
+
+### Bug Fixes
+
+* multi parameter events ([e986535](https://github.com/sern-handler/handler/commit/e98653593566ef4635493e0c997bd107a7a3a2a2))
+
+## [2.0.0](https://github.com/sern-handler/handler/compare/v1.2.1...v2.0.0) (2022-12-28)
+
+
+### ⚠ BREAKING CHANGES
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156))
+
+### Features
+
+* (2.0 global services) ([#156](https://github.com/sern-handler/handler/issues/156)) ([1455622](https://github.com/sern-handler/handler/commit/14556223fd6f79b797fb2aee03e795d4f4e94a8b))
+
+## [1.2.1](https://github.com/sern-handler/handler/compare/v1.2.0...v1.2.1) (2022-10-03)
+
+
+### Bug Fixes
+
+* **autocomplete:** now support multiple autocomplete options ([#147](https://github.com/sern-handler/handler/issues/147)) ([cbad738](https://github.com/sern-handler/handler/commit/cbad7380e1993b96c643f365726457f63e4fbd5d))
+
+## [1.2.0](https://github.com/sern-handler/handler/compare/v1.1.0...v1.2.0) (2022-09-28)
+
+
+### Features
+
+* allow constructable modules ([#133](https://github.com/sern-handler/handler/issues/133)) ([03936eb](https://github.com/sern-handler/handler/commit/03936eb2ea1d1af7cada04d77bb8345d63a5e20f))
+* classmodules@arcs ([#143](https://github.com/sern-handler/handler/issues/143)) ([5028886](https://github.com/sern-handler/handler/commit/50288867a5b171511941a1be3877d721694e9f77))
+* update CODEOWNERS ([6b8995d](https://github.com/sern-handler/handler/commit/6b8995d149c857558415a6c151a3f575ec373445))
+
+
+### Reverts
+
+* feat of allow constructable modules ([#138](https://github.com/sern-handler/handler/issues/138)) ([82bbdda](https://github.com/sern-handler/handler/commit/82bbddac8d656b60b3a1fb2471ea03ee5224f5c3))
+
 ## [1.1.0](https://github.com/sern-handler/handler/compare/v1.0.0...v1.1.0) (2022-08-29)
 
 

README.md

@@ -1,19 +1,33 @@
 <div align="center">
-  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px">
+  <img src="https://raw.githubusercontent.com/sern-handler/.github/main/banner.png" width="900px" />
 </div>
 
 <h1 align="center">Handlers. Redefined.</h1>
-<h4 align="center">A customizable, batteries-included, powerful discord.js framework to streamline bot development.</h4>
+<h4 align="center">A complete, customizable, typesafe, & reactive framework for discord bots</h4>
 
-<div align="center" style="margin-top: 10px">
+<div align="center" styles="margin-top: 10px">
-  <img src="https://img.shields.io/badge/open-source-brightgreen">
+  <img src="https://img.shields.io/badge/open-source-brightgreen" />
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/v/@sern/handler?maxAge=3600" alt="NPM version" /></a>
   <a href="https://www.npmjs.com/package/@sern/handler"><img src="https://img.shields.io/npm/dt/@sern/handler?maxAge=3600" alt="NPM downloads" /></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT"></a>
+  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/license-MIT-brightgreen" alt="License MIT" /></a>
-  <a href="https://sern-handler.js.org"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs"></a>
+  <a href="https://sern.dev"><img alt="docs.rs" src="https://img.shields.io/docsrs/docs" /></a>
-  <img alt="Lines of code" src="https://img.shields.io/badge/total%20lines-2k-blue">
+  <img alt="Lines of code" src="https://img.shields.io/badge/total%20lines-2k-blue" />
 </div>
 
+## Why?
+- Most handlers don't support discord.js 14.7+
+- Customizable commands
+- Plug and play or customize to your liking
+- Embraces reactive programming for consistent and reliable backend
+- Customizable logger, error handling, and more
+- Active development and growing [community](https://sern.dev/discord)
+## 👀 Quick Look
+
+* Support for discord.js v14 and all interactions
+* Hybrid commands
+* Lightweight and customizable
+* ESM, CommonJS and TypeScript support
+* A powerful CLI and awesome community-made plugins
 
 ## 📜 Installation
 
@@ -29,14 +43,6 @@ yarn add @sern/handler
 pnpm add @sern/handler
 ```
 
-## 👀 Quick Look
-
-* Support for discord.js v14 and all interactions
-* Hybrid commands
-* lightweight and customizable
-* ESM, CommonJS and TypeScript support
-* A powerful cli and awesome community-made plugins
-
 ## 👶 Basic Usage
 
 #### ` index.js (CommonJS)`
@@ -46,10 +52,7 @@ pnpm add @sern/handler
 const { Client, GatewayIntentBits } = require('discord.js');
 
 // Import Sern namespace
-const { Sern } = require('@sern/handler');
+const { Sern, single } = require('@sern/handler');
-
-// Our configuration file
-const { defaultPrefix, token } = require('./config.json');
 
 const client = new Client({
   intents: [
@@ -58,32 +61,46 @@ const client = new Client({
     GatewayIntentBits.GuildMessages
   ]
 });
-
+export const useContainer = Sern.makeDependencies({
-Sern.init({
+    build: root => root
-  client,   
+        .add({ '@sern/client': single(() => client)  })
-  defaultPrefix,   
+        .upsert({ '@sern/logger': single(() => new DefaultLogging()) })
-  commands : 'src/commands',
 });
 
-client.login(token);
+//View docs for all options
+Sern.init({
+	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
+	commands: 'src/commands',
+	// events: 'src/events' (optional),
+	containerConfig : {
+		get: useContainer
+	}
+});
+
+client.login("YOUR_BOT_TOKEN_HERE");
 ```
 
 #### ` ping.js (CommonJS)`
 
 ```js
-const { CommandType } = require('@sern/handler');
+const { CommandType, commandModule } = require('@sern/handler');
 
 exports.default = commandModule({
-  name: 'ping',
-  description: 'A ping pong command',
   type: CommandType.Slash,
+  description: 'A ping pong command',
   execute(ctx) {
     ctx.reply('pong!');
   }
 });
 ```
 
-See our [templates](https://github.com/sern-handler/templates) for TypeScript examples and more
+## 🤖 Bots Using sern 
+- [Community Bot](https://github.com/sern-handler/sern-community), the community bot for our [discord server](https://sern.dev/discord).
+- [Vinci](https://github.com/SrIzan10/vinci), the bot for Mara Turing.
+- [Bask](https://github.com/baskbotml/bask), Listen your favorite artists on Discord.
+- [ava](https://github.com/SrIzan10/ava), A discord bot that plays KNGI and Gensokyo Radio.
+- [ALMA (WIP)](https://github.com/Benzo-Fury/ALMA), Using AI to unleash the power in your server.
+- [Protector (WIP)](https://github.com/needhamgary/Protector), Just a simple bot to help enhance a private minecraft server.
 
 ## 💻 CLI
 
@@ -91,15 +108,13 @@ It is **highly encouraged** to use the [command line interface](https://github.c
 
 ## 🔗 Links
 
-- [Official Documentation and Guide](https://sern-handler.js.org)
+- [Official Documentation and Guide](https://sern.dev)
-- [Support Server](https://discord.com/invite/mmyCTnYtbF)
+- [Support Server](https://sern.dev/discord)
 
 ## 👋 Contribute
 
-- Read our contribution [guidelines](https://github.com/sern-handler/handler) carefully
+- Read our contribution [guidelines](https://github.com/sern-handler/handler/blob/main/.github/CONTRIBUTING.md) carefully
 - Pull up on [issues](https://github.com/sern-handler/handler/issues) and report bugs
 - All kinds of contributions are welcomed.
 
-## 🚈 Roadmap
 
-You can check our [roadmap](https://github.com/sern-handler/roadmap) to see what's going to be added or patched in the future.

package.json

@@ -1,6 +1,7 @@
 {
     "name": "@sern/handler",
-    "version": "1.1.0",
+    "packageManager": "pnpm@7.27.0",
+    "version": "2.5.2",
     "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",
@@ -12,12 +13,13 @@
         }
     },
     "scripts": {
-        "watch": "tsup --watch --dts",
+        "watch": "tsup --dts --watch",
         "clean-modules": "rimraf node_modules/ && npm install",
         "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,24 +33,23 @@
     "author": "SernDevs",
     "license": "MIT",
     "dependencies": {
-        "rxjs": "^7.5.6",
+        "iti": "^0.6.0",
-        "ts-pattern": "^4.0.2",
+        "rxjs": "^7.8.0",
+        "ts-pattern": "^4.1.4",
         "ts-results-es": "^3.5.0"
     },
     "devDependencies": {
-        "@typescript-eslint/eslint-plugin": "5.35.1",
+        "@typescript-eslint/eslint-plugin": "5.51.0",
-        "@typescript-eslint/parser": "5.35.1",
+        "@typescript-eslint/parser": "5.48.0",
-        "eslint": "8.22.0",
+        "discord.js": "^14.7.1",
-        "prettier": "2.7.1",
+        "eslint": "8.30.0",
-        "tsup": "^6.1.3",
+        "prettier": "2.8.4",
-        "typescript": "4.7.4"
+        "tsup": "^6.6.3",
-    },
+        "typescript": "4.9.4"
-    "peerDependencies": {
-        "discord.js": "^14.2.x"
     },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/sern-handler/handler.git"
     },
-    "homepage": "https://sern-handler.js.org"
+    "homepage": "https://sern.dev"
 }

src/handler/contracts/errorHandling.ts

@@ -0,0 +1,45 @@
+import type { Observable } from 'rxjs';
+import type { Logging } from './logging';
+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) {
+            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,27 @@
+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,23 @@
+import type { CommandModuleDefs } from '../../types/module';
+import type { CommandType, ModuleStore } from '../structures';
+import type { Processed } from '../../types/handler';
+
+export interface ModuleManager {
+    get<T extends CommandType>(
+        strat: (ms: ModuleStore) => Processed<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) => Processed<CommandModuleDefs[T]> | undefined,
+    ) {
+        return strat(this.moduleStore);
+    }
+
+    set(strat: (ms: ModuleStore) => void): void {
+        strat(this.moduleStore);
+    }
+}

src/handler/dependencies/index.ts

@@ -0,0 +1,2 @@
+export { single, transient, many } from './lifetimeFunctions';
+export { useContainerRaw } from './provider';

src/handler/dependencies/lifetimeFunctions.ts

@@ -0,0 +1,57 @@
+import { _const } from '../utilities/functions';
+
+type NotFunction =
+    | string
+    | number
+    | boolean
+    | null
+    | undefined
+    | bigint
+    | readonly any[]
+    | { apply?: never; [k: string]: any }
+    | { call?: never; [k: string]: any };
+
+/**
+ * @deprecated
+ * @param cb
+ */
+export function single<T extends NotFunction>(cb: T): () => T;
+/**
+ * New signature
+ * @param cb
+ */
+export function single<T extends () => unknown>(cb: T): T;
+/**
+ * Please note that on intellij, the deprecation is for all signatures, which is unintended behavior (and
+ * very annoying).
+ * For future versions, ensure that single is being passed as a **callback!!**
+ * @param cb
+ */
+export function single<T>(cb: T) {
+    if (typeof cb === 'function') return cb;
+    return () => cb;
+}
+/**
+ * @deprecated
+ * @param cb
+ * Deprecated signature
+ */
+export function transient<T extends NotFunction>(cb: T): () => () => T;
+export function transient<T extends () => () => unknown>(cb: T): T;
+/**
+ * Following iti's singleton and transient implementation,
+ * use transient if you want a new dependency every time your container getter is called
+ * @param cb
+ */
+export function transient<T>(cb: (() => () => T) | T) {
+    if (typeof cb !== 'function') return () => () => cb;
+    return cb;
+}
+
+/**
+ * @deprecated
+ * @param value
+ * Please use the transient function instead
+ */
+// prettier-ignore
+export const many = <T>(value: T) => () => _const(value);

src/handler/dependencies/provider.ts

@@ -0,0 +1,73 @@
+import type { Container } from 'iti';
+import { SernError } from '../structures/errors';
+import type { Dependencies, DependencyConfiguration, MapDeps } from '../../types/handler';
+import SernEmitter from '../sernEmitter';
+import { DefaultErrorHandling, DefaultLogging, DefaultModuleManager } from '../contracts';
+import { ModuleStore } from '../structures/moduleStore';
+import { Result } from 'ts-results-es';
+import { BehaviorSubject } from 'rxjs';
+import { createContainer } from 'iti';
+
+export const containerSubject = new BehaviorSubject(defaultContainer());
+
+/**
+ * Given the user's conf, check for any excluded dependency keys.
+ * Then, call conf.build to get the rest of the users' dependencies.
+ * Finally, update the containerSubject with the new container state
+ * @param conf
+ */
+export function composeRoot<T extends Dependencies>(conf: DependencyConfiguration<T>) {
+    //Get the current container. This should have no client or possible logger yet.
+    const currentContainer = containerSubject.getValue();
+    const excludeLogger = conf.exclude?.has('@sern/logger');
+    if (!excludeLogger) {
+        currentContainer.add({
+            '@sern/logger': () => new DefaultLogging(),
+        });
+    }
+    //Build the container based on the callback provided by the user
+    const container = conf.build(currentContainer);
+    //Check if the built container contains @sern/client or throw
+    // a runtime exception
+    Result.wrap(() => container.get('@sern/client')).expect(SernError.MissingRequired);
+
+    if (!excludeLogger) {
+        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
+    }
+    //I'm sorry little one
+    containerSubject.next(container as any);
+}
+
+export function useContainer<T extends Dependencies>() {
+    const container = containerSubject.getValue() as Container<T, {}>;
+    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.
+ * Please be careful as this only gets the client's current state.
+ * Exposes some methods from iti
+ */
+export function useContainerRaw<T extends Dependencies>() {
+    return containerSubject.getValue() as Container<T, {}>;
+}
+
+/**
+ * Provides all the defaults for sern to function properly.
+ * The only user provided dependency needs to be @sern/client
+ */
+function defaultContainer() {
+    return createContainer()
+        .add({ '@sern/errors': () => new DefaultErrorHandling() })
+        .add({ '@sern/store': () => new ModuleStore() })
+        .add(ctx => {
+            return {
+                '@sern/modules': () => new DefaultModuleManager(ctx['@sern/store']),
+            };
+        })
+        .add({ '@sern/emitter': () => new SernEmitter() }) as Container<
+        Omit<Dependencies, '@sern/client' | '@sern/logger'>,
+        {}
+    >;
+}

src/handler/events/dispatchers.ts

@@ -1,110 +0,0 @@
-import type {
-    BothCommand,
-    ButtonCommand,
-    ContextMenuMsg,
-    ContextMenuUser,
-    ModalSubmitCommand,
-    SelectMenuCommand,
-    SlashCommand,
-} from '../structures/module';
-import Context from '../structures/context';
-import type { SlashOptions } from '../../types/handler';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
-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';
-
-export function applicationCommandDispatcher(interaction: Interaction) {
-    if (isAutocomplete(interaction)) {
-        return dispatchAutocomplete(interaction);
-    } else {
-        const ctx = Context.wrap(interaction as ChatInputCommandInteraction);
-        const args: ['slash', SlashOptions] = ['slash', ctx.interaction.options];
-        return (mod: BothCommand | SlashCommand) => ({
-            mod,
-            execute: () => mod.execute(ctx, args),
-            eventPluginRes: asyncResolveArray(
-                mod.onEvent.map(plugs => plugs.execute([ctx, args], controller)),
-            ),
-        });
-    }
-}
-
-export function dispatchAutocomplete(interaction: AutocompleteInteraction) {
-    return (mod: BothCommand | SlashCommand) => {
-        const selectedOption = treeSearch(interaction, mod.options);
-        if (selectedOption !== undefined) {
-            return {
-                mod,
-                execute: () => selectedOption.command.execute(interaction),
-                eventPluginRes: asyncResolveArray(
-                    selectedOption.command.onEvent.map(e => e.execute(interaction, controller)),
-                ),
-            };
-        }
-        throw Error(
-            SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
-        );
-    };
-}
-
-export function modalCommandDispatcher(interaction: ModalSubmitInteraction) {
-    return (mod: ModalSubmitCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function buttonCommandDispatcher(interaction: ButtonInteraction) {
-    return (mod: ButtonCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function selectMenuCommandDispatcher(interaction: SelectMenuInteraction) {
-    return (mod: SelectMenuCommand) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function ctxMenuUserDispatcher(interaction: UserContextMenuCommandInteraction) {
-    return (mod: ContextMenuUser) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}
-
-export function ctxMenuMsgDispatcher(interaction: MessageContextMenuCommandInteraction) {
-    return (mod: ContextMenuMsg) => ({
-        mod,
-        execute: () => mod.execute(interaction),
-        eventPluginRes: asyncResolveArray(
-            mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
-        ),
-    });
-}

src/handler/events/dispatchers/dispatchers.ts

@@ -0,0 +1,64 @@
+import type { Processed } from '../../../types/handler';
+import type { AutocompleteInteraction } from 'discord.js';
+import { SernError } from '../../structures';
+import treeSearch from '../../utilities/treeSearch';
+import type { BothCommand, CommandModule, Module, SlashCommand } from '../../../types/module';
+import { EventEmitter } from 'events';
+import * as assert from 'assert';
+import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
+import { callPlugin } from '../operators';
+import { createResultResolver } from '../observableHandling';
+
+export function dispatchCommand(module: Processed<CommandModule>, createArgs: () => unknown[]) {
+    const args = createArgs();
+    return {
+        module,
+        args,
+    };
+}
+
+/**
+ * Creates an observable from { source }
+ * @param module
+ * @param source
+ */
+export function eventDispatcher(module: Processed<Module>, source: unknown) {
+    assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
+    /**
+     * Sometimes fromEvent emits a single parameter, which is not an Array. This
+     * operator function flattens events into an array
+     * @param src
+     */
+    const arrayify = pipe(
+        map(event => (Array.isArray(event) ? (event as unknown[]) : [event])),
+        map(args => ({ module, args })),
+    );
+    const createResult = createResultResolver<
+        Processed<Module>,
+        { module: Processed<Module>; args: unknown[] },
+        unknown[]
+    >({
+        createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
+        onSuccess: ({ args }) => args,
+    });
+    const execute: OperatorFunction<unknown[], unknown> = pipe(
+        concatMap(async args => module.execute(...args)),
+    );
+    return fromEvent(source, module.name).pipe(arrayify, concatMap(createResult), execute);
+}
+
+export function dispatchAutocomplete(
+    module: Processed<BothCommand | SlashCommand>,
+    interaction: AutocompleteInteraction,
+) {
+    const option = treeSearch(interaction, module.options);
+    if (option !== undefined) {
+        return {
+            module: option.command as Processed<Module>, //autocomplete is not a true "module" warning cast!
+            args: [interaction],
+        };
+    }
+    throw Error(
+        SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
+    );
+}

src/handler/events/dispatchers/index.ts

@@ -0,0 +1,2 @@
+export * from './dispatchers';
+export * from './provideArgs';

src/handler/events/dispatchers/provideArgs.ts

@@ -0,0 +1,23 @@
+import type { ChatInputCommandInteraction, Interaction, Message } from 'discord.js';
+import { Context } from '../../structures';
+import type { Args, SlashOptions } from '../../../types/handler';
+
+/**
+ * function overloads to create an arguments list for Context
+ * @param wrap
+ * @param messageArgs
+ */
+export function contextArgs(
+    wrap: Message,
+    messageArgs?: string[],
+): () => [Context, ['text', string[]]];
+export function contextArgs(wrap: Interaction): () => [Context, ['slash', SlashOptions]];
+export function contextArgs(wrap: Interaction | Message, messageArgs?: string[]) {
+    const ctx = Context.wrap(wrap as ChatInputCommandInteraction | Message);
+    const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.interaction.options];
+    return () => [ctx, args] as [Context, Args];
+}
+
+export function interactionArg<T extends Interaction>(interaction: T) {
+    return () => [interaction] as [T];
+}

src/handler/events/eventsHandler.ts

@@ -1,10 +1,34 @@
 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';
 
+/**
+ * why did I make this, definitely going to be changed in the future
+ */
 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

@@ -1,123 +1,137 @@
 import type { Interaction } from 'discord.js';
-import { catchError, concatMap, from, fromEvent, map, Observable } from 'rxjs';
+import { catchError, concatMap, finalize, fromEvent, map, Observable } from 'rxjs';
 import type Wrapper from '../structures/wrapper';
 import { EventsHandler } from './eventsHandler';
-import {
+import { CommandType, SernError, type ModuleStore } from '../structures';
-    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';
-import {
+import { contextArgs, interactionArg, dispatchAutocomplete, dispatchCommand } from './dispatchers';
-    applicationCommandDispatcher,
+import { executeModule, makeModuleExecutor } from './observableHandling';
-    buttonCommandDispatcher,
+import type { CommandModule } from '../../types/module';
-    ctxMenuMsgDispatcher,
+import { handleError } from '../contracts/errorHandling';
-    ctxMenuUserDispatcher,
+import SernEmitter from '../sernEmitter';
-    modalCommandDispatcher,
+import type { Processed } from '../../types/handler';
-    selectMenuCommandDispatcher,
+import { useContainerRaw } from '../dependencies';
-} from './dispatchers';
-import type {
-    ButtonInteraction,
-    ModalSubmitInteraction,
-    SelectMenuInteraction,
-    UserContextMenuCommandInteraction,
-    MessageContextMenuCommandInteraction,
-} from 'discord.js';
-import { executeModule } from './observableHandling';
 
 export default class InteractionHandler extends EventsHandler<{
     event: Interaction;
-    mod: CommandModule;
+    module: Processed<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),
+                map(this.createDispatcher),
-                concatMap(({ mod, execute, eventPluginRes }) => {
+                makeModuleExecutor(module => {
-                    //resolve all the Results from event plugins
+                    this.emitter.emit(
-                    return from(eventPluginRes).pipe(map(res => ({ mod, res, execute })));
+                        'module.activate',
+                        SernEmitter.failure(module, SernError.PluginFailure),
+                    );
                 }),
-                concatMap(payload => executeModule(wrapper, payload)),
+                concatMap(payload => executeModule(this.emitter, payload)),
-                catchError((err, caught) => {
+                catchError(handleError(this.crashHandler, this.logger)),
-                    wrapper.sernEmitter?.emit('error', err);
+                finalize(() => {
-                    return caught;
+                    this.logger?.info({
+                        message: 'interactionCreate stream closed or reached end of lifetime',
+                    });
+                    useContainerRaw()
+                        ?.disposeAll()
+                        .then(() => {
+                            this.logger?.info({ message: 'Cleaning container and crashing' });
+                        });
                 }),
             )
             .subscribe();
     }
 
     override init() {
+        const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
+            return this.modules.get(cb);
+        };
+        /**
+         * Module retrieval:
+         * ModuleStores are mapped by Discord API values and modules mapped
+         * by customId or command name.
+         */
         this.discordEvent.subscribe({
             next: event => {
-                if (isMessageComponent(event)) {
+                if (event.isMessageComponent()) {
-                    const mod = Files.MessageCompCommands[event.componentType].get(event.customId);
+                    const module = get(ms =>
-                    this.setState({ event, mod });
+                        ms.InteractionHandlers[event.componentType].get(event.customId),
-                } else if (isApplicationCommand(event) || isAutocomplete(event)) {
+                    );
-                    const mod =
+                    this.setState({ event, module });
-                        Files.ApplicationCommands[event.commandType].get(event.commandName) ??
+                } else if (event.isCommand() || event.isAutocomplete()) {
-                        Files.BothCommands.get(event.commandName);
+                    const module = get(
-                    this.setState({ event, mod });
+                        ms =>
-                } else if (isModalSubmit(event)) {
+                            /**
-                    /**
+                             * try to fetch from ApplicationCommands, if nothing, try BothCommands
-                     * maybe move modal submits into message component object maps?
+                             * map. If nothing again,this means a slash command
-                     */
+                             * exists on the API but not sern
-                    const mod = Files.ModalSubmitCommands.get(event.customId);
+                             */
-                    this.setState({ event, mod });
+                            ms.ApplicationCommands[event.commandType].get(event.commandName) ??
+                            ms.BothCommands.get(event.commandName),
+                    );
+                    this.setState({ event, module });
+                } else if (event.isModalSubmit()) {
+                    const module = get(ms => ms.ModalSubmit.get(event.customId));
+                    this.setState({ event, module });
                 } else {
                     throw Error('This interaction is not supported yet');
                 }
             },
             error: reason => {
-                this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason });
+                this.emitter.emit('error', SernEmitter.failure(undefined, reason));
             },
         });
     }
 
-    protected setState(state: { event: Interaction; mod: CommandModule | undefined }): void {
+    protected setState(state: { event: Interaction; module: CommandModule | undefined }): void {
-        if (state.mod === undefined) {
+        if (state.module === undefined) {
-            this.wrapper?.sernEmitter?.emit('warning', 'Found no module for this interaction');
+            this.emitter.emit(
+                'warning',
+                SernEmitter.warning('Found no module for this interaction'),
+            );
         } else {
             //if statement above checks already, safe cast
-            this.payloadSubject.next(state as { event: Interaction; mod: CommandModule });
+            this.payloadSubject.next(
+                state as { event: Interaction; module: Processed<CommandModule> },
+            );
         }
     }
 
-    protected processModules({ mod, event }: { event: Interaction; mod: CommandModule }) {
+    protected createDispatcher({
-        return match(mod)
+        module,
-            .with(
+        event,
-                { type: P.union(CommandType.Slash, CommandType.Both) },
+    }: {
-                applicationCommandDispatcher(event),
+        event: Interaction;
-            )
+        module: Processed<CommandModule>;
-            .with(
+    }) {
-                { type: CommandType.Modal },
+        return (
-                modalCommandDispatcher(event as ModalSubmitInteraction),
+            match(module)
-            )
+                .with({ type: CommandType.Text }, () =>
-            .with({ type: CommandType.Button }, buttonCommandDispatcher(event as ButtonInteraction))
+                    this.crashHandler.crash(Error(SernError.MismatchEvent)),
-            .with(
+                )
-                { type: CommandType.MenuSelect },
+                //P.union = either CommandType.Slash or CommandType.Both
-                selectMenuCommandDispatcher(event as SelectMenuInteraction),
+                .with({ type: P.union(CommandType.Slash, CommandType.Both) }, module => {
-            )
+                    if (event.isAutocomplete()) {
-            .with(
+                        /**
-                { type: CommandType.MenuUser },
+                         * Autocomplete is a special case that
-                ctxMenuUserDispatcher(event as UserContextMenuCommandInteraction),
+                         * must be handled separately, since it's
-            )
+                         * too different from regular command modules
-            .with(
+                         */
-                { type: CommandType.MenuMsg },
+                        return dispatchAutocomplete(module, event);
-                ctxMenuMsgDispatcher(event as MessageContextMenuCommandInteraction),
+                    } else {
-            )
+                        return dispatchCommand(module, contextArgs(event));
-            .otherwise(() => {
+                    }
-                throw Error(SernError.MismatchModule);
+                })
-            });
+                /**
+                 * Every other command module takes a one argument parameter, its corresponding interaction
+                 * this makes this usage safe
+                 */
+                .otherwise(mod => dispatchCommand(mod, interactionArg(event)))
+        );
     }
 }

src/handler/events/messageHandler.ts

@@ -1,44 +1,45 @@
 import { EventsHandler } from './eventsHandler';
-import { catchError, concatMap, from, fromEvent, map, Observable, of, switchMap } from 'rxjs';
+import { catchError, concatMap, EMPTY, finalize, fromEvent, map, Observable, of } from 'rxjs';
-import type Wrapper from '../structures/wrapper';
+import { type Wrapper, type ModuleStore, SernError } from '../structures';
 import type { Message } from 'discord.js';
-import { executeModule, ignoreNonBot, isOneOfCorrectModules } from './observableHandling';
+import { executeModule, ignoreNonBot, makeModuleExecutor } from './observableHandling';
 import { fmt } from '../utilities/messageHelpers';
-import Context from '../structures/context';
+import type { CommandModule, Module, TextCommand } from '../../types/module';
-import * as Files from '../utilities/readFile';
+import { handleError } from '../contracts/errorHandling';
-import type { TextCommand } from '../structures/module';
+import { contextArgs, dispatchCommand } from './dispatchers';
-import { CommandType, PayloadType } from '../structures/enums';
+import SernEmitter from '../sernEmitter';
-import { asyncResolveArray } from '../utilities/asyncResolveArray';
+import type { Processed } from '../../types/handler';
-import { controller } from '../sern';
+import { useContainerRaw } from '../dependencies';
 
 export default class MessageHandler extends EventsHandler<{
-    ctx: Context;
+    module: Processed<Module>;
-    args: ['text', string[]];
+    args: unknown[];
-    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 }) => {
+                makeModuleExecutor(module => {
-                    const res = asyncResolveArray(
+                    this.emitter.emit(
-                        mod.onEvent.map(ePlug => {
+                        'module.activate',
-                            return ePlug.execute([ctx, args], controller);
+                        SernEmitter.failure(module, SernError.PluginFailure),
-                        }),
                     );
-                    const execute = () => {
-                        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)),
+                concatMap(payload => executeModule(this.emitter, payload)),
-                catchError((err, caught) => {
+                catchError(handleError(this.crashHandler, this.logger)),
-                    wrapper.sernEmitter?.emit('error', err);
+                finalize(() => {
-                    return caught;
+                    this.logger?.info({
+                        message: 'messageCreate stream closed or reached end of lifetime',
+                    });
+                    useContainerRaw()
+                        ?.disposeAll()
+                        .then(() => {
+                            this.logger?.info({ message: 'Cleaning container and crashing' });
+                        });
                 }),
             )
             .subscribe();
@@ -47,35 +48,37 @@ 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) => Processed<CommandModule> | undefined) => {
+            return this.modules.get(cb);
+        };
         this.discordEvent
             .pipe(
                 ignoreNonBot(this.wrapper.defaultPrefix),
-                map(message => {
+                //This concatMap checks if module is undefined, and if it is, do not continue.
+                // Synonymous to filterMap, but I haven't thought of a generic implementation for filterMap yet
+                concatMap(message => {
                     const [prefix, ...rest] = fmt(message, defaultPrefix);
-                    return {
+                    const module = get(
-                        ctx: Context.wrap(message),
+                        ms => ms.TextCommands.get(prefix) ?? ms.BothCommands.get(prefix),
-                        args: <['text', string[]]>['text', rest],
+                    );
-                        mod:
+                    if (module === undefined) {
-                            Files.TextCommands.text.get(prefix) ??
+                        return EMPTY;
-                            Files.BothCommands.get(prefix) ??
+                    }
-                            Files.TextCommands.aliases.get(prefix),
+                    const payload = {
+                        args: contextArgs(message, rest),
+                        module,
                     };
+                    return of(payload);
                 }),
-                concatMap(element =>
+                map(({ args, module }) => dispatchCommand(module as Processed<TextCommand>, args)),
-                    of(element.mod).pipe(
-                        isOneOfCorrectModules(CommandType.Text),
-                        map(mod => ({ ...element, mod })),
-                    ),
-                ),
             )
             .subscribe({
                 next: value => this.setState(value),
-                error: reason =>
+                error: reason => this.emitter.emit('error', SernEmitter.failure(reason)),
-                    this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason }),
             });
     }
 
-    protected setState(state: { ctx: Context; args: ['text', string[]]; mod: TextCommand }) {
+    protected setState(state: { module: Processed<Module>; args: unknown[] }) {
         this.payloadSubject.next(state);
     }
 }

src/handler/events/observableHandling.ts

@@ -1,15 +1,21 @@
-import type { Message } from 'discord.js';
+import type { Awaitable, Message } from 'discord.js';
-import { concatMap, from, Observable, of, tap, throwError } from 'rxjs';
+import { concatMap, EMPTY, from, Observable, of, pipe, tap, throwError } from 'rxjs';
-import { SernError } from '../structures/errors';
+import type { SernError } from '../structures';
-import type { Module, CommandModuleDefs, CommandModule } from '../structures/module';
 import { Result } from 'ts-results-es';
-import type { CommandType } from '../structures/enums';
+import type { AnyModule, CommandModule, EventModule, Module } from '../../types/module';
-import type Wrapper from '../structures/wrapper';
+import { _const as i } from '../utilities/functions';
-import { PayloadType } from '../structures/enums';
+import SernEmitter from '../sernEmitter';
+import { callPlugin, everyPluginOk, filterMapTo } from './operators';
+import type { Processed } from '../../types/handler';
+import type { ControlPlugin, VoidResult } from '../../types/plugin';
 
-export function ignoreNonBot(prefix: string) {
+/**
-    return (src: Observable<Message>) =>
+ * Ignores messages from any person / bot except itself
-        new Observable<Message>(subscriber => {
+ * @param prefix
+ */
+export function ignoreNonBot<T extends Message>(prefix: string) {
+    return (src: Observable<T>) =>
+        new Observable<T>(subscriber => {
             return src.subscribe({
                 next(m) {
                     const messageFromHumanAndHasPrefix =
@@ -21,19 +27,19 @@ export function ignoreNonBot(prefix: string) {
                         subscriber.next(m);
                     }
                 },
-                error: e => subscriber.error(e),
-                complete: () => subscriber.complete(),
             });
         });
 }
 
 /**
  * If the current value in Result stream is an error, calls callback.
+ * This also extracts the Ok value from Result
  * @param cb
+ * @returns Observable<{ module: T; absPath: string }>
  */
-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>>) =>
+    return (src: Observable<Result<{ module: T; absPath: string }, SernError>>) =>
-        new Observable<{ mod: T; absPath: string }>(subscriber => {
+        new Observable<{ module: T; absPath: string }>(subscriber => {
             return src.subscribe({
                 next(value) {
                     if (value.err) {
@@ -42,71 +48,108 @@ export function errTap<T extends Module>(cb: (err: SernError) => void) {
                         subscriber.next(value.val);
                     }
                 },
-                error: e => subscriber.error(e),
-                complete: () => subscriber.complete(),
             });
         });
 }
 
-//POG
+/**
-export function isOneOfCorrectModules<T extends readonly CommandType[]>(...inputs: [...T]) {
+ * Wraps the task in a Result as a try / catch.
-    return (src: Observable<CommandModule | undefined>) => {
+ * if the task is ok, an event is emitted and the stream becomes empty
-        return new Observable<CommandModuleDefs[T[number]]>(subscriber => {
+ * if the task is an error, throw an error down the stream which will be handled by catchError
-            return src.subscribe({
+ * @param emitter reference to SernEmitter that will emit a successful execution of module
-                next(mod) {
+ * @param module the module that will be executed with task
-                    if (mod === undefined) {
+ * @param task the deferred execution which will be called
-                        return throwError(() => SernError.UndefinedModule);
+ */
-                    }
+export function executeModule(
-                    if (inputs.some(type => (mod.type & type) !== 0)) {
+    emitter: SernEmitter,
-                        subscriber.next(mod as CommandModuleDefs[T[number]]);
+    {
-                    } else {
+        module,
-                        return throwError(() => SernError.MismatchModule);
+        task,
-                    }
+    }: {
-                },
+        module: Processed<Module>;
-                error: e => subscriber.error(e),
+        task: () => Awaitable<unknown>;
-                complete: () => subscriber.complete(),
+    },
-            });
+) {
-        });
+    return of(module).pipe(
+        //converting the task into a promise so rxjs can resolve the Awaitable properly
+        concatMap(() => Result.wrapAsync(async () => task())),
+        concatMap(result => {
+            if (result.ok) {
+                emitter.emit('module.activate', SernEmitter.success(module));
+                return EMPTY;
+            } else {
+                return throwError(i(SernEmitter.failure(module, result.val)));
+            }
+        }),
+    );
+}
+
+/**
+ * A higher order function that
+ * - creates a stream of {@link VoidResult} { config.createStream }
+ * - any failures results to { config.onFailure } being called
+ * - if all results are ok, the stream is converted to { config.onSuccess }
+ * emit config.onSuccess Observable
+ * @param config
+ * @returns receiver function for flattening a stream of data
+ */
+export function createResultResolver<
+    T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
+    Args extends { module: T; [key: string]: unknown },
+    Output,
+>(config: {
+    onFailure?: (module: T) => unknown;
+    onSuccess: (args: Args) => Output;
+    createStream: (args: Args) => Observable<VoidResult>;
+}) {
+    return (args: Args) => {
+        const task$ = config.createStream(args);
+        return task$.pipe(
+            tap(result => {
+                if (result.err) {
+                    config.onFailure?.(args.module);
+                }
+            }),
+            everyPluginOk(),
+            filterMapTo(() => config.onSuccess(args)),
+        );
     };
 }
 
-export function executeModule(
+/**
-    wrapper: Wrapper,
+ * Calls a module's init plugins and checks for Err. If so, call { onFailure } and
-    payload: {
+ * ignore the module
-        mod: CommandModule;
+ */
-        execute: () => unknown;
+export function scanModule<
-        res: Result<void, void>[];
+    T extends Processed<CommandModule | EventModule>,
-    },
+    Args extends { module: T; absPath: string },
-) {
+>(config: { onFailure?: (module: T) => unknown; onSuccess: (module: Args) => T }) {
-    if (payload.res.every(el => el.ok)) {
+    return pipe(
-        const executeFn = Result.wrapAsync<unknown, Error | string>(() =>
+        concatMap(
-            Promise.resolve(payload.execute()),
+            createResultResolver({
-        );
+                createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
-        return from(executeFn).pipe(
+                ...config,
-            concatMap(res => {
-                if (res.err) {
-                    return throwError(() => ({
-                        type: PayloadType.Failure,
-                        reason: res.val,
-                        module: payload.mod,
-                    }));
-                }
-                return of(res.val).pipe(
-                    tap(() =>
-                        wrapper.sernEmitter?.emit('module.activate', {
-                            type: PayloadType.Success,
-                            module: payload.mod,
-                        }),
-                    ),
-                );
             }),
-        );
+        ),
-    } else {
+    );
-        wrapper.sernEmitter?.emit('module.activate', {
+}
-            type: PayloadType.Failure,
+
-            module: payload.mod,
+/**
-            reason: SernError.PluginFailure,
+ * Creates an executable task ( execute the command ) if  all control plugins are successful
-        });
+ * @param onFailure emits a failure response to the SernEmitter
-        return of(undefined);
+ */
-    }
+export function makeModuleExecutor<
+    M extends Processed<Module>,
+    Args extends { module: M; args: unknown[] },
+>(onFailure: (m: M) => unknown) {
+    const onSuccess = ({ args, module }: Args) => ({ task: () => module.execute(...args), module });
+    return pipe(
+        concatMap(
+            createResultResolver({
+                onFailure,
+                createStream: ({ args, module }) => from(module.onEvent).pipe(callPlugin(args)),
+                onSuccess,
+            }),
+        ),
+    );
 }

src/handler/events/operators/index.ts

@@ -0,0 +1,70 @@
+/**
+ * This file holds sern's rxjs operators used for processing data.
+ * Each function should be modular and testable, not bound to discord / sern
+ * and independent of each other
+ */
+
+import { concatMap, defaultIfEmpty, EMPTY, every, map, of, OperatorFunction, pipe } from 'rxjs';
+import type { AnyModule } from '../../../types/module';
+import { nameOrFilename } from '../../utilities/functions';
+import type { PluginResult, VoidResult } from '../../../types/plugin';
+import { guayin } from '../../plugins';
+import { controller } from '../../sern';
+
+/**
+ * if {src} is true, mapTo V, else ignore
+ * @param item
+ */
+export function filterMapTo<V>(item: () => V): OperatorFunction<boolean, V> {
+    return pipe(concatMap(shouldKeep => (shouldKeep ? of(item()) : EMPTY)));
+}
+
+/**
+ * Calls any plugin with {args}.
+ * @param args if an array, its spread and plugin called.
+ */
+export function callPlugin(args: unknown): OperatorFunction<
+    {
+        execute: (...args: unknown[]) => PluginResult;
+    },
+    VoidResult
+> {
+    return pipe(
+        concatMap(async plugin => {
+            const isNewPlugin = Reflect.has(plugin, guayin);
+            if (isNewPlugin) {
+                if (Array.isArray(args)) {
+                    return plugin.execute(...args);
+                }
+                return plugin.execute(args);
+            } else {
+                return plugin.execute(args, controller);
+            }
+        }),
+    );
+}
+
+/**
+ * operator function that fill the defaults for a module
+ */
+export function defineAllFields<T extends AnyModule>() {
+    const fillFields = ({ absPath, module }: { absPath: string; module: T }) => ({
+        absPath,
+        module: {
+            name: nameOrFilename(module.name, absPath),
+            description: module.description ?? '...',
+            ...module,
+        },
+    });
+    return pipe(map(fillFields));
+}
+
+/**
+ * Checks if the stream of results is all ok.
+ */
+export function everyPluginOk(): OperatorFunction<VoidResult, boolean> {
+    return pipe(
+        every(result => result.ok),
+        defaultIfEmpty(true),
+    );
+}

src/handler/events/readyHandler.ts

@@ -1,159 +1,119 @@
 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, type Observable, take } from 'rxjs';
-import type { CommandModule } from '../structures/module';
 import * as Files from '../utilities/readFile';
-import { errTap } from './observableHandling';
+import { errTap, scanModule } from './observableHandling';
-import type { DefinedCommandModule } from '../../types/handler';
+import { CommandType, SernError, type ModuleStore } from '../structures';
-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 { Processed } from '../../types/handler';
+import type { ModuleManager } from '../contracts';
+import { _const, err, ok } from '../utilities/functions';
+import { defineAllFields } from './operators';
+import SernEmitter from '../sernEmitter';
 
 export default class ReadyHandler extends EventsHandler<{
-    mod: DefinedCommandModule;
+    module: Processed<CommandModule>;
     absPath: string;
 }> {
-    protected discordEvent!: Observable<{ mod: CommandModule; absPath: string }>;
+    protected discordEvent!: Observable<{ module: 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 =>
+                    errTap(reason => {
-                        wrapper.sernEmitter?.emit('module.register', {
+                        this.emitter.emit(
-                            type: PayloadType.Failure,
+                            'module.register',
-                            module: undefined,
+                            SernEmitter.failure(undefined, reason),
-                            reason,
+                        );
-                        }),
+                    }),
-                    ),
                 ),
             ),
         );
         this.init();
         this.payloadSubject
             .pipe(
-                concatMap(payload => this.processPlugins(payload)),
+                scanModule({
-                concatMap(payload => this.resolvePlugins(payload)),
+                    onFailure: module => {
+                        this.emitter.emit(
+                            'module.register',
+                            SernEmitter.failure(module, SernError.PluginFailure),
+                        );
+                    },
+                    onSuccess: ({ module }) => {
+                        this.emitter.emit('module.register', SernEmitter.success(module));
+                        return module;
+                    },
+                }),
             )
-            .subscribe(payload => {
+            .subscribe(module => {
-                const allPluginsSuccessful = payload.pluginRes.every(({ execute }) => execute.ok);
+                const res = registerModule(this.modules, module as Processed<CommandModule>);
-                if (allPluginsSuccessful) {
+                if (res.err) {
-                    const res = registerModule(payload.mod);
+                    this.crashHandler.crash(Error(SernError.InvalidModuleType));
-                    if (res.err) {
-                        throw Error(SernError.InvalidModuleType);
-                    }
-                    wrapper.sernEmitter?.emit('module.register', {
-                        type: PayloadType.Success,
-                        module: payload.mod,
-                    });
-                } else {
-                    wrapper.sernEmitter?.emit('module.register', {
-                        type: PayloadType.Failure,
-                        module: payload.mod,
-                        reason: SernError.PluginFailure,
-                    });
                 }
             });
     }
-    private static intoDefinedModule({ absPath, mod }: { absPath: string; mod: CommandModule }): {
-        absPath: string;
-        mod: DefinedCommandModule;
-    } {
-        return {
-            absPath,
-            mod: {
-                name: mod?.name ?? Files.fmtFileName(basename(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({
+        this.discordEvent.pipe(defineAllFields()).subscribe({
             next: value => this.setState(value),
             complete: () => this.payloadSubject.unsubscribe(),
         });
     }
-    protected setState(state: { absPath: string; mod: DefinedCommandModule }): void {
+    protected setState(state: { absPath: string; module: Processed<CommandModule> }): void {
         this.payloadSubject.next(state);
     }
 }
 
-function registerModule(mod: DefinedCommandModule): Result<void, void> {
+function registerModule<T extends Processed<CommandModule>>(
+    manager: ModuleManager,
+    mod: T,
+): 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(mod as Processed<CommandModule>)
         .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,72 @@
-import { from, fromEvent, map } from 'rxjs';
+import { catchError, finalize, map, tap } from 'rxjs';
-import * as Files from '../utilities/readFile';
+import { buildData } from '../utilities/readFile';
-import { buildData, ExternalEventEmitters } from '../utilities/readFile';
+import type { Dependencies, Processed } from '../../types/handler';
-import { controller } from '../sern';
+import { errTap, scanModule } from './observableHandling';
-import type {
+import type { CommandModule, EventModule } from '../../types/module';
-    DefinedCommandModule,
+import type { EventEmitter } from 'events';
-    DefinedEventModule,
+import SernEmitter from '../sernEmitter';
-    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 { match } from 'ts-pattern';
-import { isDiscordEvent, isSernEvent } from '../utilities/predicates';
+import type { ErrorHandling, Logging } from '../contracts';
-import { errTap } from './observableHandling';
+import { SernError, EventType, type Wrapper } from '../structures';
+import { eventDispatcher } from './dispatchers';
+import { handleError } from '../contracts/errorHandling';
+import { defineAllFields } from './operators';
+import { useContainerRaw } from '../dependencies';
 
-/**
+export function processEvents({ containerConfig, events }: Wrapper) {
- * Utility function to process command plugins for all Modules
+    const [client, errorHandling, sernEmitter, logger] = containerConfig.get(
- * @param wrapper
+        '@sern/client',
- * @param payload
+        '@sern/errors',
- */
+        '@sern/emitter',
-export function processCommandPlugins<T extends DefinedCommandModule>(
+        '@sern/logger',
-    wrapper: Wrapper,
+    ) as [EventEmitter, ErrorHandling, SernEmitter, Logging?];
-    payload: { mod: T; absPath: string },
+    const lazy = (k: string) => containerConfig.get(k as keyof Dependencies)[0];
-) {
+    const eventStream$ = eventObservable$(events!, sernEmitter);
-    return payload.mod.plugins.map(plug => ({
-        ...plug,
-        name: plug?.name ?? 'Unnamed Plugin',
-        description: plug?.description ?? '...',
-        execute: plug.execute(wrapper, payload, controller),
-    }));
-}
 
-export function processEvents(wrapper: Wrapper, events: EventInput) {
+    const eventCreation$ = eventStream$.pipe(
-    const eventStream$ = eventObservable$(wrapper, events);
+        defineAllFields(),
-    const normalize$ = eventStream$.pipe(
+        scanModule({
-        map(({ mod, absPath }) => {
+            onFailure: module => sernEmitter.emit('module.register', SernEmitter.success(module)),
-            return <DefinedEventModule>{
+            onSuccess: ({ module }) => {
-                name: mod?.name ?? Files.fmtFileName(basename(absPath)),
+                sernEmitter.emit(
-                description: mod?.description ?? '...',
+                    'module.register',
-                ...mod,
+                    SernEmitter.failure(module, SernError.PluginFailure),
-            };
+                );
+                return module;
+            },
         }),
     );
-    normalize$.subscribe(e => {
+    const intoDispatcher = (e: Processed<EventModule | CommandModule>) =>
-        const emitter = isSernEvent(e)
+        match(e)
-            ? wrapper?.sernEmitter
+            .with({ type: EventType.Sern }, m => eventDispatcher(m, sernEmitter))
-            : isDiscordEvent(e)
+            .with({ type: EventType.Discord }, m => eventDispatcher(m, client))
-            ? wrapper.client
+            .with({ type: EventType.External }, m => eventDispatcher(m, lazy(m.emitter)))
-            : ExternalEventEmitters.get(e.emitter);
+            .otherwise(() => errorHandling.crash(Error(SernError.InvalidModuleType)));
-        if (emitter === undefined) {
+
-            throw new Error(`Cannot find event emitter as it is undefined`);
+    eventCreation$
-        }
+        .pipe(
-        //Would add sern event emitter for events loaded, attached onto sern emitter, but could lead to unwanted behavior!
+            map(intoDispatcher),
-        fromEvent(emitter, e.name, e.execute as SpreadParams<typeof e.execute>).subscribe();
+            /**
-    });
+             * Where all events are turned on
+             */
+            tap(dispatcher => dispatcher.subscribe()),
+            catchError(handleError(errorHandling, logger)),
+            finalize(() => {
+                logger?.info({ message: 'an event module reached end of lifetime' });
+                useContainerRaw()
+                    ?.disposeAll()
+                    .then(() => {
+                        logger?.info({ message: 'Cleaning container and crashing' });
+                    });
+            }),
+        )
+        .subscribe();
 }
 
-function eventObservable$({ sernEmitter }: Wrapper, events: EventInput) {
+function eventObservable$(events: string, emitter: SernEmitter) {
-    return match(events)
+    return buildData<EventModule>(events).pipe(
-        .when(Array.isArray, (arr: { mod: EventModule; absPath: string }[]) => {
+        errTap(reason => {
-            return from(arr);
+            emitter.emit('module.register', SernEmitter.failure(undefined, reason));
-        })
+        }),
-        .when(
+    );
-            e => typeof e === 'string',
-            (eventsDir: string) => {
-                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/args.ts

@@ -0,0 +1,117 @@
+import type { CommandType } from '../structures/enums';
+import type { PluginType } from '../structures/enums';
+import type { ClientEvents } from 'discord.js';
+import type {
+    BothCommand,
+    ButtonCommand,
+    ChannelSelectCommand,
+    ContextMenuUser,
+    DiscordEventCommand,
+    ExternalEventCommand,
+    MentionableSelectCommand,
+    ModalSubmitCommand,
+    RoleSelectCommand,
+    SernEventCommand,
+    SlashCommand,
+    StringSelectCommand,
+    TextCommand,
+    UserSelectCommand,
+    ContextMenuMsg,
+    Module,
+} from '../../types/module';
+import type { Args, Payload, Processed, SlashOptions } from '../../types/handler';
+import type Context from '../structures/context';
+import type { MessageContextMenuCommandInteraction } from 'discord.js';
+import type {
+    ButtonInteraction,
+    RoleSelectMenuInteraction,
+    StringSelectMenuInteraction,
+    UserContextMenuCommandInteraction,
+} from 'discord.js';
+import type {
+    ChannelSelectMenuInteraction,
+    MentionableSelectMenuInteraction,
+    ModalSubmitInteraction,
+    UserSelectMenuInteraction,
+} from 'discord.js';
+import { EventType } from '../structures/enums';
+
+type CommandArgsMatrix = {
+    [CommandType.Text]: {
+        [PluginType.Control]: [Context, ['text', string[]]];
+        [PluginType.Init]: [InitArgs<Processed<TextCommand>>];
+    };
+    [CommandType.Slash]: {
+        [PluginType.Control]: [Context, ['slash', /* library coupled */ SlashOptions]];
+        [PluginType.Init]: [InitArgs<Processed<SlashCommand>>];
+    };
+    [CommandType.Both]: {
+        [PluginType.Control]: [Context, Args];
+        [PluginType.Init]: [InitArgs<Processed<BothCommand>>];
+    };
+    [CommandType.CtxMsg]: {
+        [PluginType.Control]: [/* library coupled */ MessageContextMenuCommandInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ContextMenuMsg>>];
+    };
+    [CommandType.CtxUser]: {
+        [PluginType.Control]: [/* library coupled */ UserContextMenuCommandInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ContextMenuUser>>];
+    };
+    [CommandType.Button]: {
+        [PluginType.Control]: [/* library coupled */ ButtonInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ButtonCommand>>];
+    };
+    [CommandType.StringSelect]: {
+        [PluginType.Control]: [/* library coupled */ StringSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<StringSelectCommand>>];
+    };
+    [CommandType.RoleSelect]: {
+        [PluginType.Control]: [/* library coupled */ RoleSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<RoleSelectCommand>>];
+    };
+    [CommandType.ChannelSelect]: {
+        [PluginType.Control]: [/* library coupled */ ChannelSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ChannelSelectCommand>>];
+    };
+    [CommandType.MentionableSelect]: {
+        [PluginType.Control]: [/* library coupled */ MentionableSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<MentionableSelectCommand>>];
+    };
+    [CommandType.UserSelect]: {
+        [PluginType.Control]: [/* library coupled */ UserSelectMenuInteraction];
+        [PluginType.Init]: [InitArgs<Processed<UserSelectCommand>>];
+    };
+    [CommandType.Modal]: {
+        [PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
+        [PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
+    };
+};
+
+type EventArgsMatrix = {
+    [EventType.Discord]: {
+        [PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
+        [PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
+    };
+    [EventType.Sern]: {
+        [PluginType.Control]: [Payload];
+        [PluginType.Init]: [InitArgs<Processed<SernEventCommand>>];
+    };
+    [EventType.External]: {
+        [PluginType.Control]: unknown[];
+        [PluginType.Init]: [InitArgs<Processed<ExternalEventCommand>>];
+    };
+};
+
+export interface InitArgs<T extends Processed<Module>> {
+    module: T;
+    absPath: string;
+}
+
+export type CommandArgs<
+    I extends CommandType = CommandType,
+    J extends PluginType = PluginType,
+> = CommandArgsMatrix[I][J];
+export type EventArgs<
+    I extends EventType = EventType,
+    J extends PluginType = PluginType,
+> = EventArgsMatrix[I][J];

src/handler/plugins/createPlugin.ts

@@ -0,0 +1,51 @@
+import { CommandType, EventType, PluginType } from '../structures/enums';
+import type { Plugin, PluginResult } from '../../types/plugin';
+import type { CommandArgs, EventArgs } from './args';
+import type { ClientEvents } from 'discord.js';
+export const guayin = Symbol('twice<3');
+export function makePlugin<V extends unknown[]>(
+    type: PluginType,
+    execute: (...args: any[]) => any,
+): Plugin<V> {
+    return {
+        type,
+        execute,
+        [guayin]: undefined,
+    } as Plugin<V>;
+}
+
+export function EventInitPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+
+export function CommandInitPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+
+export function CommandControlPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+
+export function EventControlPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+
+/**
+ * @Experimental
+ * A specialized function for creating control plugins with discord.js ClientEvents.
+ * Will probably be moved one day!
+ */
+export function DiscordEventControlPlugin<T extends keyof ClientEvents>(
+    name: T,
+    execute: (...args: ClientEvents[T]) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}

src/handler/plugins/index.ts

@@ -0,0 +1,2 @@
+export { EventArgs, InitArgs, CommandArgs } from './args';
+export * from './createPlugin';

src/handler/plugins/plugin.ts

@@ -1,184 +0,0 @@
-/*
- * Plugins can be inserted on all commands and are emitted
- *
- * 1. On ready event, where all commands are loaded.
- * 2. On corresponding observable (when command triggers)
- *
- * The goal of plugins is to organize commands and
- * provide extensions to repetitive patterns
- * examples include refreshing modules,
- * categorizing commands, cool-downs, permissions, etc.
- * Plugins are reminiscent of middleware in express.
- */
-
-import type { AutocompleteInteraction, Awaitable, Client, ClientEvents } from 'discord.js';
-import type { Result, Ok, Err } from 'ts-results-es';
-import type { CommandType, DefinitelyDefined, Override, SernEventsMapping } from '../../index';
-import { EventType, PluginType } from '../../index';
-import type { BaseModule, CommandModuleDefs, EventModuleDefs } from '../structures/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>;
-}
-
-type BasePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType;
-    }
->;
-
-export type CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            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,
-            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<
-    BasePlugin,
-    {
-        type: PluginType.Command;
-        execute: (
-            wrapper: SernEmitter,
-            module: DefinitelyDefined<SernEventCommand, 'name' | 'description'>,
-            controller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type AutocompletePlugin = Override<
-    BaseModule,
-    {
-        type: PluginType.Event;
-        execute: (
-            autocmp: AutocompleteInteraction,
-            controlller: Controller,
-        ) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type EventPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
-    [K in T]: Override<
-        BasePlugin,
-        {
-            type: PluginType.Event;
-            execute: (
-                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<
-    BasePlugin,
-    {
-        type: PluginType.Event;
-        execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
-    }
->;
-
-export type DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BasePlugin,
-    {
-        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'>;
-};
-export type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
-};
-/**
- * Event Module Event Plugins
- */
-export type EventModuleEventPluginDefs = {
-    [EventType.Discord]: DiscordEventPlugin;
-    [EventType.Sern]: SernEventPlugin;
-    [EventType.External]: ExternalEventPlugin;
-};
-
-/**
- * Event Module Command Plugins
- */
-export type EventModuleCommandPluginDefs = {
-    [EventType.Discord]: DiscordEmitterPlugin;
-    [EventType.Sern]: SernEmitterPlugin;
-    [EventType.External]: ExternalEmitterPlugin;
-};
-
-export type EventModulePlugin<T extends EventType> =
-    | EventModuleEventPluginDefs[T]
-    | EventModuleCommandPluginDefs[T];
-
-export type CommandModulePlugin<T extends CommandType> = EventPlugin<T> | CommandPlugin<T>;
-
-/**
- * User inputs this type. Sern processes behind the scenes for better usage
- */
-export type InputCommandModule = {
-    [T in CommandType]: CommandModuleNoPlugins[T] & { plugins?: CommandModulePlugin<T>[] };
-}[CommandType];
-
-export type InputEventModule = {
-    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: EventModulePlugin<T>[] };
-}[EventType];

src/handler/sern.ts

@@ -1,22 +1,23 @@
 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, EventModule } from './structures/module';
+import { CommandType, EventType, PluginType } from './structures/enums';
-import { EventType, PluginType } from './structures/enums';
+import type { AnyEventPlugin, ControlPlugin, InitPlugin, Plugin } from '../types/plugin';
-import type {
-    CommandPlugin,
-    EventModuleCommandPluginDefs,
-    EventModuleEventPluginDefs,
-    EventPlugin,
-    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,
+    InputCommand,
+    InputEvent,
+} from '../types/module';
+import type { Dependencies, DependencyConfiguration } from '../types/handler';
+import { composeRoot, useContainer } from './dependencies/provider';
+import type { Logging } from './contracts';
+import { err, ok, partition } from './utilities/functions';
+import type { Awaitable, ClientEvents } from 'discord.js';
 
 /**
  *
@@ -25,75 +26,46 @@ 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` });
-/**
- *
- * @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,
 };
 
 /**
  * The wrapper function to define command modules for sern
  * @param mod
  */
-export function commandModule(mod: InputCommandModule): CommandModule {
+export function commandModule(mod: InputCommand): CommandModule {
-    const onEvent: EventPlugin[] = [];
+    const [onEvent, plugins] = partition(
-    const plugins: CommandPlugin[] = [];
+        mod.plugins ?? [],
-    for (const pl of mod.plugins ?? []) {
+        el => (el as Plugin).type === PluginType.Control,
-        if (pl.type === PluginType.Event) {
+    );
-            onEvent.push(pl);
-        } else {
-            plugins.push(pl as CommandPlugin);
-        }
-    }
-
     return {
         ...mod,
         onEvent,
@@ -104,18 +76,56 @@ export function commandModule(mod: InputCommandModule): CommandModule {
  * The wrapper function to define event modules for sern
  * @param mod
  */
-export function eventModule(mod: InputEventModule): EventModule {
+export function eventModule(mod: InputEvent): EventModule {
-    const onEvent: EventModuleEventPluginDefs[EventType][] = [];
+    const [onEvent, plugins] = partition(
-    const plugins: EventModuleCommandPluginDefs[EventType][] = [];
+        mod.plugins ?? [],
-    const hasPlugins = mod.plugins && mod.plugins.length > 0;
+        el => (el as Plugin).type === PluginType.Control,
-    if (hasPlugins) {
+    );
-        throw Error(
-            SernError.NotSupportedYet + `: Plugins on event listeners are not supported yet`,
-        );
-    }
     return {
         ...mod,
         onEvent,
         plugins,
     } as EventModule;
 }
+
+/**
+ * Create event modules from discord.js client events,
+ * This is an {@link eventModule} for discord events,
+ * where typings can be very bad.
+ * @param mod
+ */
+export function discordEvent<T extends keyof ClientEvents>(mod: {
+    name: T;
+    plugins?: AnyEventPlugin[];
+    execute: (...args: ClientEvents[T]) => Awaitable<unknown>;
+}) {
+    return eventModule({ type: EventType.Discord, ...mod });
+}
+/**
+ * @param conf a configuration for creating your project dependencies
+ */
+export function makeDependencies<T extends Dependencies>(conf: DependencyConfiguration<T>) {
+    //Until there are more optional dependencies, just check if the logger exists
+    composeRoot(conf);
+    return useContainer<T>();
+}
+
+/**
+ * @Experimental
+ * Will be refactored / changed in future
+ */
+export abstract class CommandExecutable<Type extends CommandType> {
+    abstract type: Type;
+    plugins: InitPlugin[] = [];
+    onEvent: ControlPlugin[] = [];
+    abstract execute: CommandModuleDefs[Type]['execute'];
+}
+/**@Experimental
+ * Will be refactored in future
+ */
+export abstract class EventExecutable<Type extends EventType> {
+    abstract type: Type;
+    plugins: InitPlugin[] = [];
+    onEvent: ControlPlugin[] = [];
+    abstract execute: EventModuleDefs[Type]['execute'];
+}

src/handler/sernEmitter.ts

@@ -1,5 +1,7 @@
 import { EventEmitter } from 'events';
-import type { SernEventsMapping } from '../types/handler';
+import type { Payload, SernEventsMapping } from '../types/handler';
+import { PayloadType } from './structures';
+import type { Module } from '../types/module';
 
 class SernEmitter extends EventEmitter {
     /**
@@ -27,7 +29,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,
@@ -35,6 +37,49 @@ class SernEmitter extends EventEmitter {
     ): boolean {
         return super.emit(eventName, ...args);
     }
+    private static payload<T extends Payload>(
+        type: PayloadType,
+        module?: Module,
+        reason?: unknown,
+    ) {
+        return { type, module, reason } as T;
+    }
+
+    /**
+     * Creates a compliant SernEmitter failure payload
+     * @param module
+     * @param reason
+     */
+    static failure(module?: Module, reason?: unknown) {
+        //The generic cast Payload & { type : PayloadType.* } coerces the type to be a failure payload
+        // same goes to the other methods below
+        return SernEmitter.payload<Payload & { type: PayloadType.Failure }>(
+            PayloadType.Failure,
+            module,
+            reason,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module success payload
+     * @param module
+     */
+    static success(module: Module) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Success }>(
+            PayloadType.Success,
+            module,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module warning payload
+     * @param reason
+     */
+    static warning(reason: unknown) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Warning }>(
+            PayloadType.Warning,
+            undefined,
+            reason,
+        );
+    }
 }
 
 export default SernEmitter;

src/handler/structures/context.ts

@@ -1,40 +1,25 @@
-import type { APIGuildMember } from 'discord-api-types/v10';
 import type {
     ChatInputCommandInteraction,
     Client,
-    Guild,
-    GuildMember,
     InteractionReplyOptions,
     Message,
-    ReplyMessageOptions,
     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 } from '../../types/handler';
+import type { ReplyOptions } from '../../types/handler';
 import { SernError } from './errors';
 
-function firstSome<T>(...args: Option<T>[]): Nullish<T> {
+function safeUnwrap<T>(res: Either<T, T>) {
-    for (const op of args) {
+    return res.val;
-        if (op.some) return op.val;
-    }
-    return null;
 }
-
-//Could I refactor with Either monad?
 /**
  * Provides values shared between
  * Message and ChatInputCommandInteraction
  */
 export default class Context {
-    private constructor(
+    private constructor(private ctx: Either<Message, ChatInputCommandInteraction>) {}
-        private oMsg: Option<Message> = None,
-        private oInterac: Option<ChatInputCommandInteraction> = None,
-    ) {
-        this.oMsg = oMsg;
-        this.oInterac = oInterac;
-    }
 
     /**
      * Getting the Message object. Crashes if module type is
@@ -42,7 +27,7 @@ export default class Context {
      * ChatInputCommandInteraction
      */
     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,98 +35,72 @@ 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 this.ctx.val.id;
-            this.oInterac.map(i => i.id),
-            this.oMsg.map(m => m.id),
-        )!;
     }
 
-    public get channel(): Nullish<TextBasedChannel> {
+    public get channel() {
-        return firstSome(
+        return this.ctx.val.channel;
-            this.oMsg.map(m => m.channel),
-            this.oInterac.map(i => i.channel),
-        );
     }
-
+    /**
+     * If context is holding a message, message.author
+     * else, interaction.user
+     */
     public get user(): User {
-        return firstSome(
+        return safeUnwrap(this.ctx.map(m => m.author).mapErr(i => i.user));
-            this.oMsg.map(m => m.author),
-            this.oInterac.map(i => i.user),
-        )!;
     }
 
     public get createdTimestamp(): number {
-        return firstSome(
+        return this.ctx.val.createdTimestamp;
-            this.oMsg.map(m => m.createdTimestamp),
-            this.oInterac.map(i => i.createdTimestamp),
-        )!;
     }
 
-    public get guild(): Guild {
+    public get guild() {
-        return firstSome(
+        return this.ctx.val.guild;
-            this.oMsg.map(m => m.guild),
-            this.oInterac.map(i => i.guild),
-        )!;
     }
 
-    public get guildId(): Snowflake {
+    public get guildId() {
-        return firstSome(
+        return this.ctx.val.guildId;
-            this.oMsg.map(m => m.guildId),
-            this.oInterac.map(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 this.ctx.val.member;
-            this.oMsg.map(m => m.member),
-            this.oInterac.map(i => i.member),
-        );
     }
 
     public get client(): Client {
-        return firstSome(
+        return this.ctx.val.client;
-            this.oMsg.map(m => m.client),
-            this.oInterac.map(i => i.client),
-        )!;
     }
 
     public get inGuild(): boolean {
-        return firstSome(
+        return this.ctx.val.inGuild();
-            this.oMsg.map(m => m.inGuild()),
+    }
-            this.oInterac.map(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() {
+    public reply(content: ReplyOptions) {
-        return this.oMsg.none && this.oInterac.none;
+        return safeUnwrap(
-    }
+            this.ctx
-    //Make queueable
+                .map(m => m.reply(content as string | MessageReplyOptions))
-    public reply(
+                .mapErr(i =>
-        content: string | Omit<InteractionReplyOptions, 'fetchReply'> | ReplyMessageOptions,
+                    i.reply(content as string | InteractionReplyOptions).then(() => i.fetchReply()),
-    ) {
+                ),
-        return firstSome(
+        );
-            this.oInterac.map(i => {
-                return i
-                    .reply(content as string | InteractionReplyOptions)
-                    .then(() => i.fetchReply());
-            }),
-            this.oMsg.map(m => {
-                return m.reply(content as string | ReplyMessageOptions);
-            }),
-        )!;
     }
 }

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
@@ -92,13 +102,23 @@ export enum EventType {
  */
 export enum PluginType {
     /**
-     * The PluginType for CommandPlugins
+     * The PluginType for InitPlugins
      */
-    Command = 0b01,
+    Init = 1,
+    /**
+     * @deprecated
+     * Use PluginType.Init instead
+     */
+    Command = 1,
+    /**
+     * @deprecated
+     * Use PluginType.Control instead
+     */
+    Event = 2,
     /**
      * The PluginType for EventPlugins
      */
-    Event = 0b10,
+    Control = 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,53 +0,0 @@
-import type { Override, SernEventsMapping } from '../../types/handler';
-import type { BaseModule } from './module';
-import type {
-    DiscordEmitterPlugin,
-    DiscordEventPlugin,
-    ExternalEmitterPlugin,
-    ExternalEventPlugin,
-    SernEmitterPlugin,
-    SernEventPlugin,
-} from '../plugins/plugin';
-import type { Awaitable, ClientEvents } from 'discord.js';
-import type { EventType } from './enums';
-
-/*
- * Mapped type to generate all sern event modules
- */
-export type SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> =
-    Override<
-        BaseModule,
-        {
-            name?: T;
-            type: EventType.Sern;
-            onEvent: SernEventPlugin[];
-            plugins: SernEmitterPlugin[];
-            execute(...args: SernEventsMapping[T]): Awaitable<void | unknown>;
-        }
-    >;
-/*
- * Mapped type to generate all discord event modules
- */
-export type DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> = Override<
-    BaseModule,
-    {
-        name?: T;
-        type: EventType.Discord;
-        onEvent: DiscordEventPlugin[];
-        plugins: DiscordEmitterPlugin[];
-        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/index.ts

@@ -0,0 +1,6 @@
+import Context from './context';
+import type Wrapper from './wrapper';
+import { ModuleStore } from './moduleStore';
+export * from './errors';
+export * from './enums';
+export { Context, Wrapper, ModuleStore };

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

src/handler/structures/structxports.ts

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

src/handler/structures/wrapper.ts

@@ -1,20 +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 {
-    readonly client: Client;
-    readonly sernEmitter?: SernEmitter;
     readonly defaultPrefix?: string;
     readonly commands: string;
-    readonly events?:
+    readonly events?: string;
-        | string
+    readonly containerConfig: {
-        | { mod: EventModule; absPath: string }[]
+        get: (...keys: (keyof Dependencies)[]) => unknown[];
-        | (() => { mod: EventModule; absPath: string }[]);
+    };
 }
-
 export default Wrapper;

src/handler/utilities/asyncResolveArray.ts

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

src/handler/utilities/functions.ts

@@ -0,0 +1,35 @@
+import * as Files from './readFile';
+import { basename } from 'path';
+import { Err, Ok } from 'ts-results-es';
+/**
+ * A function that returns whatever value is provided.
+ * Warning: this evaluates { @param value }. It does not defer a value.
+ * @param value
+ */
+// prettier-ignore
+export const _const = <T>(value: T) => () => value;
+/**
+ *
+ * @param modName
+ * @param absPath
+ */
+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];
+}

src/handler/utilities/predicates.ts

@@ -1,70 +0,0 @@
-import type { CommandModuleDefs, EventModule, Module } from '../structures/module';
-import {
-    AutocompleteInteraction,
-    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,
-    type: T,
-): plug is CommandModuleDefs[T] {
-    // Another way to check if type is equivalent,
-    // It will check based on flag system instead
-    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 {
-    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 {
-    return el.type === EventType.Sern;
-}
-
-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,8 @@
-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[] {
@@ -48,7 +22,8 @@ function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
 export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
 
 /**
- *
+ *  a directory string is converted into a stream of modules.
+ *  starts the stream of modules that sern needs to process on init
  * @returns {Observable<{ mod: Module; absPath: string; }[]>} data from command files
  * @param commandDir
  */
@@ -56,7 +31,7 @@ export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
 export function buildData<T>(commandDir: string): Observable<
     Result<
         {
-            mod: T;
+            module: T;
             absPath: string;
         },
         SernError
@@ -66,16 +41,20 @@ export function buildData<T>(commandDir: string): Observable<
     return from(
         Promise.all(
             commands.map(async absPath => {
-                let mod: T | undefined;
+                let module: T | undefined;
                 try {
                     // eslint-disable-next-line @typescript-eslint/no-var-requires
-                    mod = require(absPath).default;
+                    module = require(absPath).default;
                 } catch {
-                    mod = (await import(`file:///` + absPath)).default;
+                    module = (await import(`file:///` + absPath)).default;
                 }
-                if (mod !== undefined) {
+                if (module === undefined) {
-                    return Ok({ mod, absPath });
+                    return Err(SernError.UndefinedModule);
-                } else return Err(SernError.UndefinedModule);
+                }
+                try {
+                    module = new (module as unknown as new () => T)();
+                } catch {}
+                return Ok({ module, absPath });
             }),
         ),
     ).pipe(concatAll());

src/handler/utilities/treeSearch.ts

@@ -1,12 +1,19 @@
-import type { SernOptionsData } from '../structures/module';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
 
+/**
+ * Uses an iterative DFS to check if an autocomplete node exists
+ * @param iAutocomplete
+ * @param options
+ */
 export default function treeSearch(
     iAutocomplete: AutocompleteInteraction,
     options: SernOptionsData[] | undefined,
-) {
+): SernAutocompleteData | undefined {
     if (options === undefined) return undefined;
     const _options = options.slice(); // required to prevent direct mutation of options
+    let autocompleteData: SernAutocompleteData | undefined;
+
     while (_options.length > 0) {
         const cur = _options.pop()!;
         switch (cur.type) {
@@ -29,12 +36,12 @@ export default function treeSearch(
                     if (cur.autocomplete) {
                         const choice = iAutocomplete.options.getFocused(true);
                         if (cur.name === choice.name && cur.autocomplete) {
-                            return cur;
+                            autocompleteData = cur;
                         }
-                        return undefined;
                     }
                 }
                 break;
         }
     }
+    return autocompleteData;
 }

src/index.ts

@@ -1,7 +1,18 @@
 import SernEmitter from './handler/sernEmitter';
-export { eventModule, commandModule } from './handler/sern';
+export {
+    eventModule,
+    commandModule,
+    EventExecutable,
+    CommandExecutable,
+    controller,
+    discordEvent,
+} from './handler/sern';
 export * as Sern from './handler/sern';
 export * from './types/handler';
-export * from './handler/structures/structxports';
+export * from './types/module';
-export * from './handler/plugins/plugin';
+export * from './types/plugin';
+export * from './handler/structures';
+export * from './handler/plugins';
+export * from './handler/contracts';
 export { SernEmitter };
+export * from './handler/dependencies';

src/types/handler.ts

@@ -1,8 +1,13 @@
 import type { CommandInteractionOptionResolver } from 'discord.js';
-import type { CommandModule, EventModule, Module } from '../handler/structures/module';
 import type { PayloadType } from '../handler/structures/enums';
-export type Nullish<T> = T | undefined | null;
+import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-
+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';
+import type { Container } from 'iti';
 // Thanks to @kelsny
 export type ParseType<T> = {
     [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
@@ -12,47 +17,53 @@ 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 }[]);
-
-export type Reconstruct<T> = T extends Omit<infer O, never> ? O & Reconstruct<O> : T;
-
-export type IsOptional<T> = {
-    [K in keyof T]-?: T[K] extends Required<T>[K] ? false : true;
-};
-
-/**
- * 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 AnyDefinedModule = Processed<CommandModule | EventModule>;
-export type DefinedCommandModule = DefinitelyDefined<CommandModule, 'name' | 'description'>;
-export type DefinedEventModule = DefinitelyDefined<EventModule, 'name' | 'description'>;
 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 interface Dependencies {
+    '@sern/client': Singleton<EventEmitter>;
+    '@sern/logger'?: Singleton<Logging>;
+    '@sern/emitter': Singleton<SernEmitter>;
+    '@sern/store': Singleton<ModuleStore>;
+    '@sern/modules': Singleton<ModuleManager>;
+    '@sern/errors': Singleton<ErrorHandling>;
+}
+
+export type ReplyOptions =
+    | string
+    | Omit<InteractionReplyOptions, 'fetchReply'>
+    | MessageReplyOptions;
+//prettier-ignore
+export type MapDeps<Deps extends Dependencies, T extends readonly unknown[]> = T extends [
+    infer First extends keyof Deps,
+    ...infer Rest extends readonly unknown[],
+]
+    ? [
+          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';
+export type Processed<T> = T & { name: string; description: string };
+export type Deprecated<Message extends string> = [never, Message];
+export interface DependencyConfiguration<T extends Dependencies> {
+    exclude?: Set<OptionalDependencies>;
+    build: (root: Container<Omit<Dependencies, '@sern/client'>, {}>) => Container<T, {}>;
+}

src/types/module.ts

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

src/types/plugin.ts

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

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,39 @@
 import { defineConfig } from 'tsup';
-
+const shared = {
+    entry: ['src/index.ts'],
+    external: ['discord.js'],
+    platform: 'node',
+    clean: true,
+    sourcemap: false,
+    minify: true
+};
 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,
     },
 ]);