chore(main): release 3.1.1 (#338)

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

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: sern

.github/workflows/codeql-analysis.yml

@@ -1,39 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ main ]
-    paths: ["src/**/*"]
-  pull_request:
-    branches: [ main ]
-    paths: ["src/**/*"]
-  schedule:
-    - cron: '37 20 * * 4'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-    permissions:
-      actions: read
-      contents: read
-      security-events: write
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'javascript' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v3
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@v2
-      with:
-        languages: ${{ matrix.language }}
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@v2
-
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v2

.github/workflows/continuous-integration.yml

@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - name: Check out Git repository
-        uses: actions/checkout@c85c95e3d7251135ab7dc9ce3241c5835cc595a9 # v3
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
 
       - name: Set up Node.js
         uses: actions/setup-node@64ed1c7eab4cce3362f8c340dee64e5eaeef8f7c # v3
@@ -39,7 +39,7 @@ jobs:
 
       - name: Create Pull Request
         id: cpr
-        uses: peter-evans/create-pull-request@v4
+        uses: peter-evans/create-pull-request@38e0b6e68b4c852a5500a94740f0e535e0d7ba54 # v4
         with:
           commit-message: "style: pretty please"
           branch: prettier

.github/workflows/dependency-review.yml

@@ -15,6 +15,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: 'Checkout Repository'
-        uses: actions/checkout@v3
+        uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
       - name: 'Dependency Review'
-        uses: actions/dependency-review-action@v2
+        uses: actions/dependency-review-action@0efb1d1d84fc9633afcdaad14c485cbbc90ef46c # v2

.github/workflows/npm-publish.yml

@@ -2,17 +2,21 @@ name: NPM / Publish
 
 on:
   workflow_dispatch:
+  # We only publish if the version of sern handler is different. workflow automatically cancels if verson is the same
+  push:
+    branches:
+      - 'main'
 jobs:
   test-and-publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+      - uses: actions/setup-node@5e21ff4d9bc1a8cf6de233a3057d20ec6b3fb69d # v3
         with:
           node-version: 17
       - run: yarn --immutable
       - run: yarn build:prod
-      - uses: JS-DevTools/npm-publish@v1
+      - uses: JS-DevTools/npm-publish@0f451a94170d1699fd50710966d48fb26194d939 # v1
         with:
           token: ${{ secrets.NPM_TOKEN }}
           access: "public"

.github/workflows/release-please.yml

@@ -6,7 +6,7 @@ jobs:
     release-please:
       runs-on: ubuntu-latest
       steps:
-        - uses: google-github-actions/release-please-action@v3
+        - uses: google-github-actions/release-please-action@4c5670f886fe259db4d11222f7dff41c1382304d # v3
           with:
             release-type: node
             package-name: release-please-action

.github/workflows/test.yml

@@ -0,0 +1,29 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [18.x, 19.x, 20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@5e21ff4d9bc1a8cf6de233a3057d20ec6b3fb69d # v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm install -g yarn
+    - run: yarn install
+    - run: yarn test

.gitignore

@@ -91,3 +91,9 @@ dist
 # Yarn files
 .yarn/install-state.gz
 .yarn/build-state.yml
+
+.yalc
+
+yalc.lock
+
+*.svg

CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [3.1.1](https://github.com/sern-handler/handler/compare/v3.1.0...v3.1.1) (2023-11-06)
+
+
+### Bug Fixes
+
+* queuing events ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
+* queuing events ([#332](https://github.com/sern-handler/handler/issues/332)) @Benzo-Fury ([#333](https://github.com/sern-handler/handler/issues/333)) ([fd39858](https://github.com/sern-handler/handler/commit/fd39858636d3038abb6d91021b65c99c488a3d6e))
+
+## [3.1.0](https://github.com/sern-handler/handler/compare/v3.0.2...v3.1.0) (2023-09-04)
+
+
+### Features
+
+* add guaranteed `channelId` and `userId` getters to `Context` ([#320](https://github.com/sern-handler/handler/issues/320)) ([50253ca](https://github.com/sern-handler/handler/commit/50253ca322e7d6dbd2313139c0187a1028f71109))
+* dispose hooks (deprecate useContainerRaw) ([#323](https://github.com/sern-handler/handler/issues/323)) ([26ccd11](https://github.com/sern-handler/handler/commit/26ccd118ff8cbcde94158a4d09fc0df18da9f254))
+
+## [3.0.2](https://github.com/sern-handler/handler/compare/v3.0.1...v3.0.2) (2023-08-06)
+
+
+### Bug Fixes
+
+* invalid id for cts, mts, cjs, mjs files, node paths ([#318](https://github.com/sern-handler/handler/issues/318)) ([a7f5ea2](https://github.com/sern-handler/handler/commit/a7f5ea269fb344e221d10dbdc26a1611ffc8138f))
+
 ## [3.0.1](https://github.com/sern-handler/handler/compare/v3.0.0...v3.0.1) (2023-08-05)
 
 

README.md

@@ -18,10 +18,9 @@
 - For you. A framework that's tailored to your exact needs.
 - Lightweight. Does a lot while being small.
 - Latest features. Support for discord.js v14 and all of its interactions.
-- Hybrid, customizable and composable commands. Create them just how you like.
 - Start quickly. Plug and play or customize to your liking.
-- Embraces reactive programming. For consistent and reliable backend.
 - Switch and customize how errors are handled, logging, and more.
+- works with [bun](https://bun.sh/) and [node](https://nodejs.org/en) out the box!
 - Use it with TypeScript or JavaScript. CommonJS and ESM supported.
 - Active and growing community, always here to help. [Join us](https://sern.dev/discord)
 - Unleash its full potential with a powerful CLI and awesome plugins.
@@ -77,16 +76,14 @@ export default commandModule({
 </details>
 <details open><summary>index.ts</summary>
 
-```ts
+	
+```ts 
 import { Client, GatewayIntentBits } from 'discord.js';
-import { Sern, single, type Dependencies } from '@sern/handler';
+import { Sern, single } from '@sern/handler';
 
 //client has been declared previously
-
-interface MyDependencies extends Dependencies {
-    '@sern/client': Singleton<Client>;
-}
-export const useContainer = Sern.makeDependencies<MyDependencies>({
+//Version 3
+await makeDependencies({
     build: root => root
         .add({ '@sern/client': single(() => client)  })
 });
@@ -96,9 +93,6 @@ Sern.init({
 	defaultPrefix: '!', // removing defaultPrefix will shut down text commands
 	commands: 'src/commands',
 	// events: 'src/events' (optional),
-	containerConfig : {
-	    get: useContainer
-	}
 });
 
 client.login("YOUR_BOT_TOKEN_HERE");

package.json

@@ -1,10 +1,10 @@
 {
     "name": "@sern/handler",
     "packageManager": "yarn@3.5.0",
-    "version": "3.0.1",
+    "version": "3.1.1",
     "description": "A complete, customizable, typesafe, & reactive framework for discord bots.",
     "main": "./dist/index.js",
-    "module": "./dist/cjs/index.cjs",
+    "module": "./dist/index.mjs",
     "types": "./dist/index.d.ts",
     "exports": {
         ".": {
@@ -19,7 +19,7 @@
         "lint": "eslint src/**/*.ts",
         "format": "eslint src/**/*.ts --fix",
         "build:dev": "tsup --metafile",
-        "build:prod": "tsup --minify",
+        "build:prod": "tsup ",
         "prepare": "npm run build:prod",
         "pretty": "prettier --write .",
         "tdd": "vitest",
@@ -40,7 +40,7 @@
     "dependencies": {
         "iti": "^0.6.0",
         "rxjs": "^7.8.0",
-        "ts-results-es": "latest"
+        "ts-results-es": "^4.0.0"
     },
     "devDependencies": {
         "@faker-js/faker": "^8.0.1",

src/core/_internal.ts

@@ -7,3 +7,4 @@ export type { VoidResult } from '../types/core-plugin';
 export { SernError } from './structures/enums';
 export { ModuleStore } from './structures/module-store';
 export * as DefaultServices from './structures/services';
+export { useContainerRaw } from './ioc/base'

src/core/contracts/disposable.ts

@@ -0,0 +1,9 @@
+import type { Awaitable } from '../../types/utility';
+
+/**
+ * Represents a Disposable contract.
+ * Let dependencies implement this to dispose and cleanup.
+ */
+export interface Disposable {
+    dispose(): Awaitable<unknown>;
+}

src/core/contracts/index.ts

@@ -4,3 +4,4 @@ export * from './module-manager';
 export * from './module-store';
 export * from './init';
 export * from './emitter';
+export * from './disposable'

src/core/ioc/base.ts

@@ -7,8 +7,10 @@ import { CoreContainer } from './container';
 let containerSubject: CoreContainer<Partial<Dependencies>>;
 
 /**
+ * @deprecated
  * Returns the underlying data structure holding all dependencies.
  * Exposes methods from iti
+ * Use the Service API. The container should be readonly
  */
 export function useContainerRaw() {
     assert.ok(

src/core/ioc/container.ts

@@ -1,22 +1,24 @@
 import { Container } from 'iti';
-import { SernEmitter } from '../';
-import { isAsyncFunction } from 'node:util/types';
-
+import { Disposable, SernEmitter } from '../';
 import * as assert from 'node:assert';
 import { Subject } from 'rxjs';
 import { DefaultServices, ModuleStore } from '../_internal';
+import * as Hooks from './hooks'
+
 
 /**
- * Provides all the defaults for sern to function properly.
- * The only user provided dependency needs to be @sern/client
+ * A semi-generic container that provides error handling, emitter, and module store. 
+ * For the handler to operate correctly, 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>();
-    private beenCalled = new Set<PropertyKey>();
+    private ready$ = new Subject<void>();
     constructor() {
         super();
+        assert.ok(!this.isReady(), 'Listening for dispose & init should occur prior to sern being ready.');
 
-        this.listenForInsertions();
+        const { unsubscribe } = Hooks.createInitListener(this);
+        this.ready$
+            .subscribe({ complete: unsubscribe });
 
         (this as Container<{}, {}>)
             .add({
@@ -32,36 +34,27 @@ export class CoreContainer<T extends Partial<Dependencies>> extends Container<T,
             });
     }
 
-    private listenForInsertions() {
-        assert.ok(
-            !this.isReady(),
-            'listening for init functions should only occur prior to sern being ready.',
-        );
-        const unsubscriber = this.on('containerUpserted', e => this.callInitHooks(e));
-
-        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' && !this.beenCalled.has(e.key)) {
-            isAsyncFunction(dep.init) ? await dep.init() : dep.init();
-            this.beenCalled.add(e.key);
-        }
-    }
 
     isReady() {
+
         return this.ready$.closed;
     }
+    override async disposeAll() {
+        
+        const otherDisposables = Object
+            .entries(this._context)
+            .flatMap(([key, value]) => 
+                'dispose' in value
+                    ? [key]
+                    : []);
+
+        for(const key of otherDisposables) {
+            this.addDisposer({ [key]: (dep: Disposable) => dep.dispose() } as never);
+        }
+        await super.disposeAll() 
+    }
     ready() {
+        this.ready$.complete();
         this.ready$.unsubscribe();
     }
 }

src/core/ioc/dependency-injection.ts

@@ -1,5 +1,5 @@
 import type { CoreDependencies, DependencyConfiguration, IntoDependencies } from '../../types/ioc';
-import { SernError, DefaultServices } from '../_internal';
+import { DefaultServices } from '../_internal';
 import { useContainerRaw } from './base';
 import { CoreContainer } from './container';
 
@@ -66,12 +66,7 @@ export async function composeRoot(
     }
     //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.' });
     }

src/core/ioc/hooks.ts

@@ -0,0 +1,40 @@
+import type { CoreContainer } from "./container"
+
+interface HookEvent { 
+    key : PropertyKey
+    newContainer: any
+}
+type HookName = 'init';
+
+export const createInitListener = (coreContainer : CoreContainer<any>) => {
+    const initCalled = new Set<PropertyKey>();
+    const hasCallableMethod = createPredicate(initCalled);
+    const unsubscribe = coreContainer.on('containerUpserted', async (event) => {
+       
+        if(isNotHookable(event)) {
+            return;
+        }
+
+        if(hasCallableMethod('init', event)) {
+            await event.newContainer?.init();
+            initCalled.add(event.key);
+        }
+
+    });
+    return { unsubscribe };
+}
+
+const isNotHookable = (hk: HookEvent) => {
+    return typeof hk.newContainer !== 'object' 
+        || Array.isArray(hk.newContainer) 
+        || hk.newContainer === null;
+}
+
+const createPredicate = <T extends HookEvent>(called: Set<PropertyKey>) => {
+    return (hookName: HookName, event: T) => {
+        const hasMethod = Reflect.has(event.newContainer!, hookName);
+        const beenCalledOnce = !called.has(event.key)
+
+        return hasMethod && beenCalledOnce
+    }
+}

src/core/ioc/index.ts

@@ -1,2 +1,2 @@
-export { useContainerRaw, makeDependencies } from './base';
+export { makeDependencies } from './base';
 export { Service, Services, single, transient } from './dependency-injection';

src/core/module-loading.ts

@@ -1,7 +1,7 @@
 import { Result } from 'ts-results-es';
 import { type Observable, from, mergeMap, ObservableInput } from 'rxjs';
 import { readdir, stat } from 'fs/promises';
-import { basename, extname, join, resolve } from 'path';
+import { basename, extname, join, resolve, parse } from 'path';
 import assert from 'assert';
 import { createRequire } from 'node:module';
 import type { ImportPayload, Wrapper } from '../types/core';
@@ -25,27 +25,22 @@ export type ModuleResult<T> = Promise<ImportPayload<T>>;
 export async function importModule<T>(absPath: string) {
     let module = await import(absPath).then(esm => esm.default);
 
-    assert(
-        module,
-        'Found no default export for command module at ' +
-            absPath +
-            'Forgot to ignore with "!"? (!filename.ts)?',
-    );
+    assert(module, `Found no export for module at ${absPath}. Forgot to ignore with "!"? (!${basename(absPath)})?`);
     if ('default' in module) {
         module = module.default;
     }
-    return Result.wrap(() => module.getInstance()).unwrapOr(module) as T;
+    return Result
+        .wrap(() => module.getInstance())
+        .unwrapOr(module) as T;
 }
+
 export async function defaultModuleLoader<T extends Module>(absPath: string): ModuleResult<T> {
     let module = await importModule<T>(absPath);
-    assert.ok(
-        module,
-        "Found an undefined module. Forgot to ignore it with a '!' ie (!filename.ts)?",
-    );
+    assert(module, `Found an undefined module: ${absPath}`);
     return { module, absPath };
 }
 
-export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
+export const fmtFileName = (fileName: string) => parse(fileName).name;
 
 /**
  * a directory string is converted into a stream of modules.
@@ -59,7 +54,7 @@ export function buildModuleStream<T extends Module>(
     return from(input).pipe(mergeMap(defaultModuleLoader<T>));
 }
 
-export const getFullPathTree = (dir: string, mode: boolean) => readPaths(resolve(dir), mode);
+export const getFullPathTree = (dir: string) => readPaths(resolve(dir));
 
 export const filename = (path: string) => fmtFileName(basename(path));
 
@@ -76,22 +71,18 @@ async function deriveFileInfo(dir: string, file: string) {
         base: basename(file),
     };
 }
-async function* readPaths(dir: string, shouldDebug: boolean): AsyncGenerator<string> {
+async function* readPaths(dir: string): AsyncGenerator<string> {
     try {
         const files = await readdir(dir);
         for (const file of files) {
             const { fullPath, fileStats, base } = await deriveFileInfo(dir, file);
             if (fileStats.isDirectory()) {
                 //Todo: refactor so that i dont repeat myself for files (line 71)
-                if (isSkippable(base)) {
-                    if (shouldDebug) console.info(`ignored directory: ${fullPath}`);
-                } else {
-                    yield* readPaths(fullPath, shouldDebug);
+                if (!isSkippable(base)) {
+                    yield* readPaths(fullPath);
                 }
             } else {
-                if (isSkippable(base)) {
-                    if (shouldDebug) console.info(`ignored: ${fullPath}`);
-                } else {
+                if (!isSkippable(base)) {
                     yield 'file:///' + fullPath;
                 }
             }
@@ -104,38 +95,30 @@ async function* readPaths(dir: string, shouldDebug: boolean): AsyncGenerator<str
 const requir = createRequire(import.meta.url);
 
 export function loadConfig(wrapper: Wrapper | 'file'): Wrapper {
-    if (wrapper === 'file') {
-        console.log('Experimental loading of sern.config.json');
-        const config = requir(resolve('sern.config.json')) as {
-            language: string;
-            defaultPrefix?: string;
-            mode?: 'PROD' | 'DEV';
-            paths: {
-                base: string;
-                commands: string;
-                events?: string;
-            };
-        };
-        const makePath = (dir: keyof typeof config.paths) =>
-            config.language === 'typescript'
-                ? join('dist', config.paths[dir]!)
-                : join(config.paths[dir]!);
-
-        console.log('Loading config: ', config);
-        const commandsPath = makePath('commands');
-
-        console.log('Commands path is set to', commandsPath);
-        let eventsPath: string | undefined;
-        if (config.paths.events) {
-            eventsPath = makePath('events');
-            console.log('Events path is set to', eventsPath);
-        }
-        return {
-            defaultPrefix: config.defaultPrefix,
-            commands: commandsPath,
-            events: eventsPath,
-            mode: config.mode,
-        };
+    if (wrapper !== 'file') {
+        return wrapper;
     }
-    return wrapper;
+    console.log('Experimental loading of sern.config.json');
+    const config = requir(resolve('sern.config.json')); 
+
+    const makePath = (dir: PropertyKey) =>
+        config.language === 'typescript'
+            ? join('dist', config.paths[dir]!)
+            : join(config.paths[dir]!);
+ 
+    console.log('Loading config: ', config);
+    const commandsPath = makePath('commands');
+ 
+    console.log('Commands path is set to', commandsPath);
+    let eventsPath: string | undefined;
+    if (config.paths.events) {
+        eventsPath = makePath('events');
+        console.log('Events path is set to', eventsPath);
+    }
+    return {
+        defaultPrefix: config.defaultPrefix,
+        commands: commandsPath,
+        events: eventsPath,
+    };
+    
 }

src/core/operators.ts

@@ -52,7 +52,7 @@ export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]
  * Checks if the stream of results is all ok.
  */
 export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
-    every(result => result.ok),
+    every(result => result.isOk()),
     defaultIfEmpty(true),
 );
 
@@ -74,10 +74,10 @@ export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
 export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
     pipe(
         concatMap(result => {
-            if(result.ok) {
-                return of(result.val)
+            if(result.isOk()) {
+                return of(result.value)
             }
-            onErr(result.val);
+            onErr(result.error);
             return EMPTY
 
         })

src/core/structures/context.ts

@@ -31,44 +31,73 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
     }
 
     public get id(): Snowflake {
-        return this.ctx.val.id;
+        return safeUnwrap(this.ctx
+                            .map(m => m.id)
+                            .mapErr(i => i.id));
     }
 
     public get channel() {
-        return this.ctx.val.channel;
+        return safeUnwrap(this.ctx
+                            .map(m => m.channel)
+                            .mapErr(i => i.channel));
     }
+
+    public get channelId(): Snowflake {
+        return safeUnwrap(this.ctx
+                            .map(m => m.channelId)
+                            .mapErr(i => i.channelId));
+    }
+    
     /**
      * If context is holding a message, message.author
      * else, interaction.user
      */
     public get user(): User {
-        return safeUnwrap(this.ctx.map(m => m.author).mapErr(i => i.user));
+        return safeUnwrap(this.ctx
+                            .map(m => m.author)
+                            .mapErr(i => i.user));
+    }
+
+    public get userId(): Snowflake {
+        return this.user.id;
     }
 
     public get createdTimestamp(): number {
-        return this.ctx.val.createdTimestamp;
+        return safeUnwrap(this.ctx 
+                            .map(m => m.createdTimestamp)
+                            .mapErr(i => i.createdTimestamp));
     }
 
     public get guild() {
-        return this.ctx.val.guild;
+        return safeUnwrap(this.ctx
+                            .map(m => m.guild)
+                            .mapErr(i => i.guild));
     }
 
     public get guildId() {
-        return this.ctx.val.guildId;
+        return safeUnwrap(this.ctx
+                            .map(m => m.guildId)
+                            .mapErr(i => i.guildId));
     }
     /*
      * interactions can return APIGuildMember if the guild it is emitted from is not cached
      */
     public get member() {
-        return this.ctx.val.member;
+        return safeUnwrap(this.ctx
+                            .map(m => m.member)
+                            .mapErr(i => i.member));
     }
 
     public get client(): Client {
-        return this.ctx.val.client;
+        return safeUnwrap(this.ctx
+                            .map(m => m.client)
+                            .mapErr(i => i.client));
     }
 
     public get inGuild(): boolean {
-        return this.ctx.val.inGuild();
+        return safeUnwrap(this.ctx
+                            .map(m => m.inGuild())
+                            .mapErr(i => i.inGuild()));
     }
 
     public async reply(content: ReplyOptions) {
@@ -91,5 +120,8 @@ export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
 }
 
 function safeUnwrap<T>(res: Result<T, T>) {
-    return res.val;
+    if(res.isOk()) {
+        return res.expect("Tried unwrapping message field: " + res)
+    } 
+    return res.expectErr("Tried unwrapping interaction field" + res)
 }

src/core/structures/core-context.ts

@@ -7,7 +7,7 @@ import * as assert from 'node:assert';
  */
 export abstract class CoreContext<M, I> {
     protected constructor(protected ctx: Either<M, I>) {
-        assert.ok(typeof ctx.val === 'object' && ctx.val != null);
+        assert.ok(typeof ctx === 'object' && ctx != null);
     }
     get message(): M {
         return this.ctx.expect(SernError.MismatchEvent);
@@ -17,7 +17,7 @@ export abstract class CoreContext<M, I> {
     }
 
     public isMessage(): this is CoreContext<M, never> {
-        return this.ctx.ok;
+        return this.ctx.isOk();
     }
 
     public isSlash(): this is CoreContext<never, I> {

src/handlers/dispatchers.ts

@@ -14,23 +14,6 @@ import { CommandType, Context } from '../core';
 import type { Args } from '../types/utility';
 import type { BothCommand, CommandModule, Module, Processed } from '../types/core-modules';
 
-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;
@@ -52,9 +35,6 @@ export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?:
     return [ctx, args] as [Context, Args];
 }
 
-function interactionArg<T extends BaseInteraction>(interaction: T) {
-    return [interaction] as [T];
-}
 
 function intoPayload(module: Processed<Module>) {
     return pipe(
@@ -109,9 +89,14 @@ export function createDispatcher(payload: {
                  */
                 return dispatchAutocomplete(payload as never);
             }
-            return dispatchInteraction(payload, contextArgs);
+            return {
+                module: payload.module,
+                args: contextArgs(payload.event),
+            };
         }
-        default:
-            return dispatchInteraction(payload, interactionArg);
+        default: return { 
+            module: payload.module,
+            args: [payload.event],
+        };
     }
 }

src/handlers/event-utils.ts

@@ -21,9 +21,10 @@ import {
     handleError,
     SernError,
     VoidResult,
+    useContainerRaw,
 } from '../core/_internal';
-import { Emitter, ErrorHandling, Logging, ModuleManager, useContainerRaw } from '../core';
-import { contextArgs, createDispatcher, dispatchMessage } from './dispatchers';
+import { Emitter, ErrorHandling, Logging, ModuleManager } from '../core';
+import { contextArgs, createDispatcher } from './dispatchers';
 import { ObservableInput, pipe } from 'rxjs';
 import { SernEmitter } from '../core';
 import { Err, Ok, Result } from 'ts-results-es';
@@ -77,8 +78,7 @@ export function createInteractionHandler<T extends Interaction>(
             return Files
                 .defaultModuleLoader<Processed<CommandModule>>(fullPath)
                 .then(payload =>
-                   Ok(createDispatcher({ module: payload.module, event }))
-                );
+                   Ok(createDispatcher({ module: payload.module, event })));
         },
     );
 }
@@ -97,9 +97,9 @@ export function createMessageHandler(
         }
         return Files
             .defaultModuleLoader<Processed<CommandModule>>(fullPath)
-            .then(payload => {
+            .then(({ module })=> {
                 const args = contextArgs(event, rest);
-                return Ok(dispatchMessage(payload.module, args));
+                return Ok({ module, args });
             });
     });
 }
@@ -125,7 +125,9 @@ export function buildModules<T extends AnyModule>(
     input: ObservableInput<string>,
     moduleManager: ModuleManager,
 ) {
-    return Files.buildModuleStream<Processed<T>>(input).pipe(assignDefaults(moduleManager));
+    return Files
+        .buildModuleStream<Processed<T>>(input)
+        .pipe(assignDefaults(moduleManager));
 }
 
 /**
@@ -150,11 +152,11 @@ export function executeModule(
         //converting the task into a promise so rxjs can resolve the Awaitable properly
         concatMap(() => Result.wrapAsync(async () => task())),
         concatMap(result => {
-            if (result.ok) {
+            if (result.isOk()) {
                 emitter.emit('module.activate', SernEmitter.success(module));
                 return EMPTY;
             } else {
-                return throwError(() => SernEmitter.failure(module, result.val));
+                return throwError(() => SernEmitter.failure(module, result.error));
             }
         }),
     );
@@ -182,7 +184,7 @@ export function createResultResolver<
         const task$ = config.createStream(args);
         return task$.pipe(
             tap(result => {
-                result.err && config.onStop?.(args.module);
+                result.isErr() && config.onStop?.(args.module);
             }),
             everyPluginOk,
             filterMapTo(() => config.onNext(args)),

src/handlers/interaction-event.ts

@@ -1,5 +1,5 @@
 import { Interaction } from 'discord.js';
-import { concatMap, merge } from 'rxjs';
+import { mergeMap, merge } from 'rxjs';
 import { SernEmitter } from '../core';
 import {
     isAutocomplete,
@@ -28,6 +28,6 @@ export function interactionHandler([emitter, , , modules, client]: DependencyLis
             filterTap(e => emitter.emit('warning', SernEmitter.warning(e))),
             makeModuleExecutor(module => 
                 emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure))),
-            concatMap(payload => executeModule(emitter, payload)),
+            mergeMap(payload => executeModule(emitter, payload)),
     );
 }

src/handlers/message-event.ts

@@ -1,4 +1,4 @@
-import { concatMap, EMPTY } from 'rxjs';
+import { mergeMap, EMPTY } from 'rxjs';
 import type { Message } from 'discord.js';
 import { SernEmitter } from '../core';
 import { sharedEventStream, SernError, filterTap } from '../core/_internal';
@@ -42,6 +42,6 @@ export function messageHandler(
         makeModuleExecutor(module => {
             emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
         }),
-        concatMap(payload => executeModule(emitter, payload)),
+        mergeMap(payload => executeModule(emitter, payload)),
     );
 }

src/handlers/user-defined-events.ts

@@ -24,14 +24,12 @@ export function eventsHandler(
         }
     };
     buildModules<EventModule>(allPaths, moduleManager)
-        .pipe(
-            callInitPlugins(emitter),
-            map(intoDispatcher),
-            /**
-             * Where all events are turned on
-             */
-            mergeAll(),
-            handleCrash(err, log),
-        )
+        .pipe(callInitPlugins(emitter),
+              map(intoDispatcher),
+              /**
+                * Where all events are turned on
+               */
+              mergeAll(),
+              handleCrash(err, log))
         .subscribe();
 }

src/index.ts

@@ -50,4 +50,7 @@ export {
     CommandExecutable,
 } from './core/modules';
 
+export {
+    useContainerRaw
+} from './core/_internal'
 export { controller } from './sern';

src/sern.ts

@@ -27,13 +27,12 @@ export function init(maybeWrapper: Wrapper | 'file') {
     const dependencies = useDependencies();
     const logger = dependencies[2],
         errorHandler = dependencies[1];
-    const mode = isDevMode(wrapper.mode ?? process.env.MODE);
 
     if (wrapper.events !== undefined) {
-        eventsHandler(dependencies, Files.getFullPathTree(wrapper.events, mode));
+        eventsHandler(dependencies, Files.getFullPathTree(wrapper.events));
     }
     //Ready event: load all modules and when finished, time should be taken and logged
-    startReadyEvent(dependencies, Files.getFullPathTree(wrapper.commands, mode)).add(() => {
+    startReadyEvent(dependencies, Files.getFullPathTree(wrapper.commands)).add(() => {
         const time = ((performance.now() - startTime) / 1000).toFixed(2);
         dependencies[0].emit('modulesLoaded');
         logger?.info({
@@ -47,14 +46,6 @@ export function init(maybeWrapper: Wrapper | 'file') {
     merge(messages$, interactions$).pipe(handleCrash(errorHandler, logger)).subscribe();
 }
 
-function isDevMode(mode: string | undefined) {
-    console.info(`Detected mode: "${mode}"`);
-    if (mode === undefined) {
-        console.info('No mode found in process.env, assuming DEV');
-    }
-    return mode === 'DEV' || mode == undefined;
-}
-
 function useDependencies() {
     return Services(
         '@sern/emitter',

src/types/core.ts

@@ -10,8 +10,9 @@ export interface Wrapper {
     events?: string;
     /**
      * Overload to enable mode in case developer does not use a .env file.
+     * @deprecated - https://github.com/sern-handler/handler/pull/325
      */
-    mode?: 'DEV' | 'PROD';
+    mode?: string
     /*
      * @deprecated
      */

test/core/context.test.ts

@@ -0,0 +1,85 @@
+import { describe, vi, it, expect } from'vitest'
+import { Context } from '../../src';
+import { faker } from '@faker-js/faker'
+describe('Context', () => {
+    // Mocked message and interaction objects for testing
+    const mockMessage = {
+        id: 'messageId',
+        channel: 'channelId',
+        channelId: 'channelId',
+        interaction: { 
+            id: faker.string.uuid()
+        },
+        author: { id: 'userId' },
+        createdTimestamp: 1234567890,
+        guild: 'guildId',
+        guildId: 'guildId',
+        member: { id: 'memberId' },
+        client: { id: 'clientId' },
+        inGuild: vi.fn().mockReturnValue(true),
+        reply: vi.fn(),
+    };
+
+    const mockInteraction = {
+        id: 'interactionId',
+        user: { id: 'userId' },
+        channel: 'channelId',
+        channelId: 'channelId',
+        createdTimestamp: 1234567890,
+        guild: 'guildId',
+        guildId: 'guildId',
+        fetchReply: vi.fn().mockResolvedValue({}),
+        member: { id: 'memberId' },
+        client: { id: 'clientId' },
+        isChatInputCommand: vi.fn().mockResolvedValue(true),
+        inGuild: vi.fn().mockReturnValue(true),
+        reply: vi.fn().mockResolvedValue({}),
+    };
+
+    it('should create a context from a message', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        expect(context).toBeDefined();
+        expect(context.id).toBe('messageId');
+    });
+    it('should throw error if accessing interaction as message', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        expect(context).toBeDefined();
+        expect(() => context.interaction)
+            .toThrowError('You cannot use message when an interaction fired or vice versa');
+
+    })
+     it('should throw error if accessing message as interaction', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        expect(context).toBeDefined();
+        expect(() => context.message)
+            .toThrowError('You cannot use message when an interaction fired or vice versa');
+
+    })
+
+    it('should create a context from an interaction', () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        expect(context).toBeDefined();
+        expect(context.id).toBe('interactionId'); 
+    });
+
+    it('should reply to a context with a message', async () => {
+        //@ts-ignore
+        const context = Context.wrap(mockMessage);
+        const replyOptions = { content: 'Hello, world!' };
+        await context.reply(replyOptions);
+        expect(mockMessage.reply).toHaveBeenCalledWith(replyOptions);
+    });
+
+    it('should reply to a context with an interaction', async () => {
+        //@ts-ignore
+        const context = Context.wrap(mockInteraction);
+        const replyOptions = { content: 'Hello, world!' };
+        await context.reply(replyOptions);
+        expect(mockInteraction.reply).toHaveBeenCalledWith(replyOptions);
+    });
+
+});

test/core/ioc.test.ts

@@ -1,23 +1,36 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { CoreContainer } from '../../src/core/ioc/container';
-import { CoreDependencies } from '../../src/core/ioc';
 import { EventEmitter } from 'events';
-import { DefaultLogging, Init, Logging } from '../../src/core';
+import { DefaultLogging, Disposable, Init, Logging } from '../../src/core';
+import { CoreDependencies } from '../../src/types/ioc';
 
 describe('ioc container', () => {
-    let container: CoreContainer<{}>;
-    let initDependency: Logging & Init;
+    let container: CoreContainer<{}> = new CoreContainer();
+    let dependency: Logging & Init & Disposable;
     beforeEach(() => {
-        initDependency = {
+        dependency = {
             init: vi.fn(),
             error(): void {},
             warning(): void {},
             info(): void {},
             debug(): void {},
+            dispose: vi.fn()
         };
         container = new CoreContainer();
     });
-
+    const wait = (seconds: number) =>  new Promise((resolve) => setTimeout(resolve, seconds));
+    class DB implements Init, Disposable {
+      public connected = false
+      constructor() {}
+      async init() {
+        this.connected = true
+        await wait(10)
+      }
+      async dispose() {
+        await wait(20)
+        this.connected = false
+      }
+    }
     it('should be ready after calling container.ready()', () => {
         container.ready();
         expect(container.isReady()).toBe(true);
@@ -39,14 +52,35 @@ describe('ioc container', () => {
         }
     });
     it('should init modules', () => {
-        container.upsert({ '@sern/logger': initDependency });
+        container.upsert({ '@sern/logger': dependency });
         container.ready();
-        expect(initDependency.init).to.toHaveBeenCalledOnce();
+        expect(dependency.init).to.toHaveBeenCalledOnce();
+    });
+    it('should dispose modules', async () => {
+        
+        container.upsert({ '@sern/logger': dependency })
+
+        container.ready();
+        // We need to access the dependency at least once to be able to dispose of it.
+        container.get('@sern/logger' as never);
+        await container.disposeAll();
+        expect(dependency.dispose).toHaveBeenCalledOnce();
     });
 
+    it('should init and dispose', async () => {
+        container.add({ db: new DB() })
+        container.ready()
+        const db = container.get('db' as never) as DB
+        expect(db.connected).toBeTruthy()
+
+        await container.disposeAll();
+
+        expect(db.connected).toBeFalsy()
+    })
+
     it('should not lazy module', () => {
-        container.upsert({ '@sern/logger': () => initDependency });
+        container.upsert({ '@sern/logger': () => dependency });
         container.ready();
-        expect(initDependency.init).toHaveBeenCalledTimes(0);
+        expect(dependency.init).toHaveBeenCalledTimes(0);
     });
 });

test/core/module-loading.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest'
+import { faker } from '@faker-js/faker'
+import * as Files from '../../src/core/module-loading'
+describe('module-loading', () => {
+    it('should properly extract filename from file, nested once', () => {
+        const extension = faker.system.fileExt()
+        const name = faker.system.fileName({ extensionCount: 0 })
+        const filename = Files.fmtFileName(name+'.'+extension);
+        expect(filename).toBe(name)
+    })
+    
+//    todo: handle commands with multiple extensions
+//    it('should properly extract filename from file, nested multiple', () => {
+//        const extension = faker.system.fileExt()
+//        const extension2 = faker.system.fileExt()
+//        const name = faker.system.fileName({ extensionCount: 0 })
+//        const filename = Files.fmtFileName(name+'.'+extension+'.'+extension2);
+//        console.log(filename, name)
+//        expect(filename).toBe(name)
+//
+//    })
+}) 

test/core/services.test.ts

@@ -39,14 +39,14 @@ describe('services', () => {
             .map((path, i) => `${path}/${modules[i]}.js`);
 
         const metadata: CommandMeta[] = modules.map((cm, i) => ({
-            id: Id.create(cm.name, cm.type),
+            id: Id.create(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(Id.create(m.name, m.type), paths[i]);
+            moduleManager.set(Id.create(m.name!, m.type), paths[i]);
             moduleManager.setMetadata(m, metadata[i]);
             i++;
         }

test/handlers/id.test.ts

@@ -18,7 +18,7 @@ function createRandomCommandModules() {
         CommandType.Button,
     ];
     return commandModule({
-        type: randomCommandType[Math.floor(Math.random() * randomCommandType.length)],
+        type: faker.helpers.uniqueArray(randomCommandType, 1)[0],
         description: faker.string.alpha(),
         name: faker.string.alpha(),
         execute: () => {},

tsup.config.js

@@ -4,7 +4,7 @@ const shared = {
     external: ['discord.js', 'iti'],
     platform: 'node',
     clean: true,
-    sourcemap: false,
+    sourcemap: true,
     treeshake: {
         moduleSideEffects: false,
         correctVarValueBeforeDeclaration: true, //need this to treeshake esm discord.js empty import
@@ -17,33 +17,8 @@ export default defineConfig([
         target: 'node18',
         tsconfig: './tsconfig.json',
         outDir: './dist',
-        splitting: true,
+        minify: false,
         dts: true,
         ...shared,
     },
-    //    {
-    //        format: 'cjs',
-    //        esbuildPlugins: [ifdefPlugin({ variables: { MODE: 'cjs' }, verbose: true })],
-    //        splitting: false,
-    //        target: 'node18',
-    //        tsconfig: './tsconfig-cjs.json',
-    //        outDir: './dist/cjs',
-    //        outExtension() {
-    //            return {
-    //                js: '.cjs',
-    //            };
-    //        },
-    //        async onSuccess() {
-    //            console.log('writing json commonjs');
-    //            await writeFile('./dist/cjs/package.json', JSON.stringify({ type: 'commonjs' }));
-    //        },
-    //        ...shared,
-    //    },
-    //    {
-    //        dts: {
-    //            only: true,
-    //        },
-    //        entry: ['src/index.ts'],
-    //        outDir: 'dist',
-    //    },
-]);
+ ]);