refactor: move things to core, imports not fixed yet

src/core/contracts/errorHandling.ts

@@ -0,0 +1,50 @@
+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/core/contracts/index.ts

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

src/core/contracts/logging.ts

@@ -0,0 +1,31 @@
+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;
+}
+/**
+ * @since 2.0.0
+ */
+export class DefaultLogging implements Logging {
+    private date = () => new Date();
+    debug(payload: LogPayload): void {
+        console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    error(payload: LogPayload): void {
+        console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    info(payload: LogPayload): void {
+        console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+
+    warning(payload: LogPayload): void {
+        console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
+    }
+}

src/core/contracts/moduleManager.ts

@@ -0,0 +1,27 @@
+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);
+    }
+}