feat!: simpler plugins

README.md

@@ -28,7 +28,13 @@ yarn add @sern/handler
 ```sh
 pnpm add @sern/handler
 ```
-
+## Why?
+- Most handlers don't support discord.js 14.7+
+- Customizable commands
+- Plug and play or customize to your liking
+- Embraces reactive programming for consistent and reliable backend
+- Customizable logger, error handling, and more
+- Active development and growing [community](https://sern.dev/discord)
 ## 👀 Quick Look
 
 * Support for discord.js v14 and all interactions
@@ -105,7 +111,7 @@ It is **highly encouraged** to use the [command line interface](https://github.c
 
 ## 👋 Contribute
 
-- Read our contribution [guidelines](./.github/CONTRIBUTING.md) carefully
+- Read our contribution [guidelines](https://github.com/sern-handler/handler/blob/main/.github/CONTRIBUTING.md) carefully
 - Pull up on [issues](https://github.com/sern-handler/handler/issues) and report bugs
 - All kinds of contributions are welcomed.
 

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@sern/handler",
     "packageManager": "pnpm@7.25.0",
-    "version": "2.1.1",
+    "version": "2.5.0",
     "description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
     "main": "dist/cjs/index.cjs",
     "module": "dist/esm/index.mjs",
@@ -35,17 +35,17 @@
     "dependencies": {
         "iti": "^0.6.0",
         "rxjs": "^7.5.6",
-        "ts-pattern": "^4.0.2",
+        "ts-pattern": "^4.0.6",
         "ts-results-es": "^3.5.0"
     },
     "devDependencies": {
         "@typescript-eslint/eslint-plugin": "5.47.1",
         "@typescript-eslint/parser": "5.48.0",
+        "discord.js": ">= ^14.7.x",
         "eslint": "8.30.0",
         "prettier": "2.8.3",
         "tsup": "^6.1.3",
-        "typescript": "4.9.4",
-        "discord.js": ">= ^14.7.x"
+        "typescript": "4.9.4"
     },
     "repository": {
         "type": "git",

src/handler/contracts/errorHandling.ts

@@ -1,6 +1,5 @@
 import type { Observable } from 'rxjs';
 import type { Logging } from './logging';
-import { useContainerRaw } from '../dependencies/provider';
 import util from 'util';
 export interface ErrorHandling {
     /**
@@ -36,11 +35,6 @@ export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
         // This is done to fit the ErrorHandling contract
         const err = pload instanceof Error ? pload : Error(util.format(pload));
         if (crashHandler.keepAlive == 0) {
-            useContainerRaw()
-                ?.disposeAll()
-                .then(() => {
-                    logging?.info({ message: 'Cleaning container and crashing' });
-                });
             crashHandler.crash(err);
         }
         //formatted payload

src/handler/contracts/moduleManager.ts

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

src/handler/dependencies/index.ts

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

src/handler/dependencies/lifetimeFunctions.ts

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

src/handler/dependencies/provider.ts

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