refactor: eventhandlers (#246)

* refactor:import

* feat: save progress

* feat:progress

* refactor: event handlers

* fix: merge all subscriptions into event handler

* fix: remove duplicate minify key

* fix: leftover this

* docs: jsdoc

* chore: clean pnpm

---------

Co-authored-by: jacoobes <jacobnguyend@gmail.com>

package.json

@@ -1,7 +1,7 @@
 {
     "name": "@sern/handler",
     "packageManager": "pnpm@7.28.0",
-    "version": "2.5.3",
+    "version": "2.6.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",

src/handler/contracts/moduleManager.ts

@@ -5,7 +5,7 @@ import type { Processed } from '../../types/handler';
 export interface ModuleManager {
     get<T extends CommandType>(
         strat: (ms: ModuleStore) => Processed<CommandModuleDefs[T]> | undefined,
-    ): CommandModuleDefs[T] | undefined;
+    ): Processed<CommandModuleDefs[T]> | undefined;
     set(strat: (ms: ModuleStore) => void): void;
 }
 
@@ -21,3 +21,4 @@ export class DefaultModuleManager implements ModuleManager {
         strat(this.moduleStore);
     }
 }
+

src/handler/dependencies/provider.ts

@@ -1,12 +1,11 @@
 import type { Container } from 'iti';
-import { SernError } from '../structures/errors';
 import type { Dependencies, DependencyConfiguration, MapDeps } from '../../types/handler';
 import SernEmitter from '../sernEmitter';
 import { DefaultErrorHandling, DefaultLogging, DefaultModuleManager } from '../contracts';
-import { ModuleStore } from '../structures/moduleStore';
 import { Result } from 'ts-results-es';
 import { BehaviorSubject } from 'rxjs';
 import { createContainer } from 'iti';
+import { type Wrapper, ModuleStore, SernError} from '../structures';
 
 export const containerSubject = new BehaviorSubject(defaultContainer());
 
@@ -71,3 +70,21 @@ function defaultContainer() {
         {}
     >;
 }
+
+
+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/eventsHandler.ts

@@ -1,34 +0,0 @@
-import type Wrapper from '../structures/wrapper';
-import { Subject, type Observable } from 'rxjs';
-import type { EventEmitter } from 'events';
-import type SernEmitter from '../sernEmitter';
-import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
-
-/**
- * why did I make this, definitely going to be changed in the future
- */
-export abstract class EventsHandler<T> {
-    protected payloadSubject = new Subject<T>();
-    protected abstract discordEvent: Observable<unknown>;
-    protected client: EventEmitter;
-    protected emitter: SernEmitter;
-    protected crashHandler: ErrorHandling;
-    protected logger?: Logging;
-    protected modules: ModuleManager;
-    protected constructor({ containerConfig }: Wrapper) {
-        const [client, emitter, crash, modules, logger] = containerConfig.get(
-            '@sern/client',
-            '@sern/emitter',
-            '@sern/errors',
-            '@sern/modules',
-            '@sern/logger',
-        );
-        this.logger = logger as Logging | undefined;
-        this.modules = modules as ModuleManager;
-        this.client = client as EventEmitter;
-        this.emitter = emitter as SernEmitter;
-        this.crashHandler = crash as ErrorHandling;
-    }
-    protected abstract init(): void;
-    protected abstract setState(state: T): void;
-}

src/handler/events/interactionHandler.ts

@@ -1,108 +1,76 @@
 import type { Interaction } from 'discord.js';
-import { catchError, concatMap, finalize, fromEvent, map, Observable } from 'rxjs';
-import type Wrapper from '../structures/wrapper';
-import { EventsHandler } from './eventsHandler';
-import { CommandType, SernError, type ModuleStore } from '../structures';
+import { catchError, concatMap, EMPTY, filter, finalize, fromEvent, map, Observable, of, OperatorFunction, pipe } from 'rxjs';
+import { CommandType, type ModuleStore, SernError } from '../structures';
 import { match, P } from 'ts-pattern';
-import { contextArgs, interactionArg, dispatchAutocomplete, dispatchCommand } from './dispatchers';
+import { contextArgs, dispatchAutocomplete, dispatchCommand, interactionArg } from './dispatchers';
 import { executeModule, makeModuleExecutor } from './observableHandling';
 import type { CommandModule } from '../../types/module';
-import { handleError } from '../contracts/errorHandling';
+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';
 
-export default class InteractionHandler extends EventsHandler<{
-    event: Interaction;
-    module: Processed<CommandModule>;
-}> {
-    protected override discordEvent: Observable<Interaction>;
-    constructor(wrapper: Wrapper) {
-        super(wrapper);
-        this.discordEvent = <Observable<Interaction>>fromEvent(this.client, 'interactionCreate');
-        this.init();
 
-        this.payloadSubject
-            .pipe(
-                map(this.createDispatcher),
-                makeModuleExecutor(module => {
-                    this.emitter.emit(
-                        'module.activate',
-                        SernEmitter.failure(module, SernError.PluginFailure),
-                    );
-                }),
-                concatMap(payload => executeModule(this.emitter, payload)),
-                catchError(handleError(this.crashHandler, this.logger)),
-                finalize(() => {
-                    this.logger?.info({
-                        message: 'interactionCreate stream closed or reached end of lifetime',
-                    });
-                    useContainerRaw()
-                        ?.disposeAll()
-                        .then(() => {
-                            this.logger?.info({ message: 'Cleaning container and crashing' });
-                        });
-                }),
-            )
-            .subscribe();
-    }
+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 module = get(ms =>
+               ms.InteractionHandlers[event.componentType].get(event.customId),
+             );
+           return of({module, event});
+         } else if (event.isCommand() || event.isAutocomplete()) {
+           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(event.commandName) ??
+                ms.BothCommands.get(event.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 }>;
+}
 
-    override init() {
-        const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
-            return this.modules.get(cb);
-        };
-        /**
-         * Module retrieval:
-         * ModuleStores are mapped by Discord API values and modules mapped
-         * by customId or command name.
-         */
-        this.discordEvent.subscribe({
-            next: event => {
-                if (event.isMessageComponent()) {
-                    const module = get(ms =>
-                        ms.InteractionHandlers[event.componentType].get(event.customId),
-                    );
-                    this.setState({ event, module });
-                } else if (event.isCommand() || event.isAutocomplete()) {
-                    const module = get(
-                        ms =>
-                            /**
-                             * try to fetch from ApplicationCommands, if nothing, try BothCommands
-                             * map. If nothing again,this means a slash command
-                             * exists on the API but not sern
-                             */
-                            ms.ApplicationCommands[event.commandType].get(event.commandName) ??
-                            ms.BothCommands.get(event.commandName),
-                    );
-                    this.setState({ event, module });
-                } else if (event.isModalSubmit()) {
-                    const module = get(ms => ms.ModalSubmit.get(event.customId));
-                    this.setState({ event, module });
-                } else {
-                    throw Error('This interaction is not supported yet');
-                }
-            },
-            error: reason => {
-                this.emitter.emit('error', SernEmitter.failure(undefined, reason));
-            },
-        });
-    }
+export function makeInteractionCreate(
+    [s, client, err, log, modules]: [SernEmitter, EventEmitter, ErrorHandling, Logging | undefined, ModuleManager]
+) {
 
-    protected setState(state: { event: Interaction; module: CommandModule | undefined }): void {
-        if (state.module === undefined) {
-            this.emitter.emit(
-                'warning',
-                SernEmitter.warning('Found no module for this interaction'),
-            );
-        } else {
-            //if statement above checks already, safe cast
-            this.payloadSubject.next(
-                state as { event: Interaction; module: Processed<CommandModule> },
-            );
-        }
-    }
+    //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();
+}
 
-    protected createDispatcher({
+function createDispatcher({
         module,
         event,
     }: {
@@ -111,9 +79,9 @@ export default class InteractionHandler extends EventsHandler<{
     }) {
         return (
             match(module)
-                .with({ type: CommandType.Text }, () =>
-                    this.crashHandler.crash(Error(SernError.MismatchEvent)),
-                )
+                .with({ type: CommandType.Text }, () => {
+                    throw Error(SernError.MismatchEvent);
+                })
                 //P.union = either CommandType.Slash or CommandType.Both
                 .with({ type: P.union(CommandType.Slash, CommandType.Both) }, module => {
                     if (event.isAutocomplete()) {
@@ -134,4 +102,4 @@ export default class InteractionHandler extends EventsHandler<{
                 .otherwise(mod => dispatchCommand(mod, interactionArg(event)))
         );
     }
-}
+

src/handler/events/messageHandler.ts

@@ -1,84 +1,74 @@
-import { EventsHandler } from './eventsHandler';
-import { catchError, concatMap, EMPTY, finalize, fromEvent, map, Observable, of } from 'rxjs';
-import { type Wrapper, type ModuleStore, SernError } from '../structures';
+import { catchError, concatMap, EMPTY, finalize, fromEvent, map, of, pipe } from 'rxjs';
+import { type ModuleStore, SernError } from '../structures';
 import type { Message } from 'discord.js';
 import { executeModule, ignoreNonBot, makeModuleExecutor } from './observableHandling';
 import { fmt } from '../utilities/messageHelpers';
-import type { CommandModule, Module, TextCommand } from '../../types/module';
-import { handleError } from '../contracts/errorHandling';
+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';
 
-export default class MessageHandler extends EventsHandler<{
-    module: Processed<Module>;
-    args: unknown[];
-}> {
-    protected discordEvent: Observable<Message>;
-
-    public constructor(protected wrapper: Wrapper) {
-        super(wrapper);
-        this.discordEvent = <Observable<Message>>fromEvent(this.client, 'messageCreate');
-        this.init();
-        this.payloadSubject
-            .pipe(
-                makeModuleExecutor(module => {
-                    this.emitter.emit(
-                        'module.activate',
-                        SernEmitter.failure(module, SernError.PluginFailure),
-                    );
-                }),
-                concatMap(payload => executeModule(this.emitter, payload)),
-                catchError(handleError(this.crashHandler, this.logger)),
-                finalize(() => {
-                    this.logger?.info({
-                        message: 'messageCreate stream closed or reached end of lifetime',
-                    });
-                    useContainerRaw()
-                        ?.disposeAll()
-                        .then(() => {
-                            this.logger?.info({ message: 'Cleaning container and crashing' });
-                        });
-                }),
-            )
-            .subscribe();
-    }
-
-    protected init(): void {
-        if (this.wrapper.defaultPrefix === undefined) return; //for now, just ignore if prefix doesn't exist
-        const { defaultPrefix } = this.wrapper;
-        const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
-            return this.modules.get(cb);
+/**
+ * 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, 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,
         };
-        this.discordEvent
-            .pipe(
-                ignoreNonBot(this.wrapper.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, 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)),
-            )
-            .subscribe({
-                next: value => this.setState(value),
-                error: reason => this.emitter.emit('error', SernEmitter.failure(reason)),
-            });
-    }
+        return of(payload);
+    }),
+    map(({ args, module }) => dispatchCommand(module as Processed<TextCommand>, args)),
+);
 
-    protected setState(state: { module: Processed<Module>; args: unknown[] }) {
-        this.payloadSubject.next(state);
+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<Message>(client, 'messageCreate');
+    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/readyHandler.ts

@@ -1,72 +1,47 @@
-import { EventsHandler } from './eventsHandler';
-import type Wrapper from '../structures/wrapper';
-import { concatMap, fromEvent, type Observable, take } from 'rxjs';
+import { fromEvent, pipe, switchMap, take } from 'rxjs';
 import * as Files from '../utilities/readFile';
 import { errTap, scanModule } from './observableHandling';
-import { CommandType, SernError, type ModuleStore } from '../structures';
+import { CommandType, type ModuleStore, SernError } from '../structures';
 import { match } from 'ts-pattern';
 import { Result } from 'ts-results-es';
 import { ApplicationCommandType, ComponentType } from 'discord.js';
 import type { CommandModule } from '../../types/module';
 import type { Processed } from '../../types/handler';
-import type { ModuleManager } from '../contracts';
+import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
 import { _const, err, ok } from '../utilities/functions';
 import { defineAllFields } from './operators';
 import SernEmitter from '../sernEmitter';
+import type { EventEmitter } from 'node:events';
 
-export default class ReadyHandler extends EventsHandler<{
-    module: Processed<CommandModule>;
-    absPath: string;
-}> {
-    protected discordEvent!: Observable<{ module: CommandModule; absPath: string }>;
-    constructor(wrapper: Wrapper) {
-        super(wrapper);
-        const ready$ = fromEvent(this.client, 'ready').pipe(take(1));
-        this.discordEvent = ready$.pipe(
-            concatMap(() =>
-                Files.buildData<CommandModule>(wrapper.commands).pipe(
-                    errTap(reason => {
-                        this.emitter.emit(
-                            'module.register',
-                            SernEmitter.failure(undefined, reason),
-                        );
-                    }),
-                ),
-            ),
-        );
-        this.init();
-        this.payloadSubject
-            .pipe(
-                scanModule({
-                    onFailure: module => {
-                        this.emitter.emit(
-                            'module.register',
-                            SernEmitter.failure(module, SernError.PluginFailure),
-                        );
-                    },
-                    onSuccess: ({ module }) => {
-                        this.emitter.emit('module.register', SernEmitter.success(module));
-                        return module;
-                    },
-                }),
-            )
-            .subscribe(module => {
-                const res = registerModule(this.modules, module as Processed<CommandModule>);
-                if (res.err) {
-                    this.crashHandler.crash(Error(SernError.InvalidModuleType));
-                }
-            });
-    }
-
-    protected init() {
-        this.discordEvent.pipe(defineAllFields()).subscribe({
-            next: value => this.setState(value),
-            complete: () => this.payloadSubject.unsubscribe(),
-        });
-    }
-    protected setState(state: { absPath: string; module: Processed<CommandModule> }): void {
-        this.payloadSubject.next(state);
-    }
+export function makeReadyEvent(
+    [sEmitter,client, errorHandler,, moduleManager]: [SernEmitter, EventEmitter, ErrorHandling, Logging | undefined, ModuleManager],
+    commandDir: string,
+) {
+    const readyOnce$ = fromEvent(client, 'ready').pipe(take(1));
+    const parseCommandModules = pipe(
+        switchMap(() => Files.buildData<CommandModule>(commandDir)),
+        errTap(error => {
+            sEmitter.emit('module.register', SernEmitter.failure(undefined, error));
+        }),
+        defineAllFields(),
+    );
+    return readyOnce$.pipe(
+        parseCommandModules,
+        scanModule({
+            onFailure: module => {
+                sEmitter.emit('module.register', SernEmitter.failure(module, SernError.PluginFailure));
+            },
+            onSuccess: ({ 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>>(

src/handler/events/userDefinedEventsHandling.ts

@@ -1,4 +1,4 @@
-import { catchError, finalize, map, tap } from 'rxjs';
+import { catchError, finalize, map, tap, mergeAll } from 'rxjs';
 import { buildData } from '../utilities/readFile';
 import type { Dependencies, Processed } from '../../types/handler';
 import { errTap, scanModule } from './observableHandling';
@@ -13,57 +13,56 @@ import { handleError } from '../contracts/errorHandling';
 import { defineAllFields } from './operators';
 import { useContainerRaw } from '../dependencies';
 
-export function processEvents({ containerConfig, events }: Wrapper) {
-    const [client, errorHandling, sernEmitter, logger] = containerConfig.get(
-        '@sern/client',
-        '@sern/errors',
-        '@sern/emitter',
-        '@sern/logger',
-    ) as [EventEmitter, ErrorHandling, SernEmitter, Logging?];
-    const lazy = (k: string) => containerConfig.get(k as keyof Dependencies)[0];
-    const eventStream$ = eventObservable$(events!, sernEmitter);
+
+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(
         defineAllFields(),
         scanModule({
-            onFailure: module => sernEmitter.emit('module.register', SernEmitter.success(module)),
+            onFailure: module => s.emit('module.register', SernEmitter.success(module)),
             onSuccess: ({ module }) => {
-                sernEmitter.emit(
+                s.emit(
                     'module.register',
                     SernEmitter.failure(module, SernError.PluginFailure),
                 );
                 return module;
             },
         }),
-    );
+    ); 
     const intoDispatcher = (e: Processed<EventModule | CommandModule>) =>
         match(e)
-            .with({ type: EventType.Sern }, m => eventDispatcher(m, sernEmitter))
+            .with({ type: EventType.Sern }, m => eventDispatcher(m, s))
             .with({ type: EventType.Discord }, m => eventDispatcher(m, client))
             .with({ type: EventType.External }, m => eventDispatcher(m, lazy(m.emitter)))
-            .otherwise(() => errorHandling.crash(Error(SernError.InvalidModuleType)));
-
+            .otherwise(() => err.crash(Error(SernError.InvalidModuleType)));
     eventCreation$
         .pipe(
             map(intoDispatcher),
             /**
              * Where all events are turned on
              */
-            tap(dispatcher => dispatcher.subscribe()),
-            catchError(handleError(errorHandling, logger)),
+            mergeAll(),
+            catchError(handleError(err, log)),
             finalize(() => {
-                logger?.info({ message: 'an event module reached end of lifetime' });
+                log?.info({ message: 'an event module reached end of lifetime'});
                 useContainerRaw()
                     ?.disposeAll()
                     .then(() => {
-                        logger?.info({ message: 'Cleaning container and crashing' });
+                        log?.info({ message: 'Cleaning container and crashing' });
                     });
-            }),
+            })
         )
         .subscribe();
 }
 
-function eventObservable$(events: string, emitter: SernEmitter) {
+
+function eventObservable(events: string, emitter: SernEmitter) {
     return buildData<EventModule>(events).pipe(
         errTap(reason => {
             emitter.emit('module.register', SernEmitter.failure(undefined, reason));

src/handler/plugins/createPlugin.ts

@@ -1,4 +1,4 @@
-import { CommandType, EventType, PluginType } from '../structures/enums';
+import { CommandType, EventType, PluginType } from '../structures';
 import type { Plugin, PluginResult } from '../../types/plugin';
 import type { CommandArgs, EventArgs } from './args';
 import type { ClientEvents } from 'discord.js';

src/handler/sern.ts

@@ -1,10 +1,10 @@
 import type Wrapper from './structures/wrapper';
-import { processEvents } from './events/userDefinedEventsHandling';
+import { makeEventsHandler } from './events/userDefinedEventsHandling';
 import { CommandType, EventType, PluginType } from './structures/enums';
 import type { AnyEventPlugin, ControlPlugin, InitPlugin, Plugin } from '../types/plugin';
-import InteractionHandler from './events/interactionHandler';
-import ReadyHandler from './events/readyHandler';
-import MessageHandler from './events/messageHandler';
+import { makeInteractionCreate } from './events/interactionHandler';
+import { makeReadyEvent } from './events/readyHandler';
+import { makeMessageCreate } from './events/messageHandler';
 import type {
     CommandModule,
     CommandModuleDefs,
@@ -14,7 +14,7 @@ import type {
     InputEvent,
 } from '../types/module';
 import type { Dependencies, DependencyConfiguration } from '../types/handler';
-import { composeRoot, useContainer } from './dependencies/provider';
+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';
@@ -37,14 +37,27 @@ import type { Awaitable, ClientEvents } from 'discord.js';
  */
 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) {
-        processEvents(wrapper);
+        makeEventsHandler(
+            requiredDependenciesAnd([]),
+            events,
+            wrapper.containerConfig
+        );
     }
-    new ReadyHandler(wrapper);
-    new MessageHandler(wrapper);
-    new InteractionHandler(wrapper);
+    makeReadyEvent(
+        requiredDependenciesAnd(['@sern/modules']),
+        wrapper.commands
+    );
+    makeMessageCreate(
+        requiredDependenciesAnd(['@sern/modules']),
+        wrapper.defaultPrefix
+    );
+    makeInteractionCreate(
+        requiredDependenciesAnd(['@sern/modules'])
+    );
     const endTime = performance.now();
     logger?.info({ message: `sern : ${(endTime - startTime).toFixed(2)} ms` });
 }