3.0.0-rc1

.eslintrc

@@ -1,13 +0,0 @@
-{
-    "parser": "@typescript-eslint/parser",
-    "extends": ["plugin:@typescript-eslint/recommended"],
-    "parserOptions": { "ecmaVersion": "latest", "sourceType": "script" },
-    "rules": {
-        "@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/ban-types": 0,
-        "@typescript-eslint/no-explicit-any": "off"
-    }
-}

.prettierrc

@@ -1,8 +0,0 @@
-{
-    "semi": true,
-    "trailingComma": "all",
-    "singleQuote": true,
-    "printWidth": 100,
-    "tabWidth": 4,
-    "arrowParens": "avoid"
-}

LICENSE.md

@@ -1,23 +0,0 @@
-MIT License
-
-**Copyright (c) 2022 Sern**
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-End license text.

package.json

@@ -1,15 +1,16 @@
 {
     "name": "@sern/handler",
     "packageManager": "yarn@3.5.0",
-    "version": "2.6.1",
+    "version": "3.0.0-rc1",
     "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
-    "main": "dist/cjs/index.cjs",
-    "module": "dist/esm/index.mjs",
+    "main": "./dist/esm/index.mjs",
+    "module": "./dist/cjs/index.cjs",
     "types": "dist/index.d.ts",
     "exports": {
         ".": {
             "import": "./dist/esm/index.mjs",
-            "require": "./dist/cjs/index.cjs"
+            "require": "./dist/cjs/index.cjs",
+            "types": "./dist/index.d.ts"
         }
     },
     "scripts": {
@@ -17,10 +18,12 @@
         "clean-modules": "rimraf node_modules/ && npm install",
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
-        "build:dev": "tsup && tsup --dts-only --outDir dist",
-        "build:prod": "tsup --minify && tsup --dts-only --outDir dist",
+        "build:dev": "tsup --metafile",
+        "build:prod": "tsup --minify",
         "publish": "npm run build:prod",
-        "pretty": "prettier --write ."
+        "pretty": "prettier --write .",
+        "tdd": "vitest",
+        "test": "vitest --run"
     },
     "keywords": [
         "sern-handler",
@@ -39,16 +42,53 @@
         "ts-results-es": "^3.6.0"
     },
     "devDependencies": {
+        "@faker-js/faker": "^8.0.1",
         "@types/node": "^18.15.11",
         "@typescript-eslint/eslint-plugin": "5.58.0",
         "@typescript-eslint/parser": "5.58.0",
-        "discord.js": "^14.9.0",
-        "esbuild": "^0.15.2",
+        "discord.js": "14.11.0",
         "esbuild-ifdef": "^0.2.0",
         "eslint": "8.38.0",
         "prettier": "2.8.7",
         "tsup": "^6.7.0",
-        "typescript": "5.0.2"
+        "typescript": "5.0.2",
+        "vitest": "latest"
+    },
+    "prettier": {
+        "semi": true,
+        "trailingComma": "all",
+        "singleQuote": true,
+        "printWidth": 100,
+        "tabWidth": 4,
+        "arrowParens": "avoid"
+    },
+    "eslintConfig": {
+        "parser": "@typescript-eslint/parser",
+        "extends": [
+            "plugin:@typescript-eslint/recommended"
+        ],
+        "parserOptions": {
+            "ecmaVersion": "latest",
+            "sourceType": "script"
+        },
+        "rules": {
+            "@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/ban-types": 0,
+            "@typescript-eslint/no-explicit-any": "off"
+        }
     },
     "repository": {
         "type": "git",

src/core/contracts/error-handling.ts

@@ -0,0 +1,21 @@
+/**
+ * @since 2.0.0
+ */
+export interface ErrorHandling {
+    /**
+     * Number of times the process should throw an error until crashing and exiting
+     */
+    keepAlive: number;
+
+    /**
+     * @deprecated 
+     * Version 4 will remove this method
+     */
+    crash(err :Error) : never
+    /**
+     * A function that is called on every crash. Updates keepAlive.
+     * If keepAlive is 0, the process crashes.
+     * @param error
+     */
+    updateAlive(error: Error): void;
+}

src/core/contracts/index.ts

@@ -0,0 +1,5 @@
+export * from './error-handling';
+export * from './logging';
+export * from './module-manager';
+export * from './module-store';
+export * from './init';

src/core/contracts/init.ts

@@ -0,0 +1,9 @@
+import { Awaitable } from '../../shared';
+
+/**
+ * Represents an initialization contract.
+ * Let dependencies implement this to initiate some logic.
+ */
+export interface Init {
+    init(): Awaitable<unknown>;
+}

src/core/contracts/logging.ts

@@ -0,0 +1,11 @@
+/**
+ * @since 2.0.0
+ */
+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 type LogPayload<T = unknown> = { message: T };

src/core/contracts/module-manager.ts

@@ -0,0 +1,14 @@
+import { CommandType } from '../structures';
+import { CommandMeta, CommandModule, CommandModuleDefs, Module } from '../types/modules';
+
+/**
+ * @since 2.0.0
+ */
+export interface ModuleManager {
+    get(id: string): string | undefined;
+    getMetadata(m: Module): CommandMeta|undefined;
+    setMetadata(m: Module, c: CommandMeta): void;
+    set(id: string, path: string): void;
+    getPublishableCommands(): Promise<CommandModule[]>;
+    getByNameCommandType<T extends CommandType>(name: string, commandType: T): Promise<CommandModuleDefs[T]>|undefined;
+}

src/core/contracts/module-store.ts

@@ -0,0 +1,9 @@
+import { CommandMeta, Module } from '../types/modules';
+
+/**
+ * Represents a core module store that stores IDs mapped to file paths.
+ */
+export interface CoreModuleStore {
+    commands: Map<string, string>;
+    metadata: WeakMap<Module, CommandMeta>;
+}

src/core/create-plugins.ts

@@ -1,8 +1,7 @@
-import { CommandType, EventType, PluginType } from '../structures';
-import type { Plugin, PluginResult } from '../../types/plugin';
-import type { CommandArgs, EventArgs } from './args';
+import { CommandType, EventType, PluginType } from './structures';
+import type { Plugin, PluginResult, EventArgs, CommandArgs } from './types/plugins';
 import type { ClientEvents } from 'discord.js';
-export const guayin = Symbol('twice<3');
+
 export function makePlugin<V extends unknown[]>(
     type: PluginType,
     execute: (...args: any[]) => any,
@@ -10,12 +9,11 @@ export function makePlugin<V extends unknown[]>(
     return {
         type,
         execute,
-        [guayin]: undefined,
     } as Plugin<V>;
 }
 /**
  * @since 2.5.0
- *
+ * @__PURE__
  */
 export function EventInitPlugin<I extends EventType>(
     execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
@@ -24,7 +22,7 @@ export function EventInitPlugin<I extends EventType>(
 }
 /**
  * @since 2.5.0
- *
+ * @__PURE__
  */
 export function CommandInitPlugin<I extends CommandType>(
     execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
@@ -33,7 +31,7 @@ export function CommandInitPlugin<I extends CommandType>(
 }
 /**
  * @since 2.5.0
- *
+ * @__PURE__
  */
 export function CommandControlPlugin<I extends CommandType>(
     execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
@@ -42,7 +40,7 @@ export function CommandControlPlugin<I extends CommandType>(
 }
 /**
  * @since 2.5.0
- *
+ * @__PURE__
  */
 export function EventControlPlugin<I extends EventType>(
     execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,

src/core/functions.ts

@@ -1,12 +1,37 @@
+import { Err, Ok } from 'ts-results-es';
 import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
-import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
+import type { SernAutocompleteData, SernOptionsData } from './types/modules';
+import { AnyCommandPlugin, AnyEventPlugin, Plugin } from './types/plugins';
+import { PluginType } from './structures';
+
+//function wrappers for empty ok / err
+export const ok = /* @__PURE__*/ () => Ok.EMPTY;
+export const err = /* @__PURE__*/ () => Err.EMPTY;
+
+export function partitionPlugins(
+    arr: (AnyEventPlugin | AnyCommandPlugin)[] = [],
+): [Plugin[], Plugin[]] {
+    const controlPlugins = [];
+    const initPlugins = [];
+    for (const el of arr) {
+        switch (el.type) {
+            case PluginType.Control:
+                controlPlugins.push(el);
+                break;
+            case PluginType.Init:
+                initPlugins.push(el);
+                break;
+        }
+    }
+    return [controlPlugins, initPlugins];
+}
 
 /**
- * Uses an iterative DFS to check if an autocomplete node exists
+ * Uses an iterative DFS to check if an autocomplete node exists on the option tree
  * @param iAutocomplete
  * @param options
  */
-export default function treeSearch(
+export function treeSearch(
     iAutocomplete: AutocompleteInteraction,
     options: SernOptionsData[] | undefined,
 ): SernAutocompleteData | undefined {
@@ -18,19 +43,13 @@ export default function treeSearch(
         const cur = _options.pop()!;
         switch (cur.type) {
             case ApplicationCommandOptionType.Subcommand:
+            case ApplicationCommandOptionType.SubcommandGroup:
                 {
                     for (const option of cur.options ?? []) {
                         _options.push(option);
                     }
                 }
                 break;
-            case ApplicationCommandOptionType.SubcommandGroup:
-                {
-                    for (const command of cur.options ?? []) {
-                        _options.push(command);
-                    }
-                }
-                break;
             default:
                 {
                     if (cur.autocomplete) {

src/core/index.ts

@@ -0,0 +1,28 @@
+export * from './contracts';
+export * from './create-plugins';
+export * from './structures';
+export * from './ioc';
+export type {
+    CommandModule,
+    EventModule,
+    BothCommand,
+    ContextMenuMsg,
+    ContextMenuUser,
+    SlashCommand,
+    TextCommand,
+    ButtonCommand,
+    StringSelectCommand,
+    MentionableSelectCommand,
+    UserSelectCommand,
+    ChannelSelectCommand,
+    RoleSelectCommand,
+    ModalSubmitCommand,
+    DiscordEventCommand,
+    SernEventCommand,
+    ExternalEventCommand,
+    CommandModuleDefs,
+    EventModuleDefs,
+    SernAutocompleteData,
+    SernOptionsData,
+} from './types/modules';
+export type { Controller, PluginResult, InitPlugin, ControlPlugin, Plugin } from './types/plugins';

src/core/ioc/base.ts

@@ -0,0 +1,34 @@
+import * as assert from 'assert';
+import { composeRoot, useContainer } from './dependency-injection';
+import { DependencyConfiguration } from './types';
+import { CoreContainer } from '../structures/container';
+
+//SIDE EFFECT: GLOBAL DI
+let containerSubject: CoreContainer<Partial<Dependencies>>;
+
+/**
+ * Returns the underlying data structure holding all dependencies.
+ * Exposes methods from iti
+ */
+export function useContainerRaw() {
+    assert.ok(
+        containerSubject && containerSubject.isReady(),
+        "Could not find container or container wasn't ready. Did you call makeDependencies?",
+    );
+    return containerSubject;
+}
+
+/**
+ * @since 2.0.0
+ * @param conf a configuration for creating your project dependencies
+ */
+export async function makeDependencies<const T extends Dependencies>(
+    conf: DependencyConfiguration,
+) {
+    //Until there are more optional dependencies, just check if the logger exists
+    //SIDE EFFECT
+    containerSubject = new CoreContainer();
+    await composeRoot(containerSubject, conf);
+
+    return useContainer<T>();
+}

src/core/ioc/dependencies.d.ts

@@ -0,0 +1,16 @@
+// This file serves an the interface for developers to augment the Dependencies interface
+// Developers will have to create a new file dependencies.d.ts in the root directory, augmenting 
+// this type
+
+/* eslint-disable @typescript-eslint/consistent-type-imports */
+
+import { CoreDependencies } from './types'
+
+declare global {
+
+    interface Dependencies extends CoreDependencies {}
+}
+
+    
+
+

src/core/ioc/dependency-injection.ts

@@ -0,0 +1,80 @@
+import type {
+    CoreDependencies,
+    DependencyConfiguration,
+    IntoDependencies,
+} from './types';
+import { DefaultLogging } from '../structures';
+import { SernError } from '../structures/errors';
+import { useContainerRaw } from './base';
+import { CoreContainer } from '../structures/container';
+
+/**
+ * @__PURE__
+ * @since 2.0.0.
+ * Creates a singleton object.
+ * @param cb
+ */
+export function single<T>(cb: () => T) {
+    return cb;
+}
+
+/**
+ * @__PURE__
+ * @since 2.0.0
+ * Creates a transient object
+ * @param cb
+ */
+export function transient<T>(cb: () => () => T) {
+    return cb;
+}
+
+export function Service<const T extends keyof Dependencies>(key: T) {
+    return useContainerRaw().get(key)!;
+}
+
+export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]) {
+    const container = useContainerRaw();
+    return keys.map(k => container.get(k)!) as IntoDependencies<T>;
+}
+
+/**
+ * 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 async function composeRoot(
+    container: CoreContainer<Partial<Dependencies>>,
+    conf: DependencyConfiguration,
+) {
+    //container should have no client or logger yet.
+    const hasLogger = conf.exclude?.has('@sern/logger');
+    if (!hasLogger) {
+        container.upsert({
+            '@sern/logger': () => new DefaultLogging(),
+        });
+    }
+    //Build the container based on the callback provided by the user
+    conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
+    try {
+        container.get('@sern/client');
+    } catch {
+        throw new Error(SernError.MissingRequired + ' No client was provided');
+    }
+
+    if (!hasLogger) {
+        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
+    }
+
+    container.ready();
+}
+
+export function useContainer<const T extends Dependencies>() {
+    console.warn(`
+        Warning: using a container hook (useContainer) is not recommended.
+        Could lead to many unwanted side effects.
+        Use the new Service(s) api function instead.
+        `);
+    return <V extends (keyof T)[]>(...keys: [...V]) =>
+        keys.map(key => useContainerRaw().get(key as keyof Dependencies)) as IntoDependencies<V>;
+}

src/core/ioc/index.ts

@@ -0,0 +1,3 @@
+export { useContainerRaw, makeDependencies } from './base';
+export { Service, Services, single, transient } from './dependency-injection';
+export type { Singleton, Transient, CoreDependencies } from './types';

src/core/ioc/types.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from 'node:events';
+import { Container, UnpackFunction } from 'iti';
+export type Singleton<T> = () => T;
+export type Transient<T> = () => () => T;
+
+export interface CoreDependencies {
+    '@sern/client': () => EventEmitter
+    '@sern/logger'?: () => import('../contracts').Logging;
+    '@sern/emitter': () => import('../structures/sern-emitter').SernEmitter;
+    '@sern/store': () => import('../contracts').CoreModuleStore;
+    '@sern/modules': () => import('../contracts').ModuleManager;
+    '@sern/errors': () => import('../contracts').ErrorHandling;
+}
+
+export type DependencyFromKey<T extends keyof Dependencies> = Dependencies[T];
+
+export type IntoDependencies<Tuple extends [...any[]]> = {
+    [Index in keyof Tuple]: UnpackFunction<DependencyFromKey<Tuple[Index]> & {}>; //Unpack and make NonNullable
+} & { length: Tuple['length'] };
+
+export interface DependencyConfiguration {
+    //@deprecated. Loggers will always be included in the future
+    exclude?: Set<'@sern/logger'>;
+    build: (root: Container<Omit<CoreDependencies, '@sern/client'>, {}>) => Container<Dependencies, {}>;
+}
+

src/core/module-loading.ts

@@ -0,0 +1,103 @@
+import { SernError } from './structures/errors';
+import { Result, Err, Ok } from 'ts-results-es';
+import { Module } from './types/modules';
+import { type Observable, from, mergeMap, ObservableInput } from 'rxjs';
+import { readdir, stat } from 'fs/promises';
+import { basename, extname, join, resolve } from 'path';
+import { ImportPayload } from '../handler/types';
+
+export type ModuleResult<T> = Promise<Result<ImportPayload<T>, SernError>>;
+
+
+export async function importModule<T>(absPath: string) {
+    // prettier-ignore
+    let module =
+    /// #if MODE === 'esm'
+    import(absPath).then(i => i.default); // eslint-disable-line
+    /// #elif MODE === 'cjs'
+    require(absPath).default; // eslint-disable-line
+    /// #endif
+    return module.then(m => 
+       Result
+       .wrap(() => m.getInstance())
+       .unwrapOr(m)
+    ) as T;
+}
+export async function defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
+    let module = await importModule<T>(absPath);
+    if (module === undefined) {
+        return Err(SernError.UndefinedModule);
+    }
+    //todo readd class modules
+    return Ok({ module, absPath });
+}
+
+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
+ */
+export function buildModuleStream<T extends Module>(
+    input: ObservableInput<string>,
+): Observable<Result<ImportPayload<T>, SernError>> {
+    return from(input).pipe(mergeMap(defaultModuleLoader<T>));
+}
+
+export function getFullPathTree(dir: string, mode: boolean) {
+    return readPaths(resolve(dir), mode);
+}
+
+export function filename(path: string) {
+    return fmtFileName(basename(path));
+}
+
+function createSkipCondition(base: string) {
+    const validExtensions = ['.js', '.cjs', '.mts', '.mjs', 'cts'];
+    return ( type: 'file' | 'directory') => {
+        if(type === 'file') {
+           return fmtFileName(base)[0] === '!'
+            || !validExtensions.includes(extname(base));
+        }
+        return base[0] === '!';
+    }
+}
+async function deriveFileInfo(dir: string, file: string) {
+     const fullPath = join(dir, file);
+     return {
+       fullPath,
+       fileStats: await stat(fullPath),
+       base: basename(file)
+     }
+}
+async function* readPaths(dir: string, shouldDebug: boolean): AsyncGenerator<string> {
+    try {
+        const files = await readdir(dir);
+        for (const file of files) {
+            const { fullPath, fileStats, base } = await deriveFileInfo(dir, file);
+            const isSkippable = createSkipCondition(base);
+            if (fileStats.isDirectory()) {
+                //Todo: refactor so that i dont repeat myself for files (line 71)
+                if (isSkippable('directory')) {
+                    if (shouldDebug) console.info(`ignored directory: ${fullPath}`);
+                } else {
+                    yield* readPaths(fullPath, shouldDebug);
+                }
+            } else {
+                if (isSkippable('file')) {
+                    if (shouldDebug) console.info(`ignored: ${fullPath}`);
+                } else {
+                    /// #if MODE === 'esm'
+                    yield 'file:///' + fullPath;
+                    /// #elif MODE === 'cjs'
+                    yield fullPath;
+                    /// #endif
+                }
+            }
+        }
+    } catch (err) {
+        throw err;
+    }
+}

src/core/operators.ts

@@ -1,17 +1,28 @@
 /**
  * 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
+ * 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';
+import {
+    concatMap,
+    defaultIfEmpty,
+    EMPTY,
+    every,
+    fromEvent,
+    map,
+    Observable,
+    of,
+    OperatorFunction,
+    pipe,
+    share,
+    switchMap,
+} from 'rxjs';
 import { Result } from 'ts-results-es';
-import { ImportPayload, Processed } from '../../../types/handler';
+import { EventEmitter } from 'node:events';
+import { ErrorHandling, Logging } from './contracts';
+import util from 'node:util';
+import { Awaitable } from '../shared';
+import { PluginResult, VoidResult } from './types/plugins';
 /**
  * if {src} is true, mapTo V, else ignore
  * @param item
@@ -20,6 +31,20 @@ export function filterMapTo<V>(item: () => V): OperatorFunction<boolean, V> {
     return concatMap(shouldKeep => (shouldKeep ? of(item()) : EMPTY));
 }
 
+export function filterMap<In, Out>(
+    cb: (i: In) => Awaitable<Result<Out, unknown>>,
+): OperatorFunction<In, Out> {
+    return pipe(
+        switchMap(async input => cb(input)),
+        concatMap(s => {
+            if (s.ok) {
+                return of(s.val);
+            }
+            return EMPTY;
+        }),
+    );
+}
+
 /**
  * Calls any plugin with {args}.
  * @param args if an array, its spread and plugin called.
@@ -31,31 +56,15 @@ export function callPlugin(args: unknown): OperatorFunction<
     VoidResult
 > {
     return 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);
-        }
     });
 }
 
 export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]) : [src]));
 
-export const fillDefaults = <T extends AnyModule>({ module, absPath }: ImportPayload<T>) => {
-    return {
-        absPath,
-        module: {
-            name: nameOrFilename(module?.name, absPath),
-            description: module?.description ?? '...',
-            ...module,
-        },
-    };
-};
-
 /**
  * If the current value in Result stream is an error, calls callback.
  * This also extracts the Ok value from Result
@@ -80,3 +89,18 @@ export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
     every(result => result.ok),
     defaultIfEmpty(true),
 );
+
+export const sharedObservable = <T>(e: EventEmitter, eventName: string) => {
+    return (fromEvent(e, eventName) as Observable<T>).pipe(share());
+};
+
+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.inspect(pload, { colors: true }));
+        //formatted payload
+        logging?.error({ message: util.inspect(pload) });
+        crashHandler.updateAlive(err);
+        return caught;
+    };
+}

src/core/predicates.ts

@@ -0,0 +1,34 @@
+import {
+    AnySelectMenuInteraction,
+    AutocompleteInteraction,
+    ButtonInteraction,
+    ChatInputCommandInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+} from 'discord.js';
+import { InteractionType } from 'discord.js';
+
+interface InteractionTypable {
+    type: InteractionType;
+}
+//discord.js pls fix ur typings or i will >:(
+type AnyMessageComponentInteraction = AnySelectMenuInteraction | ButtonInteraction;
+type AnyCommandInteraction =
+    | ChatInputCommandInteraction
+    | MessageContextMenuCommandInteraction
+    | UserContextMenuCommandInteraction;
+
+export function isMessageComponent(i: InteractionTypable): i is AnyMessageComponentInteraction {
+    return i.type === InteractionType.MessageComponent;
+}
+export function isCommand(i: InteractionTypable): i is AnyCommandInteraction {
+    return i.type === InteractionType.ApplicationCommand;
+}
+export function isAutocomplete(i: InteractionTypable): i is AutocompleteInteraction {
+    return i.type === InteractionType.ApplicationCommandAutocomplete;
+}
+
+export function isModal(i: InteractionTypable): i is ModalSubmitInteraction {
+    return i.type === InteractionType.ModalSubmit;
+}

src/core/structures/container.ts

@@ -0,0 +1,62 @@
+import { Container } from 'iti';
+import { DefaultErrorHandling, DefaultModuleManager, SernEmitter } from '../';
+import { isAsyncFunction } from 'node:util/types';
+import * as assert from 'node:assert';
+import { Subject } from 'rxjs';
+import { ModuleStore } from './module-store';
+
+/**
+ * Provides all the defaults for sern to function properly.
+ * The only user provided dependency needs to be @sern/client
+ */
+export class CoreContainer<T extends Partial<Dependencies>> extends Container<T, {}> {
+    private ready$ = new Subject<never>();
+    constructor() {
+        super();
+
+        this.listenForInsertions();
+
+        (this as Container<{}, {}>)
+            .add({
+                '@sern/errors': () => new DefaultErrorHandling(),
+                '@sern/emitter': () => new SernEmitter(),
+                '@sern/store': () => new ModuleStore(),
+            })
+            .add(ctx => {
+                return { '@sern/modules': () => new DefaultModuleManager(ctx['@sern/store']) };
+            });
+    }
+
+    private listenForInsertions() {
+        assert.ok(
+            !this.isReady(),
+            'listening for init functions should only occur prior to sern being ready.',
+        );
+        const unsubscriber = this.on('containerUpserted', this.callInitHooks);
+
+        this.ready$.subscribe({
+            complete: unsubscriber,
+        });
+    }
+
+    private async callInitHooks(e: { key: keyof T; newContainer: T[keyof T] | null }) {
+        const dep = e.newContainer;
+   
+        assert.ok(dep);
+        //Ignore any dependencies that are not objects or array
+        if (typeof dep !== 'object' || Array.isArray(dep)) {
+            return;
+        }
+
+        if ('init' in dep && typeof dep.init === 'function') {
+            isAsyncFunction(dep.init) ? await dep.init() : dep.init();
+        }
+    }
+
+    isReady() {
+        return this.ready$.closed;
+    }
+    ready() {
+        this.ready$.unsubscribe();
+    }
+}

src/core/structures/context.ts

@@ -1,42 +1,32 @@
-import type {
+import {
+    BaseInteraction,
     ChatInputCommandInteraction,
     Client,
     InteractionReplyOptions,
     Message,
-    Snowflake,
     MessageReplyOptions,
+    Snowflake,
     User,
 } from 'discord.js';
-import { Result as Either, Ok as Left, Err as Right } from 'ts-results-es';
-import type { ReplyOptions } from '../../types/handler';
-import { SernError } from './errors';
+import { CoreContext } from './core-context';
+import { Result, Ok, Err } from 'ts-results-es';
+import * as assert from 'assert';
+import { ReplyOptions } from '../../shared';
 
-function safeUnwrap<T>(res: Either<T, T>) {
-    return res.val;
-}
 /**
  * @since 1.0.0
  * Provides values shared between
  * Message and ChatInputCommandInteraction
  */
-export default class Context {
-    private constructor(private ctx: Either<Message, ChatInputCommandInteraction>) {}
-
-    /**
-     * Getting the Message object. Crashes if module type is
-     * CommandType.Slash or the event fired in a Both command was
-     * ChatInputCommandInteraction
+export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
+    /*
+     * @Experimental
      */
-    public get message() {
-        return this.ctx.expect(SernError.MismatchEvent);
+    get options() {
+        return this.interaction.options;
     }
-    /**
-     * Getting the ChatInputCommandInteraction object. Crashes if module type is
-     * CommandType.Text or the event fired in a Both command was
-     * Message
-     */
-    public get interaction() {
-        return this.ctx.expectErr(SernError.MismatchEvent);
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
+        super(ctx);
     }
 
     public get id(): Snowflake {
@@ -65,7 +55,6 @@ export default class Context {
     public get guildId() {
         return this.ctx.val.guildId;
     }
-
     /*
      * interactions can return APIGuildMember if the guild it is emitted from is not cached
      */
@@ -80,22 +69,8 @@ export default class Context {
     public get inGuild(): boolean {
         return this.ctx.val.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(Right(wrappable));
-        }
-        return new Context(Left(wrappable));
-    }
-
-    public reply(content: ReplyOptions) {
+    public async reply(content: ReplyOptions) {
         return safeUnwrap(
             this.ctx
                 .map(m => m.reply(content as string | MessageReplyOptions))
@@ -104,4 +79,16 @@ export default class Context {
                 ),
         );
     }
+
+    static override wrap(wrappable: BaseInteraction | Message): Context {
+        if ('interaction' in wrappable) {
+            return new Context(Ok(wrappable));
+        }
+        assert.ok(wrappable.isChatInputCommand());
+        return new Context(Err(wrappable));
+    }
+}
+
+function safeUnwrap<T>(res: Result<T, T>) {
+    return res.val;
 }

src/core/structures/core-context.ts

@@ -0,0 +1,34 @@
+import { Result as Either } from 'ts-results-es';
+import { SernError } from './errors';
+import * as assert from 'node:assert';
+
+/**
+ * @since 3.0.0
+ */
+export abstract class CoreContext<M, I> {
+    protected constructor(protected ctx: Either<M, I>) {
+        assert.ok(typeof ctx.val === 'object' && ctx.val != null);
+    }
+    get message(): M {
+        return this.ctx.expect(SernError.MismatchEvent);
+    }
+    get interaction(): I {
+        return this.ctx.expectErr(SernError.MismatchEvent);
+    }
+
+    public isMessage(): this is CoreContext<M, never> {
+        return this.ctx.ok;
+    }
+
+    public isSlash(): this is CoreContext<never, I> {
+        return !this.isMessage();
+    }
+    //todo: add agnostic options resolver for Context
+    abstract get options(): unknown;
+
+    abstract get id(): string;
+
+    static wrap(_: unknown): unknown {
+        throw Error('You need to override this method; cannot wrap an abstract class');
+    }
+}

src/core/structures/enums.ts

@@ -15,45 +15,18 @@
  * ```
  */
 export enum CommandType {
-    /**
-     * The CommandType for text commands
-     */
-    Text = 1,
-    /**
-     * The CommandType for slash commands
-     */
-    Slash = 2,
-    /**
-     * The CommandType for hybrid commands, text and slash
-     */
+    Text = 1 << 0,
+    Slash = 1 << 1,
     Both = 3,
-    /**
-     * The CommandType for UserContextMenuInteraction commands
-     */
-    CtxUser = 4,
-    /**
-     * The CommandType for MessageContextMenuInteraction commands
-     */
-    CtxMsg = 8,
-    /**
-     * The CommandType for ButtonInteraction commands
-     */
-    Button = 16,
-    /**
-     * The CommandType for StringSelectMenuInteraction commands
-     */
-    StringSelect = 32,
-    /**
-     * The CommandType for ModalSubmitInteraction commands
-     */
-    Modal = 64,
-    /**
-     * The CommandType for the other SelectMenuInteractions
-     */
-    ChannelSelect = 256,
-    MentionableSelect = 512,
-    RoleSelect = 1024,
-    UserSelect = 2048,
+    CtxUser = 1 << 2,
+    CtxMsg = 1 << 3,
+    Button = 1 << 4,
+    StringSelect = 1 << 5,
+    Modal = 1 << 6,
+    ChannelSelect = 1 << 7,
+    MentionableSelect = 1 << 8,
+    RoleSelect = 1 << 9,
+    UserSelect = 1 << 10,
 }
 
 /**
@@ -106,16 +79,6 @@ export enum PluginType {
      * The PluginType for InitPlugins
      */
     Init = 1,
-    /**
-     * @deprecated
-     * Use PluginType.Init instead
-     */
-    Command = 1,
-    /**
-     * @deprecated
-     * Use PluginType.Control instead
-     */
-    Event = 2,
     /**
      * The PluginType for EventPlugins
      */

src/core/structures/errors.ts

@@ -1,7 +1,7 @@
 /**
  * @enum { string }
  */
-export enum SernError {
+export const enum SernError {
     /**
      * Throws when registering an invalid module.
      * This means it is undefined or an invalid command type was provided

src/core/structures/index.ts

@@ -0,0 +1,5 @@
+export * from './enums';
+export * from './context';
+export * from './sern-emitter';
+export * from './services';
+export * from './module-store';

src/core/structures/module-store.ts

@@ -0,0 +1,12 @@
+import { CoreModuleStore } from '../contracts';
+import { Module, CommandMeta } from '../types/modules';
+
+/*
+ * @internal
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
+ * For interacting with modules, use the ModuleManager instead.
+ */
+export class ModuleStore implements CoreModuleStore {
+    metadata = new WeakMap<Module, CommandMeta>();
+    commands = new Map<string, string>();
+}

src/core/structures/sern-emitter.ts

@@ -1,12 +1,15 @@
-import { EventEmitter } from 'events';
-import type { Payload, SernEventsMapping } from '../types/handler';
-import { PayloadType } from './structures';
-import type { Module } from '../types/module';
+import { EventEmitter } from 'node:events';
+import { PayloadType } from '../../core/structures';
+import { Payload, SernEventsMapping } from '../../shared';
+import { Module } from '../types/modules';
 
 /**
  * @since 1.0.0
  */
-class SernEmitter extends EventEmitter {
+export class SernEmitter extends EventEmitter {
+    constructor() {
+        super({ captureRejections: true });
+    }
     /**
      * Listening to sern events with on. This event stays on until a crash or a normal exit
      * @param eventName
@@ -84,5 +87,3 @@ class SernEmitter extends EventEmitter {
         );
     }
 }
-
-export default SernEmitter;

src/core/structures/services/error-handling.ts

@@ -0,0 +1,22 @@
+import { ErrorHandling } from '../../contracts';
+
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
+ */
+export class DefaultErrorHandling implements ErrorHandling {
+    
+    crash(err: Error): never {
+        throw err; 
+    }
+
+    keepAlive = 5;
+
+    updateAlive(err: Error) {
+        this.keepAlive--;
+        if(this.keepAlive === 0) {
+           throw err;
+        }
+    }
+}

src/core/structures/services/index.ts

@@ -0,0 +1,3 @@
+export * from './error-handling';
+export * from './logger';
+export * from './module-manager';

src/core/structures/services/logger.ts

@@ -1,15 +1,9 @@
-import type { LogPayload } from '../../types/handler';
-/**
- * @since 2.0.0
- */
-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;
-}
+import { LogPayload, Logging } from '../../contracts';
+
 /**
+ * @internal
  * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using ModuleStore!
  */
 export class DefaultLogging implements Logging {
     private date = () => new Date();

src/core/structures/services/module-manager.ts

@@ -0,0 +1,51 @@
+import { createId } from '../../../handler/id';
+import { CoreModuleStore, ModuleManager } from '../../contracts';
+import { importModule } from '../../module-loading';
+import { CommandMeta, CommandModule, CommandModuleDefs, Module } from '../../types/modules';
+import { CommandType } from '../enums';
+/**
+ * @internal
+ * @since 2.0.0
+ * Version 4.0.0 will internalize this api. Please refrain from using DefaultModuleManager!
+ */
+export class DefaultModuleManager implements ModuleManager {
+    constructor(private moduleStore: CoreModuleStore) {}
+
+    getByNameCommandType<T extends CommandType>(name: string, commandType: T) {
+        const id = this.get(createId(name, commandType));
+        if(!id) {
+            return undefined;
+        }
+        return importModule<CommandModuleDefs[T]>(id);
+    }
+
+    setMetadata(m: Module, c: CommandMeta): void {
+        this.moduleStore.metadata.set(m, c);
+    }
+
+    getMetadata(m: Module): CommandMeta {
+        const maybeModule = this.moduleStore.metadata.get(m);
+        if (!maybeModule) {
+            throw Error('Could not find metadata in store for ' + maybeModule);
+        }
+        return maybeModule;
+    }
+
+
+    get(id: string) {
+        return this.moduleStore.commands.get(id);
+    }
+    set(id: string, path: string): void {
+        this.moduleStore.commands.set(id, path);
+    }
+    //not tested
+    getPublishableCommands(): Promise<CommandModule[]> {
+        const entries = this.moduleStore.commands.entries();
+        const publishable = 0b000000110;
+        return Promise.all(
+            Array.from(entries)
+                .filter(([id]) => !(Number.parseInt(id.at(-1)!) & publishable))
+                .map(([, path]) => importModule<CommandModule>(path)),
+        );
+    }
+}

src/core/types/modules.ts

@@ -1,34 +1,35 @@
 import type {
-    ApplicationCommandAttachmentOption,
-    ApplicationCommandChannelOptionData,
-    ApplicationCommandChoicesData,
-    ApplicationCommandNonOptionsData,
-    ApplicationCommandNumericOptionData,
-    ApplicationCommandOptionData,
+    APIApplicationCommandBasicOption,
+    APIApplicationCommandOptionBase,
     ApplicationCommandOptionType,
-    ApplicationCommandSubCommandData,
-    ApplicationCommandSubGroupData,
-    AutocompleteInteraction,
-    Awaitable,
     BaseApplicationCommandOptionsData,
+} from 'discord.js';
+import {
+    AutocompleteInteraction,
     ButtonInteraction,
+    ChannelSelectMenuInteraction,
+    ClientEvents,
+    MentionableSelectMenuInteraction,
     MessageContextMenuCommandInteraction,
     ModalSubmitInteraction,
-    UserContextMenuCommandInteraction,
-    ChannelSelectMenuInteraction,
-    MentionableSelectMenuInteraction,
     RoleSelectMenuInteraction,
     StringSelectMenuInteraction,
+    UserContextMenuCommandInteraction,
     UserSelectMenuInteraction,
 } 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 { AnyCommandPlugin, AnyEventPlugin } from './plugin';
-import type { SernEventsMapping } from './handler';
-import type { ClientEvents } from 'discord.js';
+import { CommandType, Context, EventType } from '../structures';
+import { AnyCommandPlugin, AnyEventPlugin, ControlPlugin, InitPlugin } from './plugins';
+import { Awaitable, SernEventsMapping } from '../../shared';
+import { Processed } from '../../handler/types';
+import { Args, SlashOptions } from '../../shared';
+
+export interface CommandMeta {
+    fullPath: string;
+    id: string;
+    isClass: boolean
+}
+
+export type AnyDefinedModule = Processed<CommandModule | EventModule>;
 
 export interface Module {
     type: CommandType | EventType;
@@ -39,25 +40,17 @@ export interface Module {
     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 SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
+    extends Module {
+    name?: T;
+    type: EventType.Sern;
+    execute(...args: SernEventsMapping[T]): 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 ExternalEventCommand extends Module {
+    name?: string;
+    emitter: keyof Dependencies;
+    type: EventType.External;
+    execute(...args: unknown[]): Awaitable<unknown>;
 }
 
 export interface ContextMenuUser extends Module {
@@ -111,25 +104,31 @@ export interface AutocompleteCommand
     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 TextCommand extends Module {
+    type: CommandType.Text;
+    alias?: string[];
+    execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
+}
 
-export interface ExternalEventCommand extends Module {
-    name?: string;
-    emitter: string;
-    type: EventType.External;
-    execute(...args: unknown[]): 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 type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
@@ -151,7 +150,7 @@ 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 = {
+export interface CommandModuleDefs {
     [CommandType.Text]: TextCommand;
     [CommandType.Slash]: SlashCommand;
     [CommandType.Both]: BothCommand;
@@ -164,13 +163,13 @@ export type CommandModuleDefs = {
     [CommandType.MentionableSelect]: MentionableSelectCommand;
     [CommandType.UserSelect]: UserSelectCommand;
     [CommandType.Modal]: ModalSubmitCommand;
-};
+}
 
-export type EventModuleDefs = {
+export interface EventModuleDefs {
     [EventType.Sern]: SernEventCommand;
     [EventType.Discord]: DiscordEventCommand;
     [EventType.External]: ExternalEventCommand;
-};
+}
 
 export interface SernAutocompleteData
     extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
@@ -182,10 +181,10 @@ export interface SernAutocompleteData
     command: AutocompleteCommand;
 }
 
-export type CommandModuleNoPlugins = {
+type CommandModuleNoPlugins = {
     [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
 };
-export type EventModulesNoPlugins = {
+type EventModulesNoPlugins = {
     [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
 };
 
@@ -197,32 +196,22 @@ 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
+export type SernOptionsData =
+    | SernSubCommandData
+    | SernSubCommandGroupData
+    | APIApplicationCommandBasicOption
     | SernAutocompleteData;
 
-export interface SernSubCommandData extends BaseApplicationCommandOptionsData {
+export interface SernSubCommandData extends APIApplicationCommandOptionBase<ApplicationCommandOptionType.Subcommand> {
     type: ApplicationCommandOptionType.Subcommand;
-    required?: never;
-    options?: BaseOptions[];
+    options?: SernOptionsData[];
 }
 
 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/core/types/plugins.ts

@@ -1,12 +1,26 @@
-import type { CommandType } from '../structures/enums';
-import type { PluginType } from '../structures/enums';
-import type { ClientEvents } from 'discord.js';
+/*
+ * 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 { Err, Ok, Result } from 'ts-results-es';
 import type {
     BothCommand,
     ButtonCommand,
     ChannelSelectCommand,
+    CommandModule,
+    ContextMenuMsg,
     ContextMenuUser,
     DiscordEventCommand,
+    EventModule,
     ExternalEventCommand,
     MentionableSelectCommand,
     ModalSubmitCommand,
@@ -16,27 +30,58 @@ import type {
     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 {
+} from './modules';
+import { Args, Awaitable, Payload, SlashOptions } from '../../shared';
+import { CommandType, Context, EventType, PluginType } from '../structures';
+import { InitArgs, Processed } from '../../handler/types';
+import {
     ButtonInteraction,
+    ChannelSelectMenuInteraction,
+    ClientEvents,
+    MentionableSelectMenuInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
     RoleSelectMenuInteraction,
     StringSelectMenuInteraction,
     UserContextMenuCommandInteraction,
-} from 'discord.js';
-import type {
-    ChannelSelectMenuInteraction,
-    MentionableSelectMenuInteraction,
-    ModalSubmitInteraction,
     UserSelectMenuInteraction,
 } from 'discord.js';
-import { EventType } from '../structures/enums';
 
-type CommandArgsMatrix = {
+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>>]>;
+
+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];
+
+interface CommandArgsMatrix {
     [CommandType.Text]: {
         [PluginType.Control]: [Context, ['text', string[]]];
         [PluginType.Init]: [InitArgs<Processed<TextCommand>>];
@@ -85,9 +130,9 @@ type CommandArgsMatrix = {
         [PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
         [PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
     };
-};
+}
 
-type EventArgsMatrix = {
+interface EventArgsMatrix {
     [EventType.Discord]: {
         [PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
         [PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
@@ -100,18 +145,4 @@ type EventArgsMatrix = {
         [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/commands.ts

@@ -0,0 +1,112 @@
+import { ClientEvents } from 'discord.js';
+import { CommandType, EventType, PluginType } from '../core/structures';
+import {
+    AnyCommandPlugin,
+    AnyEventPlugin,
+    CommandArgs,
+    ControlPlugin,
+    EventArgs,
+    InitPlugin,
+} from '../core/types/plugins';
+import {
+    CommandModule,
+    EventModule,
+    InputCommand,
+    InputEvent,
+    Module,
+} from '../core/types/modules';
+import { partitionPlugins } from '../core/functions';
+import { Awaitable } from '../shared';
+
+/**
+ * @since 1.0.0 The wrapper function to define command modules for sern
+ * @param mod
+ */
+export function commandModule(mod: InputCommand): CommandModule {
+    const [onEvent, plugins] = partitionPlugins(mod.plugins);
+    return {
+        ...mod,
+        onEvent,
+        plugins,
+    } as CommandModule;
+}
+/**
+ * @since 1.0.0
+ * The wrapper function to define event modules for sern
+ * @param mod
+ */
+export function eventModule(mod: InputEvent): EventModule {
+    const [onEvent, plugins] = partitionPlugins(mod.plugins);
+    return {
+        ...mod,
+        plugins,
+        onEvent,
+    } as EventModule;
+}
+
+/** Create event modules from discord.js client events,
+ * This is an {@link eventModule} for discord events,
+ * where typings can be very bad.
+ * @Experimental
+ * @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,
+    });
+}
+
+function prepareClassPlugins(c: Module) {
+    const [onEvent, initPlugins] = partitionPlugins(c.plugins);
+    c.plugins = initPlugins as InitPlugin[];
+    c.onEvent = onEvent as ControlPlugin[];
+}
+//
+// Class modules:
+// Can be refactored.
+// Both implement singleton, could I make them inherit a singleton parent class?
+/**
+ * @Experimental
+ * Will be refactored / changed in future
+ */
+export abstract class CommandExecutable<const Type extends CommandType = CommandType> {
+    abstract type: Type;
+    plugins: AnyCommandPlugin[] = [];
+    private static _instance: CommandModule;
+
+    static getInstance() {
+        if (!CommandExecutable._instance) {
+            //@ts-ignore
+            CommandExecutable._instance = new this();
+            prepareClassPlugins(CommandExecutable._instance);
+        }
+        return CommandExecutable._instance;
+    }
+
+    abstract execute(...args: CommandArgs<Type, PluginType.Control>): Awaitable<unknown>;
+}
+
+/**
+ * @Experimental
+ * Will be refactored in future
+ */
+export abstract class EventExecutable<Type extends EventType> {
+    abstract type: Type;
+    plugins: AnyEventPlugin[] = [];
+
+    private static _instance: EventModule;
+    static getInstance() {
+        if (!EventExecutable._instance) {
+            //@ts-ignore
+            EventExecutable._instance = new this();
+            prepareClassPlugins(EventExecutable._instance);
+        }
+        return EventExecutable._instance;
+    }
+    abstract execute(...args: EventArgs<Type, PluginType.Control>): Awaitable<unknown>;
+}

src/handler/contracts/errorHandling.ts

@@ -1,50 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { Logging } from './logging';
-import util from 'util';
-/**
- * @since 2.0.0
- */
-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;
-}
-/**
- * @since 2.0.0
- */
-export class DefaultErrorHandling implements ErrorHandling {
-    keepAlive = 5;
-    crash(error: Error): never {
-        throw error;
-    }
-    updateAlive(_: 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

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

src/handler/contracts/moduleManager.ts

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

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

src/handler/dependencies/lifetimeFunctions.ts

@@ -1,63 +0,0 @@
-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
- * @since 2.0.0
- * @param cb
- */
-export function single<T extends () => unknown>(cb: T): T;
-/**
- * @__PURE__
- * @since 2.0.0.
- * 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;
-/**
- * @__PURE__
- * @since 2.0.0
- * 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;
-}
-
-/**
- * @__PURE__
- * @deprecated
- * @param value
- * Please use the transient function instead
- */
-// prettier-ignore
-export const many = <T>(value: T) => () => _const(value);

src/handler/dependencies/provider.ts

@@ -1,86 +0,0 @@
-import type { Container } from 'iti';
-import type { Dependencies, DependencyConfiguration, MapDeps } from '../../types/handler';
-import SernEmitter from '../sernEmitter';
-import { DefaultErrorHandling, DefaultLogging, DefaultModuleManager } from '../contracts';
-import { Result } from 'ts-results-es';
-import { BehaviorSubject } from 'rxjs';
-import { createContainer } from 'iti';
-import { type Wrapper, ModuleStore, SernError } from '../structures';
-
-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'>,
-        {}
-    >;
-}
-
-export function makeFetcher(wrapper: Wrapper) {
-    const requiredDependencyKeys = [
-        '@sern/emitter',
-        '@sern/client',
-        '@sern/errors',
-        '@sern/logger',
-    ] as ['@sern/emitter', '@sern/client', '@sern/errors', '@sern/logger'];
-    return <Keys extends (keyof Dependencies)[]>(otherKeys: [...Keys]) =>
-        wrapper.containerConfig.get(...requiredDependencyKeys, ...otherKeys) as MapDeps<
-            Dependencies,
-            [...typeof requiredDependencyKeys, ...Keys]
-        >;
-}

src/handler/events/dispatchers.ts

@@ -0,0 +1,119 @@
+import { EventEmitter } from 'node:events';
+import * as assert from 'node:assert';
+import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
+import { arrayifySource, callPlugin } from '../../core/operators';
+import { createResultResolver } from './generic';
+import { AutocompleteInteraction, BaseInteraction, Message } from 'discord.js';
+import { treeSearch } from '../../core/functions';
+import { SernError } from '../../core/structures/errors';
+import { CommandType, Context } from '../../core';
+import { isAutocomplete } from '../../core/predicates';
+import { Processed } from '../types';
+import { BothCommand, CommandModule, Module } from '../../core/types/modules';
+import { Args } from '../../shared';
+
+
+function dispatchInteraction<T extends CommandModule, V extends BaseInteraction | Message>(
+    payload: { module: Processed<T>; event: V },
+    createArgs: (m: typeof payload.event) => unknown[],
+) {
+    return {
+        module: payload.module,
+        args: createArgs(payload.event),
+    };
+}
+//TODO: refactor dispatchers so that it implements a strategy for each different type of payload?
+export function dispatchMessage(module: Processed<CommandModule>, args: [Context, Args]) {
+    return {
+        module,
+        args,
+    };
+}
+
+function dispatchAutocomplete(payload: {
+    module: Processed<BothCommand>;
+    event: AutocompleteInteraction;
+}) {
+    const option = treeSearch(payload.event, payload.module.options);
+    if (option !== undefined) {
+        return {
+            module: option.command as Processed<Module>, //autocomplete is not a true "module" warning cast!
+            args: [payload.event],
+        };
+    }
+    throw Error(
+        SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
+    );
+}
+
+export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?: string[]) {
+    const ctx = Context.wrap(wrappable);
+    const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.options];
+    return [ctx, args] as [Context, Args];
+}
+
+function interactionArg<T extends BaseInteraction>(interaction: T) {
+    return [interaction] as [T];
+}
+
+function intoPayload(module: Processed<Module>) {
+    return pipe(
+        arrayifySource,
+        map(args => ({ module, args })),
+    );
+}
+
+const createResult = createResultResolver<
+    Processed<Module>,
+    { module: Processed<Module>; args: unknown[] },
+    unknown[]
+>({
+    createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
+    onNext: ({ args }) => 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`);
+
+    const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
+        module.execute(...args),
+    );
+    return fromEvent(source, module.name).pipe(
+        intoPayload(module),
+        concatMap(createResult),
+        execute,
+    );
+}
+
+export function createDispatcher(payload: {
+    module: Processed<CommandModule>;
+    event: BaseInteraction;
+}) {
+    switch (payload.module.type) {
+        case CommandType.Text:
+            throw Error(
+                SernError.MismatchEvent +
+                    ' Found a text module in interaction stream. ' +
+                    payload.module,
+            );
+        case CommandType.Slash:
+        case CommandType.Both: {
+            if (isAutocomplete(payload.event)) {
+                /**
+                 * Autocomplete is a special case that
+                 * must be handled separately, since it's
+                 * too different from regular command modules
+                 * CAST SAFETY: payload is already guaranteed to be a slash command or both command
+                 */
+                return dispatchAutocomplete(payload as never);
+            }
+            return dispatchInteraction(payload, contextArgs);
+        }
+        default:
+            return dispatchInteraction(payload, interactionArg);
+    }
+}

src/handler/events/dispatchers/dispatchers.ts

@@ -1,67 +0,0 @@
-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 { arrayifySource, callPlugin } from '../operators';
-import { createResultResolver } from '../observableHandling';
-
-export function dispatchCommand(module: Processed<CommandModule>, createArgs: () => unknown[]) {
-    const args = createArgs();
-    return {
-        module,
-        args,
-    };
-}
-
-function intoPayload(module: Processed<Module>) {
-    return pipe(
-        arrayifySource,
-        map(args => ({ module, args })),
-    );
-}
-
-const createResult = createResultResolver<
-    Processed<Module>,
-    { module: Processed<Module>; args: unknown[] },
-    unknown[]
->({
-    createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
-    onNext: ({ args }) => 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`);
-
-    const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
-        module.execute(...args),
-    );
-    return fromEvent(source, module.name).pipe(
-        intoPayload(module),
-        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

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

src/handler/events/dispatchers/provideArgs.ts

@@ -1,23 +0,0 @@
-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/generic.ts

@@ -0,0 +1,232 @@
+import { Interaction, Message } from 'discord.js';
+import {
+    EMPTY,
+    Observable,
+    concatMap,
+    filter,
+    from,
+    of,
+    throwError,
+    tap,
+    MonoTypeOperatorFunction,
+    catchError,
+    finalize,
+} from 'rxjs';
+import { ErrorHandling, Logging, ModuleManager, useContainerRaw } from '../../core';
+import { SernError } from '../../core/structures/errors';
+import { callPlugin, everyPluginOk, filterMap, filterMapTo, handleError } from '../../core/operators';
+import { defaultModuleLoader } from '../../core/module-loading';
+import { CommandModule, Module, AnyModule } from '../../core/types/modules';
+import { contextArgs, createDispatcher, dispatchMessage } from './dispatchers';
+import { ObservableInput, pipe, switchMap } from 'rxjs';
+import { SernEmitter } from '../../core';
+import { errTap } from '../../core/operators';
+import * as Files from '../../core/module-loading';
+import { Err, Result } from 'ts-results-es';
+import { fmt } from './messages';
+import { ControlPlugin, VoidResult } from '../../core/types/plugins';
+import { ImportPayload, Processed } from '../types';
+import { Awaitable } from '../../shared';
+import { createId, reconstructId } from '../id';
+
+function createGenericHandler<Source, Narrowed extends Source, Output>(
+    source: Observable<Source>,
+    makeModule: (event: Narrowed) => Awaitable<Result<Output, unknown>>,
+) {
+    return (pred: (i: Source) => i is Narrowed) => source.pipe(filter(pred), filterMap(makeModule));
+}
+/**
+ *
+ * Creates an RxJS observable that filters and maps incoming interactions to their respective modules.
+ * @param i An RxJS observable of interactions.
+ * @param mg The module manager instance used to retrieve the module path for each interaction.
+ * @returns A handler to create a RxJS observable of dispatchers that take incoming interactions and execute their corresponding modules.
+ */
+export function createInteractionHandler<T extends Interaction>(
+    source: Observable<Interaction>,
+    mg: ModuleManager,
+) {
+    return createGenericHandler<Interaction, T, ReturnType<typeof createDispatcher>>(
+        source,
+        event => {
+            const fullPath = mg.get(reconstructId(event as unknown as Interaction));
+            if (!fullPath)
+                return Err(SernError.UndefinedModule + ' No full path found in module store');
+            return defaultModuleLoader<Processed<CommandModule>>(fullPath).then(res =>
+                res.map(payload => createDispatcher({ module: payload.module, event })),
+            );
+        },
+    );
+}
+
+export function createMessageHandler(
+    source: Observable<Message>,
+    defaultPrefix: string,
+    mg: ModuleManager,
+) {
+    return createGenericHandler(source, event => {
+        const [prefix, ...rest] = fmt(event.content, defaultPrefix);
+        const fullPath = mg.get(`${prefix}_A0`);
+        if (fullPath === undefined) {
+            return Err(SernError.UndefinedModule + ' No full path found in module store');
+        }
+        return defaultModuleLoader<Processed<CommandModule>>(fullPath).then(result => {
+            const args = contextArgs(event, rest);
+            return result.map(payload => dispatchMessage(payload.module, args));
+        });
+    });
+}
+/**
+ * IMPURE SIDE EFFECT
+ * This function assigns remaining, incomplete data to each imported module.
+ */
+function assignDefaults<T extends Module>(
+    moduleManager: ModuleManager,
+): MonoTypeOperatorFunction<ImportPayload<T>> {
+    return tap(({ module, absPath }) => {
+        module.name ??= Files.filename(absPath);
+        module.description ??= '...';
+        moduleManager.setMetadata(module, {
+            isClass: module.constructor.name === 'Function',
+            fullPath: absPath,
+            id: createId(module.name, module.type),
+        });
+    });
+}
+
+export function buildModules<T extends AnyModule>(
+    input: ObservableInput<string>,
+    sernEmitter: SernEmitter,
+    moduleManager: ModuleManager,
+) {
+    return pipe(
+        switchMap(() => Files.buildModuleStream<T>(input)),
+        errTap(error => {
+            sernEmitter.emit('module.register', SernEmitter.failure(undefined, error));
+        }),
+        assignDefaults<T>(moduleManager),
+    );
+}
+
+function hasPrefix(prefix: string, content: string) {
+    const prefixInContent = content.slice(0, prefix.length);
+    return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
+}
+
+/**
+ * Ignores messages from any person / bot except itself
+ * @param prefix
+ */
+export function isNonBot(prefix: string) {
+    return ({ author, content }: Message) => !author.bot && hasPrefix(prefix, content);
+}
+
+/**
+ * Wraps the task in a Result as a try / catch.
+ * if the task is ok, an event is emitted and the stream becomes empty
+ * if the task is an error, throw an error down the stream which will be handled by catchError
+ * @param emitter reference to SernEmitter that will emit a successful execution of module
+ * @param module the module that will be executed with task
+ * @param task the deferred execution which will be called
+ */
+export function executeModule(
+    emitter: SernEmitter,
+    {
+        module,
+        task,
+    }: {
+        module: Processed<Module>;
+        task: () => Awaitable<unknown>;
+    },
+) {
+    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(() => 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.onNext }
+ * 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: {
+    onStop?: (module: T) => unknown;
+    onNext: (args: Args) => Output;
+    createStream: (args: Args) => Observable<VoidResult>;
+}) {
+    return (args: Args) => {
+        const task$ = config.createStream(args);
+        return task$.pipe(
+            tap(result => {
+                result.err && config.onStop?.(args.module);
+            }),
+            everyPluginOk,
+            filterMapTo(() => config.onNext(args)),
+        );
+    };
+}
+
+/**
+ * Calls a module's init plugins and checks for Err. If so, call { onStop } and
+ * ignore the module
+ */
+export function callInitPlugins<
+    T extends Processed<AnyModule>,
+    Args extends ImportPayload<T>,
+>(config: { onStop?: (module: T) => unknown; onNext: (module: Args) => T }) {
+    return concatMap(
+        createResultResolver({
+            createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
+            ...config,
+        }),
+    );
+}
+
+/**
+ * Creates an executable task ( execute the command ) if  all control plugins are successful
+ * @param onStop emits a failure response to the SernEmitter
+ */
+export function makeModuleExecutor<
+    M extends Processed<Module>,
+    Args extends { module: M; args: unknown[] },
+>(onStop: (m: M) => unknown) {
+    const onNext = ({ args, module }: Args) => ({ task: () => module.execute(...args), module });
+    return concatMap(
+        createResultResolver({
+            onStop,
+            createStream: ({ args, module }) => from(module.onEvent).pipe(callPlugin(args)),
+            onNext,
+        }),
+    );
+}
+
+export function handleCrash(
+    errorHandler: ErrorHandling,
+    logger?: Logging,
+) {
+    return pipe(
+        catchError(handleError(errorHandler, logger)),
+        finalize(() => {
+            logger?.info({ message: 'A stream closed or reached end of lifetime' });
+            useContainerRaw()?.disposeAll()
+                .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
+        })
+    );
+}

src/handler/events/interactionHandler.ts

@@ -1,118 +0,0 @@
-import { Interaction } from 'discord.js';
-import {
-    catchError,
-    concatMap,
-    EMPTY,
-    filter,
-    finalize,
-    fromEvent,
-    map,
-    Observable,
-    of,
-    OperatorFunction,
-    pipe,
-} from 'rxjs';
-import { CommandType, type ModuleStore, SernError } from '../structures';
-import { contextArgs, dispatchAutocomplete, dispatchCommand, interactionArg } from './dispatchers';
-import { executeModule, makeModuleExecutor } from './observableHandling';
-import type { CommandModule } from '../../types/module';
-import { ErrorHandling, handleError } from '../contracts/errorHandling';
-import SernEmitter from '../sernEmitter';
-import type { Processed } from '../../types/handler';
-import { useContainerRaw } from '../dependencies';
-import type { Logging, ModuleManager } from '../contracts';
-import type { EventEmitter } from 'node:events';
-
-function makeInteractionProcessor(
-    modules: ModuleManager,
-): OperatorFunction<Interaction, { module: Processed<CommandModule>; event: Interaction }> {
-    const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
-        return modules.get(cb);
-    };
-    return pipe(
-        concatMap(event => {
-            if (event.isMessageComponent()) {
-                const customId = event.customId;
-                const module = get(ms => {
-                    return ms.InteractionHandlers[event.componentType].get(customId);
-                });
-                return of({ module, event });
-            } else if (event.isCommand() || event.isAutocomplete()) {
-                const commandName = event.commandName;
-                const module = get(
-                    ms =>
-                        /**
-                         * try to fetch from ApplicationCommands, if nothing, try BothCommands
-                         * exists on the API but not sern
-                         */
-                        ms.ApplicationCommands[event.commandType].get(commandName) ??
-                        ms.BothCommands.get(commandName),
-                );
-                return of({ module, event });
-            } else if (event.isModalSubmit()) {
-                const module = get(ms => ms.ModalSubmit.get(event.customId));
-                return of({ module, event });
-            } else return EMPTY;
-        }),
-        filter(m => m.module !== undefined),
-    ) as OperatorFunction<Interaction, { module: Processed<CommandModule>; event: Interaction }>;
-}
-
-export function makeInteractionCreate([s, client, err, log, modules]: [
-    SernEmitter,
-    EventEmitter,
-    ErrorHandling,
-    Logging | undefined,
-    ModuleManager,
-]) {
-    //map. If nothing again,this means a slash command
-    const interactionStream$ = fromEvent(client, 'interactionCreate') as Observable<Interaction>;
-    const interactionProcessor = makeInteractionProcessor(modules);
-    return interactionStream$
-        .pipe(
-            interactionProcessor,
-            map(createDispatcher),
-            makeModuleExecutor(module => {
-                s.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
-            }),
-            concatMap(module => executeModule(s, module)),
-            catchError(handleError(err, log)),
-            finalize(() => {
-                log?.info({
-                    message: 'interactionCreate stream closed or reached end of lifetime',
-                });
-                useContainerRaw()
-                    ?.disposeAll()
-                    .then(() => log?.info({ message: 'Cleaning container and crashing' }));
-            }),
-        )
-        .subscribe();
-}
-
-function createDispatcher({
-    module,
-    event,
-}: {
-    event: Interaction;
-    module: Processed<CommandModule>;
-}) {
-    switch (module.type) {
-        case CommandType.Text:
-            throw Error(SernError.MismatchEvent);
-        case CommandType.Slash:
-        case CommandType.Both: {
-            if (event.isAutocomplete()) {
-                /**
-                 * Autocomplete is a special case that
-                 * must be handled separately, since it's
-                 * too different from regular command modules
-                 */
-                return dispatchAutocomplete(module, event);
-            } else {
-                return dispatchCommand(module, contextArgs(event));
-            }
-        }
-        default:
-            return dispatchCommand(module, interactionArg(event));
-    }
-}

src/handler/events/interactions.ts

@@ -0,0 +1,26 @@
+import { Interaction } from 'discord.js';
+import { concatMap, merge } from 'rxjs';
+import { SernError } from '../../core/structures/errors';
+import { SernEmitter } from '../../core';
+import { sharedObservable } from '../../core/operators';
+import { isAutocomplete, isCommand, isMessageComponent, isModal } from '../../core/predicates';
+import { createInteractionHandler, executeModule, makeModuleExecutor } from './generic';
+import { DependencyList } from '../types';
+
+export function makeInteractionHandler([emitter, , , modules, client]: DependencyList) {
+    const interactionStream$ = sharedObservable<Interaction>(client, 'interactionCreate');
+    const handle = createInteractionHandler(interactionStream$, modules);
+
+    const interactionHandler$ = merge(
+        handle(isMessageComponent),
+        handle(isAutocomplete),
+        handle(isCommand),
+        handle(isModal),
+    );
+    return interactionHandler$.pipe(
+        makeModuleExecutor(module => {
+            emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
+        }),
+        concatMap(payload => executeModule(emitter, payload)),
+    );
+}

src/handler/events/messageHandler.ts

@@ -1,92 +0,0 @@
-import { catchError, concatMap, EMPTY, finalize, fromEvent, map, Observable, of, pipe } from 'rxjs';
-import { type ModuleStore, SernError } from '../structures';
-import type { Message } from 'discord.js';
-import { executeModule, ignoreNonBot, makeModuleExecutor } from './observableHandling';
-import type { CommandModule, TextCommand } from '../../types/module';
-import { ErrorHandling, handleError } from '../contracts/errorHandling';
-import { contextArgs, dispatchCommand } from './dispatchers';
-import SernEmitter from '../sernEmitter';
-import type { Processed } from '../../types/handler';
-import { useContainerRaw } from '../dependencies';
-import type { Logging, ModuleManager } from '../contracts';
-import type { EventEmitter } from 'node:events';
-
-/**
- * Removes the first character(s) _[depending on prefix length]_ of the message
- * @param msg
- * @param prefix The prefix to remove
- * @returns The message without the prefix
- * @example
- * message.content = '!ping';
- * console.log(fmt(message, '!'));
- * // [ 'ping' ]
- */
-export function fmt(msg: string, prefix: string): string[] {
-    return msg.slice(prefix.length).trim().split(/\s+/g);
-}
-
-/**
- * An operator function that processes a message to fetch a command module and prepares context payload.
- * @param defaultPrefix
- * @param get
- */
-const createMessageProcessor = (
-    defaultPrefix: string,
-    get: (
-        cb: (ms: ModuleStore) => Processed<CommandModule> | undefined,
-    ) => CommandModule | undefined,
-) =>
-    pipe(
-        ignoreNonBot(defaultPrefix),
-        //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.content, defaultPrefix);
-            const module = get(ms => ms.TextCommands.get(prefix) ?? ms.BothCommands.get(prefix));
-            if (module === undefined) {
-                return EMPTY;
-            }
-            const payload = {
-                args: contextArgs(message, rest),
-                module,
-            };
-            return of(payload);
-        }),
-        map(({ args, module }) => dispatchCommand(module as Processed<TextCommand>, args)),
-    );
-
-export function makeMessageCreate(
-    [s, client, err, log, modules]: [
-        SernEmitter,
-        EventEmitter,
-        ErrorHandling,
-        Logging | undefined,
-        ModuleManager,
-    ],
-    defaultPrefix?: string,
-) {
-    if (!defaultPrefix) {
-        return EMPTY.subscribe();
-    }
-    const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
-        return modules.get(cb);
-    };
-    const messageStream$ = fromEvent(client, 'messageCreate') as Observable<Message>;
-    const messageProcessor = createMessageProcessor(defaultPrefix, get);
-    return messageStream$
-        .pipe(
-            messageProcessor,
-            makeModuleExecutor(module => {
-                s.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
-            }),
-            concatMap(payload => executeModule(s, payload)),
-            catchError(handleError(err, log)),
-            finalize(() => {
-                log?.info({ message: 'messageCreate stream closed or reached end of lifetime' });
-                useContainerRaw()
-                    ?.disposeAll()
-                    .then(() => log?.info({ message: 'Cleaning container and crashing' }));
-            }),
-        )
-        .subscribe();
-}

src/handler/events/messages.ts

@@ -0,0 +1,42 @@
+import { concatMap, EMPTY } from 'rxjs';
+import { SernError } from '../../core/structures/errors';
+import type { Message } from 'discord.js';
+import { SernEmitter } from '../../core';
+import { sharedObservable } from '../../core/operators';
+import { createMessageHandler, executeModule, isNonBot, makeModuleExecutor } from './generic';
+import { DependencyList } from '../types';
+
+/**
+ * Removes the first character(s) _[depending on prefix length]_ of the message
+ * @param msg
+ * @param prefix The prefix to remove
+ * @returns The message without the prefix
+ * @example
+ * message.content = '!ping';
+ * console.log(fmt(message, '!'));
+ * // [ 'ping' ]
+ */
+export function fmt(msg: string, prefix: string): string[] {
+    return msg.slice(prefix.length).trim().split(/\s+/g);
+}
+
+export function makeMessageHandler(
+    [emitter, , log, modules, client]: DependencyList,
+    defaultPrefix: string | undefined,
+) {
+    if (!defaultPrefix) {
+        log?.debug({ message: 'No prefix found. message handler shutting down' });
+        return EMPTY;
+    }
+    const messageStream$ = sharedObservable<Message>(client, 'messageCreate');
+    const handler = createMessageHandler(messageStream$, defaultPrefix, modules);
+
+    const prefixedMessages$ = handler(isNonBot(defaultPrefix) as (m: Message) => m is Message);
+
+    return prefixedMessages$.pipe(
+        makeModuleExecutor(module => {
+            emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
+        }),
+        concatMap(payload => executeModule(emitter, payload)),
+    );
+}

src/handler/events/observableHandling.ts

@@ -1,121 +0,0 @@
-import type { Awaitable, Message } from 'discord.js';
-import { concatMap, EMPTY, filter, from, Observable, of, tap, throwError } from 'rxjs';
-import { Result } from 'ts-results-es';
-import type { CommandModule, EventModule, Module } from '../../types/module';
-import SernEmitter from '../sernEmitter';
-import { callPlugin, everyPluginOk, filterMapTo } from './operators';
-import type { ImportPayload, Processed } from '../../types/handler';
-import type { ControlPlugin, VoidResult } from '../../types/plugin';
-
-function hasPrefix(prefix: string, content: string) {
-    const prefixInContent = content.slice(0, prefix.length);
-    return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
-}
-
-/**
- * Ignores messages from any person / bot except itself
- * @param prefix
- */
-export function ignoreNonBot(prefix: string) {
-    const messageFromHumanAndHasPrefix = ({ author, content }: Message) =>
-        !author.bot && hasPrefix(prefix, content);
-    return filter(messageFromHumanAndHasPrefix);
-}
-
-/**
- * Wraps the task in a Result as a try / catch.
- * if the task is ok, an event is emitted and the stream becomes empty
- * if the task is an error, throw an error down the stream which will be handled by catchError
- * @param emitter reference to SernEmitter that will emit a successful execution of module
- * @param module the module that will be executed with task
- * @param task the deferred execution which will be called
- */
-export function executeModule(
-    emitter: SernEmitter,
-    {
-        module,
-        task,
-    }: {
-        module: Processed<Module>;
-        task: () => Awaitable<unknown>;
-    },
-) {
-    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(() => 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: {
-    onStop?: (module: T) => unknown;
-    onNext: (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.onStop?.(args.module);
-                }
-            }),
-            everyPluginOk,
-            filterMapTo(() => config.onNext(args)),
-        );
-    };
-}
-
-/**
- * Calls a module's init plugins and checks for Err. If so, call { onStop } and
- * ignore the module
- */
-export function callInitPlugins<
-    T extends Processed<CommandModule | EventModule>,
-    Args extends ImportPayload<T>,
->(config: { onStop?: (module: T) => unknown; onNext: (module: Args) => T }) {
-    return concatMap(
-        createResultResolver({
-            createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
-            ...config,
-        }),
-    );
-}
-
-/**
- * Creates an executable task ( execute the command ) if  all control plugins are successful
- * @param onStop emits a failure response to the SernEmitter
- */
-export function makeModuleExecutor<
-    M extends Processed<Module>,
-    Args extends { module: M; args: unknown[] },
->(onStop: (m: M) => unknown) {
-    const onNext = ({ args, module }: Args) => ({ task: () => module.execute(...args), module });
-    return concatMap(
-        createResultResolver({
-            onStop,
-            createStream: ({ args, module }) => from(module.onEvent).pipe(callPlugin(args)),
-            onNext,
-        }),
-    );
-}

src/handler/events/ready.ts

@@ -0,0 +1,55 @@
+import { ObservableInput, fromEvent, take } from 'rxjs';
+import { CommandType } from '../../core/structures';
+import { SernError } from '../../core/structures/errors';
+import { Result } from 'ts-results-es';
+import { ModuleManager } from '../../core/contracts';
+import { SernEmitter } from '../../core';
+import { Processed, DependencyList } from '../types';
+import { buildModules, callInitPlugins } from './generic';
+import { AnyModule } from '../../core/types/modules';
+import * as assert from 'node:assert';
+
+export function startReadyEvent(
+    [sEmitter, , , moduleManager, client]: DependencyList,
+    allPaths: ObservableInput<string>,
+) {
+    const ready$ = fromEvent(client!, 'ready').pipe(take(1));
+    return ready$
+        .pipe(
+            buildModules<Processed<AnyModule>>(allPaths, sEmitter, moduleManager),
+            callInitPlugins({
+                onStop: module => {
+                    sEmitter.emit(
+                        'module.register',
+                        SernEmitter.failure(module, SernError.PluginFailure),
+                    );
+                },
+                onNext: ({ module }) => {
+                    sEmitter.emit('module.register', SernEmitter.success(module));
+                    return module;
+                },
+            }),
+        )
+        .subscribe(module => {
+            const result = registerModule(moduleManager, module);
+            if (result.err) {
+                throw Error(SernError.InvalidModuleType + ' ' + result.val);
+            }
+        });
+}
+
+function registerModule<T extends Processed<AnyModule>>(
+    manager: ModuleManager,
+    module: T,
+): Result<void, void> {
+    const { id, fullPath } = manager.getMetadata(module);
+
+    assert.ok(
+        module.type > 0 && module.type < 1 << 10,
+        `Found ${module.name} at ${fullPath}, which does not have a valid type`,
+    );
+    if (module.type === CommandType.Both || module.type === CommandType.Text) {
+        module.alias?.forEach(a => manager.set(`${a}_A0`, fullPath));
+    }
+    return Result.wrap(() => manager.set(id, fullPath));
+}

src/handler/events/readyHandler.ts

@@ -1,106 +0,0 @@
-import { fromEvent, map, pipe, switchMap, take } from 'rxjs';
-import * as Files from '../module-loading/readFile';
-import { callInitPlugins } from './observableHandling';
-import { CommandType, type ModuleStore, SernError } from '../structures';
-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 { ErrorHandling, Logging, ModuleManager } from '../contracts';
-import { err, ok } from '../utilities/functions';
-import { errTap, fillDefaults } from './operators';
-import SernEmitter from '../sernEmitter';
-import type { EventEmitter } from 'node:events';
-
-function buildCommandModules(commandDir: string, sernEmitter: SernEmitter) {
-    return pipe(
-        switchMap(() => Files.buildModuleStream<CommandModule>(commandDir)),
-        errTap(error => {
-            sernEmitter.emit('module.register', SernEmitter.failure(undefined, error));
-        }),
-        map(fillDefaults),
-    );
-}
-export function makeReadyEvent(
-    [sEmitter, client, errorHandler, , moduleManager]: [
-        SernEmitter,
-        EventEmitter,
-        ErrorHandling,
-        Logging | undefined,
-        ModuleManager,
-    ],
-    commandDir: string,
-) {
-    const readyOnce$ = fromEvent(client, 'ready').pipe(take(1));
-    return readyOnce$
-        .pipe(
-            buildCommandModules(commandDir, sEmitter),
-            callInitPlugins({
-                onStop: module => {
-                    sEmitter.emit(
-                        'module.register',
-                        SernEmitter.failure(module, SernError.PluginFailure),
-                    );
-                },
-                onNext: ({ module }) => {
-                    sEmitter.emit('module.register', SernEmitter.success(module));
-                    return module;
-                },
-            }),
-        )
-        .subscribe(module => {
-            const result = registerModule(moduleManager, module as Processed<CommandModule>);
-            if (result.err) {
-                errorHandler.crash(Error(SernError.InvalidModuleType));
-            }
-        });
-}
-
-function registerModule<T extends Processed<CommandModule>>(
-    manager: ModuleManager,
-    mod: T,
-): Result<void, void> {
-    const name = mod.name;
-    const insert = (cb: (ms: ModuleStore) => void) => {
-        const set = Result.wrap(() => manager.set(cb));
-        return set.ok ? ok() : err();
-    };
-    switch (mod.type) {
-        case CommandType.Text: {
-            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
-            return insert(ms => ms.TextCommands.set(name, mod));
-        }
-        case CommandType.Slash:
-            return insert(ms =>
-                ms.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod),
-            );
-        case CommandType.Both: {
-            mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
-            return insert(ms => ms.BothCommands.set(name, mod));
-        }
-        case CommandType.CtxUser:
-            return insert(ms => ms.ApplicationCommands[ApplicationCommandType.User].set(name, mod));
-        case CommandType.CtxMsg:
-            return insert(ms =>
-                ms.ApplicationCommands[ApplicationCommandType.Message].set(name, mod),
-            );
-        case CommandType.Button:
-            return insert(ms => ms.InteractionHandlers[ComponentType.Button].set(name, mod));
-        case CommandType.StringSelect:
-            return insert(ms => ms.InteractionHandlers[ComponentType.StringSelect].set(name, mod));
-        case CommandType.MentionableSelect:
-            return insert(ms =>
-                ms.InteractionHandlers[ComponentType.MentionableSelect].set(name, mod),
-            );
-        case CommandType.UserSelect:
-            return insert(ms => ms.InteractionHandlers[ComponentType.UserSelect].set(name, mod));
-        case CommandType.ChannelSelect:
-            return insert(ms => ms.InteractionHandlers[ComponentType.ChannelSelect].set(name, mod));
-        case CommandType.RoleSelect:
-            return insert(ms => ms.InteractionHandlers[ComponentType.RoleSelect].set(name, mod));
-        case CommandType.Modal:
-            return insert(ms => ms.ModalSubmit.set(name, mod));
-        default:
-            return err();
-    }
-}

src/handler/events/user-defined.ts

@@ -0,0 +1,59 @@
+import { ObservableInput, catchError, finalize, map, mergeAll, of } from 'rxjs';
+import type { CommandModule, EventModule } from '../../core/types/modules';
+import { SernEmitter } from '../../core';
+import { EventType } from '../../core/structures';
+import { SernError } from '../../core/structures/errors';
+import { eventDispatcher } from './dispatchers';
+import { buildModules, callInitPlugins } from './generic';
+import { handleError } from '../../core/operators';
+import { Service, useContainerRaw } from '../../core/ioc';
+import { DependencyList, Processed } from '../types';
+
+export function makeEventsHandler(
+    [emitter, err, log, moduleManager, client]: DependencyList,
+    allPaths: ObservableInput<string>,
+) {
+    //code smell
+    const intoDispatcher = (e: Processed<EventModule | CommandModule>) => {
+        switch (e.type) {
+            case EventType.Sern:
+                return eventDispatcher(e, emitter);
+            case EventType.Discord:
+                return eventDispatcher(e, client);
+            case EventType.External:
+                return eventDispatcher(e, Service(e.emitter));
+            default:
+                throw Error(SernError.InvalidModuleType + ' while creating event handler');
+        }
+    };
+    of(null)
+        .pipe(
+            buildModules<Processed<EventModule>>(allPaths, emitter, moduleManager),
+            callInitPlugins({
+                onStop: module =>
+                    emitter.emit(
+                        'module.register',
+                        SernEmitter.failure(module, SernError.PluginFailure),
+                    ),
+                onNext: ({ module }) => {
+                    emitter.emit('module.register', SernEmitter.success(module));
+                    return module;
+                },
+            }),
+            map(intoDispatcher),
+            /**
+             * Where all events are turned on
+             */
+            mergeAll(),
+            catchError(handleError(err, log)),
+            finalize(() => {
+                log?.info({ message: 'an event module reached end of lifetime' });
+                useContainerRaw()
+                    ?.disposeAll()
+                    .then(() => {
+                        log?.info({ message: 'Cleaning container and crashing' });
+                    });
+            }),
+        )
+        .subscribe();
+}

src/handler/events/userDefinedEventsHandling.ts

@@ -1,74 +0,0 @@
-import { catchError, finalize, map, mergeAll } from 'rxjs';
-import * as Files from '../module-loading/readFile';
-import type { Dependencies, Processed } from '../../types/handler';
-import { callInitPlugins } from './observableHandling';
-import type { CommandModule, EventModule } from '../../types/module';
-import type { EventEmitter } from 'events';
-import SernEmitter from '../sernEmitter';
-import type { ErrorHandling, Logging } from '../contracts';
-import { SernError, EventType, type Wrapper } from '../structures';
-import { eventDispatcher } from './dispatchers';
-import { handleError } from '../contracts/errorHandling';
-import { errTap, fillDefaults } from './operators';
-import { useContainerRaw } from '../dependencies';
-
-export function makeEventsHandler(
-    [s, client, err, log]: [SernEmitter, EventEmitter, ErrorHandling, Logging | undefined],
-    eventsPath: string,
-    containerGetter: Wrapper['containerConfig'],
-) {
-    const lazy = (k: string) => containerGetter.get(k as keyof Dependencies)[0];
-    const eventStream$ = eventObservable(eventsPath, s);
-
-    const eventCreation$ = eventStream$.pipe(
-        map(fillDefaults),
-        callInitPlugins({
-            onStop: module =>
-                s.emit('module.register', SernEmitter.failure(module, SernError.PluginFailure)),
-            onNext: ({ module }) => {
-                s.emit('module.register', SernEmitter.success(module));
-                return module;
-            },
-        }),
-    );
-    const intoDispatcher = (e: Processed<EventModule | CommandModule>) => {
-        switch (e.type) {
-            case EventType.Sern:
-                return eventDispatcher(e, s);
-            case EventType.Discord:
-                return eventDispatcher(e, client);
-            case EventType.External:
-                return eventDispatcher(e, lazy(e.emitter));
-            default:
-                return err.crash(
-                    Error(SernError.InvalidModuleType + ' while creating event handler'),
-                );
-        }
-    };
-    eventCreation$
-        .pipe(
-            map(intoDispatcher),
-            /**
-             * Where all events are turned on
-             */
-            mergeAll(),
-            catchError(handleError(err, log)),
-            finalize(() => {
-                log?.info({ message: 'an event module reached end of lifetime' });
-                useContainerRaw()
-                    ?.disposeAll()
-                    .then(() => {
-                        log?.info({ message: 'Cleaning container and crashing' });
-                    });
-            }),
-        )
-        .subscribe();
-}
-
-function eventObservable(events: string, emitter: SernEmitter) {
-    return Files.buildModuleStream<EventModule>(events).pipe(
-        errTap(reason => {
-            emitter.emit('module.register', SernEmitter.failure(undefined, reason));
-        }),
-    );
-}

src/handler/id.ts

@@ -0,0 +1,50 @@
+import { Interaction, InteractionType } from 'discord.js';
+import { CommandType, EventType } from '../core';
+
+/**
+ * Construct unique ID for a given interaction object.
+ * @param event The interaction object for which to create an ID.
+ * @returns A unique string ID based on the type and properties of the interaction object.
+ */
+export function reconstructId<T extends Interaction>(event: T) {
+    switch (event.type) {
+        case InteractionType.MessageComponent: {
+            return `${event.customId}_C${event.componentType}`;
+        }
+        case InteractionType.ApplicationCommand:
+        case InteractionType.ApplicationCommandAutocomplete: {
+            return `${event.commandName}_A${event.commandType}`;
+        }
+        //Modal interactions are classified as components for sern
+        case InteractionType.ModalSubmit: {
+            return `${event.customId}_C1`;
+        }
+    }
+}
+
+const appBitField = 0b000000011111;
+/*
+ * Generates a number based on CommandType.
+ * This corresponds to an ApplicationCommandType or ComponentType
+ * TextCommands are 0 as they aren't either or.
+ */
+function apiType(t: CommandType | EventType) {
+    if (t === CommandType.Both || t === CommandType.Modal) return 1;
+    const log = Math.log2(t);
+    return (appBitField & t) !== 0 ? log : log - 2;
+}
+
+/*
+ * Generates an id based on CommandType.
+ * A is for any ApplicationCommand. C is for any ComponentCommand
+ * Then, another number generated by apiType function is appended
+ */
+function uniqueSuffix(t: CommandType | EventType) {
+    const am = (appBitField & t) !== 0 ? 'A' : 'C';
+    return am + apiType(t);
+}
+
+
+export function createId(name: string, type: CommandType | EventType) {
+    return name+"_"+uniqueSuffix(type)
+}

src/handler/module-loading/readFile.ts

@@ -1,64 +0,0 @@
-import { readdirSync, statSync } from 'fs';
-import { join } from 'path';
-import { type Observable, from, mergeMap } from 'rxjs';
-import { SernError } from '../structures/errors';
-import { type Result, Err, Ok } from 'ts-results-es';
-import { ImportPayload } from '../../types/handler';
-import { pathToFileURL } from 'node:url';
-
-// Courtesy @Townsy45
-function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
-    try {
-        const files = readdirSync(dir);
-        for (const file of files) {
-            if (statSync(dir + '/' + file).isDirectory()) readPath(dir + '/' + file, arrayOfFiles);
-            else arrayOfFiles.push(join(dir, '/', file));
-        }
-    } catch (err) {
-        throw err;
-    }
-
-    return arrayOfFiles;
-}
-export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
-// export const isLazy = (n: string) => n.indexOf(".lazy.", n.length-9) !== -1;
-
-export async function defaultModuleLoader<T>(
-    absPath: string,
-): Promise<Result<ImportPayload<T>, SernError>> {
-    // prettier-ignore
-    let module: T | undefined
-    /// #if MODE === 'esm'
-    = (await import(pathToFileURL(absPath).toString())).default
-    /// #elif MODE === 'cjs'
-    = require(absPath).default; // eslint-disable-line
-    /// #endif
-    if (module === undefined) {
-        return Err(SernError.UndefinedModule);
-    }
-    try {
-        module = new (module as unknown as new () => T)();
-    } catch {}
-    return Ok({ module, absPath });
-}
-
-/**
- * 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
- */
-export function buildModuleStream<T>(
-    commandDir: string,
-): Observable<Result<ImportPayload<T>, SernError>> {
-    const commands = getCommands(commandDir);
-    return from(commands).pipe(mergeMap(defaultModuleLoader<T>));
-}
-
-export function fullPathFrom(dir: string) {
-    return join(process.cwd(), dir);
-}
-
-export function getCommands(dir: string): string[] {
-    return readPath(fullPathFrom(dir));
-}

src/handler/plugins/index.ts

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

src/handler/sern.ts

@@ -1,23 +1,13 @@
-import type Wrapper from './structures/wrapper';
-import { makeEventsHandler } from './events/userDefinedEventsHandling';
-import { CommandType, EventType, PluginType } from './structures/enums';
-import type { AnyEventPlugin, ControlPlugin, InitPlugin, Plugin } from '../types/plugin';
-import { makeInteractionCreate } from './events/interactionHandler';
-import { makeReadyEvent } from './events/readyHandler';
-import { makeMessageCreate } from './events/messageHandler';
-import type {
-    CommandModule,
-    CommandModuleDefs,
-    EventModule,
-    EventModuleDefs,
-    InputCommand,
-    InputEvent,
-} from '../types/module';
-import type { Dependencies, DependencyConfiguration } from '../types/handler';
-import { composeRoot, makeFetcher, useContainer } from './dependencies/provider';
-import type { Logging } from './contracts';
-import { err, ok, partition } from './utilities/functions';
-import type { Awaitable, ClientEvents } from 'discord.js';
+import { makeEventsHandler } from './events/user-defined';
+import { makeInteractionHandler } from './events/interactions';
+import { startReadyEvent } from './events/ready';
+import { makeMessageHandler } from './events/messages';
+import { err, ok } from '../core/functions';
+import { getFullPathTree } from '../core/module-loading';
+import { merge } from 'rxjs';
+import { Services } from '../core/ioc';
+import { Wrapper } from '../shared';
+import { handleCrash } from './events/generic';
 
 /**
  * @since 1.0.0
@@ -26,29 +16,67 @@ import type { Awaitable, ClientEvents } from 'discord.js';
  * @example
  * ```ts title="src/index.ts"
  * Sern.init({
- *     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 requiredDependenciesAnd = makeFetcher(wrapper);
     const startTime = performance.now();
-    const { events } = wrapper;
-    if (events !== undefined) {
-        makeEventsHandler(requiredDependenciesAnd([]), events, wrapper.containerConfig);
+
+    const dependencies = useDependencies();
+    const logger = dependencies[2];
+    const errorHandler = dependencies[1];
+    const mode = debugModuleLoading(wrapper.mode ?? process.env.MODE);
+
+    if (wrapper.events !== undefined) {
+        makeEventsHandler(dependencies, getFullPathTree(wrapper.events, mode));
     }
-    const dependencies = requiredDependenciesAnd(['@sern/modules']);
-    makeReadyEvent(dependencies, wrapper.commands);
-    makeMessageCreate(dependencies, wrapper.defaultPrefix);
-    makeInteractionCreate(dependencies);
-    const endTime = performance.now();
-    logger?.info({ message: `sern : ${(endTime - startTime).toFixed(2)} ms` });
+
+    startReadyEvent(dependencies, getFullPathTree(wrapper.commands, mode))
+    .add(() => {
+        const time = ((performance.now() - startTime) / 1000).toFixed(2);
+        dependencies[0].emit('modulesLoaded' );
+        logger?.info({
+            message: `sern: registered all modules in ${time} s`,
+        });
+    });
+
+    const messages$ = makeMessageHandler(dependencies, wrapper.defaultPrefix);
+    const interactions$ = makeInteractionHandler(dependencies);
+
+    merge(messages$, interactions$)
+        .pipe(handleCrash(errorHandler, logger))
+        .subscribe();
+}
+
+function debugModuleLoading(mode: string | undefined) {
+    console.info(`Detected mode: "${mode}"`);
+    if (mode === undefined) {
+        console.info('No mode found in process.env, assuming DEV');
+    }
+    switch (mode) {
+        case 'PROD':
+            return false;
+        case 'DEV':
+        case undefined:
+            return true;
+        default: {
+            console.warn(mode + ' is not a valid. Should be PROD or DEV');
+            return false;
+        }
+    }
+}
+
+function useDependencies() {
+    return Services(
+        '@sern/emitter',
+        '@sern/errors',
+        '@sern/logger',
+        '@sern/modules',
+        '@sern/client',
+    );
 }
 
 /**
@@ -59,80 +87,3 @@ export const controller = {
     next: ok,
     stop: err,
 };
-
-/**
- * @since 1.0.0
- * The wrapper function to define command modules for sern
- * @param mod
- */
-export function commandModule(mod: InputCommand): CommandModule {
-    const [onEvent, plugins] = partition(
-        mod.plugins ?? [],
-        el => (el as Plugin).type === PluginType.Control,
-    );
-    return {
-        ...mod,
-        onEvent,
-        plugins,
-    } as CommandModule;
-}
-/**
- * @since 1.0.0
- * The wrapper function to define event modules for sern
- * @param mod
- */
-export function eventModule(mod: InputEvent): EventModule {
-    const [onEvent, plugins] = partition(
-        mod.plugins ?? [],
-        el => (el as Plugin).type === PluginType.Control,
-    );
-    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 });
-}
-/**
- * @since 2.0.0
- * @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/structures/index.ts

@@ -1,6 +0,0 @@
-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/moduleStore.ts

@@ -1,27 +0,0 @@
-import type { CommandModule } from '../../types/module';
-import { ApplicationCommandType, ComponentType } from 'discord.js';
-import type { Processed } from '../../types/handler';
-
-/**
- * @since 2.0.0
- * 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/wrapper.ts

@@ -1,16 +0,0 @@
-import type { Dependencies } from '../../types/handler';
-
-/**
- * @since 1.0.0
- * An object to be passed into Sern#init() function.
- * @typedef {object} Wrapper
- */
-interface Wrapper {
-    readonly defaultPrefix?: string;
-    readonly commands: string;
-    readonly events?: string;
-    readonly containerConfig: {
-        get: (...keys: (keyof Dependencies)[]) => unknown[];
-    };
-}
-export default Wrapper;

src/handler/types.ts

@@ -0,0 +1,24 @@
+import { ErrorHandling, Logging, ModuleManager, SernEmitter } from '../core';
+import { EventEmitter } from 'node:events';
+import { Module } from '../core/types/modules';
+
+export type Processed<T> = T & { name: string; description: string };
+
+export type DependencyList = [
+    SernEmitter,
+    ErrorHandling,
+    Logging | undefined,
+    ModuleManager,
+    EventEmitter,
+];
+
+export interface InitArgs<T extends Processed<Module>> {
+    module: T;
+    absPath: string;
+}
+
+export interface ImportPayload<T> {
+    module: T;
+    absPath: string;
+    [key: string]: unknown;
+}

src/handler/utilities/functions.ts

@@ -1,36 +0,0 @@
-import * as Files from '../module-loading/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
- * @__PURE__
- */
-// 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/index.ts

@@ -1,18 +1,11 @@
-import SernEmitter from './handler/sernEmitter';
+export * as Sern from './handler/sern';
+export * from './core';
 export {
-    eventModule,
     commandModule,
+    eventModule,
+    discordEvent,
     EventExecutable,
     CommandExecutable,
-    controller,
-    discordEvent,
-} from './handler/sern';
-export * as Sern from './handler/sern';
-export * from './types/handler';
-export * from './types/module';
-export * from './types/plugin';
-export * from './handler/structures';
-export * from './handler/plugins';
-export * from './handler/contracts';
-export { SernEmitter };
-export * from './handler/dependencies';
+} from './handler/commands';
+export { controller } from './handler/sern';
+export type { Wrapper, Args } from './shared';

src/shared.ts

@@ -0,0 +1,52 @@
+import type {
+    CommandInteractionOptionResolver,
+    InteractionReplyOptions,
+    MessageReplyOptions,
+} from 'discord.js';
+import { PayloadType } from './core';
+import { AnyModule } from './core/types/modules';
+
+export type ReplyOptions =
+    | string
+    | Omit<InteractionReplyOptions, 'fetchReply'>
+    | MessageReplyOptions;
+
+export type Payload =
+    | { type: PayloadType.Success; module: AnyModule }
+    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
+    | { type: PayloadType.Warning; reason: string };
+
+export interface SernEventsMapping {
+    'module.register': [Payload];
+    'module.activate': [Payload];
+    error: [Payload];
+    warning: [Payload];
+    'modulesLoaded': [never?];
+}
+
+export type Awaitable<T> = PromiseLike<T> | T;
+
+export interface Wrapper {
+    commands: string;
+    defaultPrefix?: string;
+    events?: string;
+    /**
+     * Overload to enable mode in case developer does not use a .env file.
+     */
+    mode?: 'DEV' | 'PROD';
+    /*
+     * @deprecated
+     */
+    containerConfig?: {
+        get: (...keys: (keyof Dependencies)[]) => unknown[];
+    };
+}
+
+// Thanks to @kelsny
+type ParseType<T> = {
+    [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
+}[keyof T];
+
+export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
+
+export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;

src/types/handler.ts

@@ -1,71 +0,0 @@
-import type { CommandInteractionOptionResolver } from 'discord.js';
-import type { PayloadType } from '../handler/structures/enums';
-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;
-}[keyof T];
-
-export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
-
-export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
-
-/**
- * After modules are transformed, name and description are given default values if none
- * are provided to Module. This type represents that transformation
- */
-export type AnyDefinedModule = Processed<CommandModule | EventModule>;
-export type Payload =
-    | { type: PayloadType.Success; module: AnyModule }
-    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
-    | { type: PayloadType.Warning; reason: string };
-export type SernEventsMapping = {
-    'module.register': [Payload];
-    'module.activate': [Payload];
-    error: [Payload];
-    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, {}>;
-}
-
-export type ImportPayload<T> = { module: T; absPath: string };

src/types/plugin.ts

@@ -1,74 +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 { 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: '>;

test/core/contracts.test.ts

@@ -0,0 +1,14 @@
+import { assertType, describe, it, vi } from "vitest";
+import * as DefaultContracts from '../../src/core/structures/services'
+import * as Contracts from '../../src/core/contracts/index.js'
+import { ModuleStore } from "../../src/core";
+
+describe('default contracts', () => {
+    it('should satisfy contracts', () => {
+        assertType<Contracts.Logging>(new DefaultContracts.DefaultLogging())
+        assertType<Contracts.ErrorHandling>(new DefaultContracts.DefaultErrorHandling())
+        assertType<Contracts.ModuleManager>(new DefaultContracts.DefaultModuleManager(new ModuleStore()))
+        assertType<Contracts.CoreModuleStore>(new ModuleStore())
+    })
+
+})

test/core/create-plugin.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest'
+import { CommandControlPlugin, CommandInitPlugin, EventControlPlugin, EventInitPlugin } from '../../src/core/create-plugins'
+import { PluginType, controller } from '../../src/index'
+
+describe('create-plugins', () => {
+    it('should make proper control plugins', () => {
+        const pl = EventControlPlugin(() => controller.next())
+        expect(pl)
+            .to.have.all.keys(['type', 'execute']) 
+        expect(pl.type).toBe(PluginType.Control)
+        expect(pl.execute).an('function')            
+        const pl2 = CommandControlPlugin(() => controller.next())
+        expect(pl2)
+            .to.have.all.keys(['type', 'execute']) 
+        expect(pl2.type).toBe(PluginType.Control)
+        expect(pl2.execute).an('function')            
+
+    })
+    it('should make proper init plugins', () => {
+        const pl = EventInitPlugin(() => controller.next())
+        expect(pl)
+            .to.have.all.keys(['type', 'execute']) 
+        expect(pl.type).toBe(PluginType.Init)
+        expect(pl.execute).an('function')
+
+        const pl2 = CommandInitPlugin(() => controller.next())
+        expect(pl2)
+            .to.have.all.keys(['type', 'execute']) 
+        expect(pl2.type).toBe(PluginType.Init)
+        expect(pl2.execute).an('function')   
+    })
+   
+
+})
+

test/core/functions.test.ts

@@ -0,0 +1,208 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { PluginType, SernOptionsData, controller } from '../../src/index'
+import { partitionPlugins, treeSearch } from "../../src/core/functions";
+import { faker } from '@faker-js/faker';
+import { ApplicationCommandOptionType, AutocompleteInteraction } from "discord.js";
+
+vi.mock('discord.js', () => {
+
+        const Collection = Map
+        const ModalSubmitInteraction = class {
+            customId
+            type = 5
+            isModalSubmit = vi.fn()
+            constructor(customId) {
+                this.customId = customId
+            }
+        }
+        const ButtonInteraction = class {
+            customId
+            type = 3
+            componentType = 2
+            isButton = vi.fn()
+            constructor(customId) {
+                this.customId = customId
+            }
+        }
+        const AutocompleteInteraction = class {
+            type = 4;
+            option: string
+            constructor(s: string) {
+                this.option = s;
+            }
+            options = {
+               getFocused : vi.fn()
+            }
+        }
+
+        return {
+            Collection,
+            ComponentType: { 
+                Button: 2
+            },
+            InteractionType : {
+                Ping: 1,
+                ApplicationCommand: 2,
+                MessageComponent: 3,
+                ApplicationCommandAutocomplete:4,
+                ModalSubmit: 5
+            },
+            ApplicationCommandOptionType : {
+               Subcommand : 1,
+               SubcommandGroup : 2,
+               String : 3,
+               Integer : 4,
+               Boolean : 5,
+               User : 6,
+               Channel : 7,
+               Role : 8,
+               Mentionable : 9,
+               Number : 10,
+               Attachment : 11
+            },
+            ModalSubmitInteraction,
+            ButtonInteraction,
+            AutocompleteInteraction
+        };
+})
+
+describe('functions', () => { 
+    afterEach(() => {  vi.clearAllMocks() })
+    function createRandomPlugins(len: number) {
+        const random = () => Math.floor(Math.random()*2)+1; // 1 or 2, plugin enum
+        return Array.from({ length: len }, () => ({ type: random(), execute: () => random() === 1 ? controller.next():controller.stop() }))
+    }
+    function createRandomChoice() {
+        return {
+            type: faker.number.int({ min: 1, max: 11}),
+            name: faker.word.noun(),
+            description: faker.word.adjective(),
+        }  
+    }
+    it('should partition plugins correctly', () => {
+         const plugins = createRandomPlugins(100); 
+         const [ onEvent, init ] = partitionPlugins(plugins)
+         for(const el of onEvent) 
+            expect(el.type).to.equal(PluginType.Control)
+         
+         for(const el of init) 
+            expect(el.type).to.equal(PluginType.Init)
+    })
+    
+    it('should tree search options tree depth 1', () => {
+        //@ts-expect-error mocking
+        let autocmpInteraction = new AutocompleteInteraction('autocomplete');
+        const options : SernOptionsData[] = [
+            createRandomChoice(),
+            createRandomChoice(),
+            createRandomChoice(),
+            { 
+              type: ApplicationCommandOptionType.String,
+              name: 'autocomplete',
+              description: 'here',
+              autocomplete: true,
+              command : { onEvent: [], execute:(a) => {} } 
+            }
+        ];
+        autocmpInteraction.options.getFocused.mockReturnValue(
+            {
+                name: 'autocomplete',
+                value: faker.string.alpha(),
+                focused: true
+            },
+        );
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result == undefined).to.be.false;
+        expect(result.name).to.be.eq('autocomplete');
+        expect(result.command).to.be.not.undefined;
+
+    }),
+    it('should tree search depth 2', () => {
+        //@ts-expect-error mocking
+        let autocmpInteraction = new AutocompleteInteraction('nested');
+        const options : SernOptionsData[] = [
+            {
+                type: ApplicationCommandOptionType.Subcommand,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                   createRandomChoice(),
+                   createRandomChoice(),
+                   createRandomChoice(),
+                   {
+                    type: ApplicationCommandOptionType.String,
+                    name: 'nested',
+                    description: faker.string.alpha(),
+                    autocomplete: true,
+                    command: {
+                        onEvent: [],
+                        execute:() => {}
+                    }
+                   }
+                ]
+            }
+            
+        ];
+        autocmpInteraction.options.getFocused.mockReturnValue(
+            {
+                name: 'nested',
+                value: faker.string.alpha(),
+                focused: true
+            }
+        );
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result == undefined).to.be.false;
+        expect(result.name).to.be.eq('nested');
+        expect(result.command).to.be.not.undefined;
+
+    })
+
+    it('should tree search depth n > 2', () => {
+        //@ts-expect-error mocking
+        let autocmpInteraction = new AutocompleteInteraction('nested');
+        const options : SernOptionsData[] = [
+            {
+                
+                type: ApplicationCommandOptionType.SubcommandGroup,
+                name: faker.string.alpha(),
+                description: faker.string.alpha(),
+                options: [
+                {
+                    type: ApplicationCommandOptionType.Subcommand,
+                    name: faker.string.alpha(),
+                    description: faker.string.alpha(),
+                    options: [
+                       createRandomChoice(),
+                       createRandomChoice(),
+                       createRandomChoice(),
+                       {
+                        type: ApplicationCommandOptionType.String,
+                        name: 'nested',
+                        description: faker.string.alpha(),
+                        autocomplete: true,
+                        command: {
+                            onEvent: [],
+                            execute:() => {}
+                        }
+                        }
+                    ]
+                }]
+            },
+        ];
+        autocmpInteraction.options.getFocused.mockReturnValue(
+            {
+                name: 'nested',
+                value: faker.string.alpha(),
+                focused: true
+            }
+        );
+        const result = treeSearch(autocmpInteraction, options);
+        expect(result == undefined).to.be.false;
+        expect(result.name).to.be.eq('nested');
+        expect(result.command).to.be.not.undefined;
+    })
+
+
+})
+
+

test/core/ioc.test.ts

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CoreContainer } from '../../src/core/structures/container'
+import { CoreDependencies } from "../../src/core/ioc";
+import { EventEmitter } from "events";
+import { DefaultLogging, Init, Logging } from "../../src/core";
+
+
+describe('ioc container', () => {
+    let container: CoreContainer<{}>; 
+    let initDependency: Logging & Init;
+    beforeEach(() => {
+        initDependency = {
+            init: vi.fn(),
+            error(): void {},
+            warning(): void {},
+            info(): void {},
+            debug(): void {},
+        }
+        container = new CoreContainer() 
+
+    })
+    
+    it('should be ready after calling container.ready()', () => {
+        container.ready()
+        expect(container.isReady()).toBe(true)
+    })
+    it('should container all core dependencies', async  () => {
+        const keys = ['@sern/modules', '@sern/emitter', '@sern/logger', '@sern/errors'] satisfies (keyof CoreDependencies)[]
+        container.add({
+            '@sern/logger': () => new DefaultLogging(),
+            '@sern/client': () => new EventEmitter(),
+        })
+        for(const k of keys) {
+            //@ts-expect-error typings for iti are strict
+            expect(() => container.get(k)).not.toThrow();
+        }
+    })
+    it('should init modules', () => {
+        container.upsert({ '@sern/logger': initDependency })
+        container.ready()
+        expect(initDependency.init).to.toHaveBeenCalledOnce() 
+    })
+
+    it('should not lazy module', () => {
+        container.upsert({ '@sern/logger': () => initDependency })
+        container.ready()
+        expect(initDependency.init).toHaveBeenCalledTimes(0);
+    })
+
+    
+    
+})

test/core/services.test.ts

@@ -0,0 +1,80 @@
+import { SpyInstance, afterAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { CoreContainer } from '../../src/core/structures/container'
+import { DefaultLogging } from "../../src/core";
+import { faker } from '@faker-js/faker'
+import { commandModule } from "../../src";
+import { createId } from '../../src/handler/id'
+import { CommandMeta } from "../../src/core/types/modules";
+
+describe('services', () => {
+    //@ts-ignore
+    let container: CoreContainer<Dependencies>; 
+    let consoleMock : SpyInstance;   
+    beforeEach(() => {
+        container = new CoreContainer() 
+        container.add({ '@sern/logger': () => new DefaultLogging() })
+        container.ready()
+        consoleMock = vi.spyOn(container.get('@sern/logger'), 'error').mockImplementation(() => {})
+    })
+    
+    afterAll(() => {
+        consoleMock.mockReset()
+    });
+    it('module-store.ts', async () => {
+       function createRandomCommandModules() {
+            return commandModule({
+                type: faker.number.int({ min: 1<<0, max: 1<<10 }),
+                description: faker.string.alpha(),
+                name: faker.string.alpha(),
+                execute: ()=>{}
+            })
+       }
+
+       const modules = faker.helpers.multiple(createRandomCommandModules, { count: 40 })
+      
+       const paths =  faker.helpers.multiple(faker.system.directoryPath, { count: 40 })
+        .map((path,i) => `${path}/${modules[i]}.js`);
+
+       const metadata: CommandMeta[] = modules.map((cm, i) => ({
+           id: createId(cm.name, cm.type),
+           isClass: false,
+           fullPath: `${paths[i]}/${cm.name}.js` 
+       }));
+       const moduleManager = container.get('@sern/modules');
+       let i =0;
+       for(const m of modules) {
+        moduleManager.set(createId(m.name,m.type), paths[i]);
+        moduleManager.setMetadata(m, metadata[i]);
+        i++
+      }
+      for(const m of modules) {
+        expect(moduleManager.getMetadata(m), "module references do not exist").toBeDefined() 
+      }
+       
+    })
+
+    //todo add more
+    it('error-handling', () => {
+        const errorHandler = container.get('@sern/errors');
+        const lifetime = errorHandler.keepAlive;
+        for(let i = 0; i< lifetime; i++) {
+            if(i == lifetime-1) {
+                expect(() => errorHandler.updateAlive(new Error("poo"))).toThrowError();
+            } else {
+                expect(() => errorHandler.updateAlive(new Error("poo"))).not.toThrowError();
+            }
+        }
+        
+    })
+    //todo add more, spy on every instance?
+    it('logger', () => {
+
+        container.get('@sern/logger').error({ message: 'error' })
+
+        expect(consoleMock).toHaveBeenCalledOnce();
+        expect(consoleMock).toHaveBeenLastCalledWith({ message: 'error' })
+    })
+
+    
+    
+})

tsconfig-base.json

@@ -11,8 +11,9 @@
         "declaration": true,
         "preserveSymlinks": true,
         "allowSyntheticDefaultImports": true,
-        "forceConsistentCasingInFileNames": true
+        "forceConsistentCasingInFileNames": true,
+        "isolatedModules": true
     },
     "exclude": ["node_modules", "dist"],
-    "include": ["src"]
+    "include": ["./src", "./src/**/*.d.ts"]
 }

tsup.config.js

@@ -3,18 +3,24 @@ import { writeFile } from 'fs/promises';
 import ifdefPlugin from 'esbuild-ifdef';
 const shared = {
     entry: ['src/index.ts'],
-    external: ['discord.js'],
+    external: ['discord.js', 'iti'],
     platform: 'node',
     clean: true,
     sourcemap: false,
+    treeshake: {
+        moduleSideEffects: false,
+        correctVarValueBeforeDeclaration: true, //need this to treeshake esm discord.js empty import
+        annotations: true,
+    },
+    dts: false,
 };
 export default defineConfig([
     {
         format: 'esm',
-        target: 'node16',
+        target: 'node18',
         tsconfig: './tsconfig-esm.json',
         outDir: './dist/esm',
-        treeshake: true,
+        splitting: true,
         esbuildPlugins: [ifdefPlugin({ variables: { MODE: 'esm' }, verbose: true })],
         outExtension() {
             return {
@@ -31,7 +37,7 @@ export default defineConfig([
         format: 'cjs',
         esbuildPlugins: [ifdefPlugin({ variables: { MODE: 'cjs' }, verbose: true })],
         splitting: false,
-        target: 'node16',
+        target: 'node18',
         tsconfig: './tsconfig-cjs.json',
         outDir: './dist/cjs',
         outExtension() {
@@ -45,4 +51,11 @@ export default defineConfig([
         },
         ...shared,
     },
+    {
+        dts: {
+            only: true,
+        },
+        entry: ['src/index.ts'],
+        outDir: 'dist',
+    },
 ]);