feat!: v3 (#294)

* refactor: move things to core, imports not fixed yet

* work on strategy and lifted Context

* remove id from lifted Context

* refactor: remove dependence on discord.js for module stoore

* moving and fixing imports

* chore: move operators into core

* chore: fix paths

* add wrapper platform field

* add deprecation warning

* chore:update paths

* chore:remove const function

* chore: remove deprecated symbols

* docs: add documentation to internal function

* chore: remove deprecated support for plugins

* chore: remove dependence on discord.js Awaitable type

* chore: update typings

* lift requiredDependencyKeys out of makeFetcher

* move strategy to index.ts and add adapters

* chore: fix typings

* chore: move command args matrix as binding

* feat: make Context platform specific, CoreContext as Core

* chore: remove extra file

* chore: move prettier into package.json

* chore(core): update imports and operators

* chore(core): add DefaultWrapper as sern classic

* move eslint and prettier configs to json

* chore: remove utils folder in favor of single file

* chore: remove redundant directories for single files

* chore: remove redundant directories for single files

* refactor: move and update things

* chore: move commands into seperate file

* chore: serverless work

* chore: remove redundant directories for single files

* chore: rename, wip refactoring

* chore: redundant directory

* refactor: internalize operators

* feat!: new module resolution algorithm

* chore: refactor and move things

* chore: refactor and add multiplatform typings

* chore: remove leaky import

* chore: add agnostic predicates

* chore: add old context here until i figure out what to do

* chore: update Proccessed typing to ./core

* chore: add tweetnacl

* revert: multiplatform

* revert: multiplatform

* chore: modularize and split typings

* chore: revert multiplatform

* chore: revert multi and mov sernEmitter

* chore: revert multi and clean up code

* refactor: add createGenericHandler

* refactor: remove unneeded signatures and fix imports

* feat: add getPublishableCommands to ModuleManager

* chore: remove bad imports

* style: pretty

* revert: remove AnyDependencies type

* refactor: fold switch case

* docs: specifics

* chore: change all file names to camel case

* refactor: change all files to camelcase and refactor

* revert: remove cloudflare typings

* feat: SernEmitter now captures promise rejections

* chore: fix InitArgs missing

* chore: move typings

* chore: move and clean

* chore: delete plugins dir

* chore: cleanup dispatchers subdirectory for single file

* chore: move context into structures directory

* refactor: cleaning up code and renaming variables

* chore: update name of function to reflect use

* revert: multiple entry points

* revert: readd discordEvent

* refactor: rename, format, move things

* feat: types organization and cleaning up code base

* fix: unaliased modules would throw error

* build: speed up build

* revert: readd module store and add contract

* add separate id for id processing

* chore: progress of globalizing dependencies type

* chore: update container and init hook progress

* style: format & lint

* feat: dev and prod mode

* fix: directories ignoring incorrectly

* refactor: move metadata outside of module declarations

* revert: re export command executable and event executable

* refactor: a lot

* fix: plugins for class modules and module loader

* style: pretty

* fix class based module loading

* feat: globalize dependencies type

* revert: internal name

* feat: add new sern emitter event

* refactor: remove cast

* refactor: add better typings for sern event modules

* test: add tests

* test: add more tests

* feat: change error handling contract

* chore: make changes in codebase after error contract change

* docs: add purpose of d.ts file

* revert removal of crash method and mark deprecated

* fix: typings for options- have access to all properties now

* refactor: npx knip

* 3.0.0-rc1

* chore: fix for version 3 and reexport old types

* fix: reexport payload and button modules

* fix: component commands incorrectly aligned and ordered

* chore: bump version

* test: add id generation testing

* refactor: algorithm for module resolution

* chore: bump vers

* test: add eventDispatcher test

* *.test.ts

* fix: autocomplete nested option

* chore: bump vers

* add npmignore .yarn

* feat: experimental loading sern.config.json

* refactor: simplify build

* chore: bump vers

* chore: add documentation for service api

* add since

* feat: add possible mode option in file loading mode

* refactor: remove two unneeded functions and refactor to throw early

* refactor: clean up handler code

* fix: undefined this binding

* refactor: clean up signatures and types

* refactor: make evident the internal api and move around stuff

* refactor: remove circular dependencies

* fix circulars and imports

* oops, moving around mroe stuff

* refresh lock

* chore: import type and prettier

* style: prettier

* feat: solidify init logic

* fix module-loading.ts

---------

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

src/core/_internal.ts

@@ -0,0 +1,9 @@
+export * as Id from './id';
+export * from './operators';
+export * from './predicates';
+export * as Files from './module-loading';
+export * from './functions';
+export type { VoidResult } from '../types/core-plugin';
+export { SernError } from './structures/enums';
+export { ModuleStore } from './structures/module-store';
+export * as DefaultServices from './structures/services';

src/core/contracts/emitter.ts

@@ -0,0 +1,7 @@
+import type { AnyFunction } from '../../types/utility';
+
+export interface Emitter {
+    addListener(eventName: string | symbol, listener: AnyFunction): this;
+    removeListener(eventName: string | symbol, listener: AnyFunction): this;
+    emit(eventName: string | symbol, ...payload: any[]): boolean;
+}

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,6 @@
+export * from './error-handling';
+export * from './logging';
+export * from './module-manager';
+export * from './module-store';
+export * from './init';
+export * from './emitter';

src/core/contracts/init.ts

@@ -0,0 +1,9 @@
+import type { Awaitable } from '../../types/utility';
+
+/**
+ * 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,22 @@
+import type {
+    CommandMeta,
+    CommandModule,
+    CommandModuleDefs,
+    Module,
+} from '../../types/core-modules';
+import { CommandType } from '../structures';
+
+/**
+ * @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 type { CommandMeta, Module } from '../../types/core-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

@@ -0,0 +1,62 @@
+import { CommandType, EventType, PluginType } from './structures';
+import type { Plugin, PluginResult, EventArgs, CommandArgs } from '../types/core-plugin';
+import type { ClientEvents } from 'discord.js';
+
+export function makePlugin<V extends unknown[]>(
+    type: PluginType,
+    execute: (...args: any[]) => any,
+): Plugin<V> {
+    return {
+        type,
+        execute,
+    } as Plugin<V>;
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function EventInitPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function CommandInitPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
+) {
+    return makePlugin(PluginType.Init, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function CommandControlPlugin<I extends CommandType>(
+    execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+/**
+ * @since 2.5.0
+ * @__PURE__
+ */
+export function EventControlPlugin<I extends EventType>(
+    execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}
+
+/**
+ * @since 2.5.0
+ * @Experimental
+ * A specialized function for creating control plugins with discord.js ClientEvents.
+ * Will probably be moved one day!
+ */
+export function DiscordEventControlPlugin<T extends keyof ClientEvents>(
+    name: T,
+    execute: (...args: ClientEvents[T]) => PluginResult,
+) {
+    return makePlugin(PluginType.Control, execute);
+}

src/core/functions.ts

@@ -0,0 +1,83 @@
+import { Err, Ok } from 'ts-results-es';
+import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
+import type { SernAutocompleteData, SernOptionsData } from '../types/core-modules';
+import type { AnyCommandPlugin, AnyEventPlugin, Plugin } from '../types/core-plugin';
+import { PluginType } from './structures';
+import assert from 'assert';
+
+//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 on the option tree
+ * @param iAutocomplete
+ * @param options
+ */
+export function treeSearch(
+    iAutocomplete: AutocompleteInteraction,
+    options: SernOptionsData[] | undefined,
+): SernAutocompleteData | undefined {
+    if (options === undefined) return undefined;
+    //clone to prevent mutation of original command module
+    const _options = options.map(a => ({ ...a }));
+    let subcommands = new Set();
+    while (_options.length > 0) {
+        const cur = _options.pop()!;
+        switch (cur.type) {
+            case ApplicationCommandOptionType.Subcommand:
+                {
+                    subcommands.add(cur.name);
+                    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 ('autocomplete' in cur && cur.autocomplete) {
+                        const choice = iAutocomplete.options.getFocused(true);
+                        assert(
+                            'command' in cur,
+                            'No command property found for autocomplete option',
+                        );
+                        if (subcommands.size > 0) {
+                            const parent = iAutocomplete.options.getSubcommand();
+                            const parentAndOptionMatches =
+                                subcommands.has(parent) && cur.name === choice.name;
+                            if (parentAndOptionMatches) {
+                                return cur;
+                            }
+                        } else {
+                            if (cur.name === choice.name) {
+                                return cur;
+                            }
+                        }
+                    }
+                }
+                break;
+        }
+    }
+}

src/core/id.ts

@@ -0,0 +1,63 @@
+import { ApplicationCommandType, ComponentType, Interaction, InteractionType } from 'discord.js';
+import { CommandType, EventType } from './structures';
+
+/**
+ * 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 reconstruct<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`;
+        }
+    }
+}
+/**
+ *
+ * A magic number to represent any commandtype that is an ApplicationCommand.
+ */
+const appBitField = 0b000000001111;
+
+// Each index represents the exponent of a CommandType.
+// Every CommandType is a power of two.
+export const CommandTypeDiscordApi = [
+    1, // CommandType.Text
+    ApplicationCommandType.ChatInput,
+    ApplicationCommandType.User,
+    ApplicationCommandType.Message,
+    ComponentType.Button,
+    ComponentType.StringSelect,
+    1, //  CommandType.Modal
+    ComponentType.UserSelect,
+    ComponentType.RoleSelect,
+    ComponentType.MentionableSelect,
+    ComponentType.ChannelSelect,
+];
+/*
+ * 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;
+    return CommandTypeDiscordApi[Math.log2(t)];
+}
+
+/*
+ * Generates an id based on name and CommandType.
+ * A is for any ApplicationCommand. C is for any ComponentCommand
+ * Then, another number generated by apiType function is appended
+ */
+export function create(name: string, type: CommandType | EventType) {
+    const am = (appBitField & type) !== 0 ? 'A' : 'C';
+    return name + '_' + am + apiType(type);
+}

src/core/index.ts

@@ -0,0 +1,4 @@
+export * from './contracts';
+export * from './create-plugins';
+export * from './structures';
+export * from './ioc';

src/core/ioc/base.ts

@@ -0,0 +1,34 @@
+import * as assert from 'assert';
+import { composeRoot, useContainer } from './dependency-injection';
+import type { DependencyConfiguration } from '../../types/ioc';
+import { CoreContainer } from './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/container.ts

@@ -0,0 +1,67 @@
+import { Container } from 'iti';
+import { SernEmitter } from '../';
+import { isAsyncFunction } from 'node:util/types';
+
+import * as assert from 'node:assert';
+import { Subject } from 'rxjs';
+import { DefaultServices, ModuleStore } from '../_internal';
+
+/**
+ * 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>();
+    private beenCalled = new Set<PropertyKey>();
+    constructor() {
+        super();
+
+        this.listenForInsertions();
+
+        (this as Container<{}, {}>)
+            .add({
+                '@sern/errors': () => new DefaultServices.DefaultErrorHandling(),
+                '@sern/emitter': () => new SernEmitter(),
+                '@sern/store': () => new ModuleStore(),
+            })
+            .add(ctx => {
+                return {
+                    '@sern/modules': () =>
+                        new DefaultServices.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', 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;
+    }
+    ready() {
+        this.ready$.unsubscribe();
+    }
+}

src/core/ioc/dependency-injection.ts

@@ -0,0 +1,90 @@
+import type { CoreDependencies, DependencyConfiguration, IntoDependencies } from '../../types/ioc';
+import { SernError, DefaultServices } from '../_internal';
+import { useContainerRaw } from './base';
+import { CoreContainer } from './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;
+}
+/**
+ * The new Service api, a cleaner alternative to useContainer
+ * To obtain intellisense, ensure a .d.ts file exists in the root of compilation.
+ * Usually our scaffolding tool takes care of this.
+ * @since 3.0.0
+ * @example
+ * ```ts
+ * const client = Service('@sern/client');
+ * ```
+ * @param key a key that corresponds to a dependency registered.
+ *
+ */
+export function Service<const T extends keyof Dependencies>(key: T) {
+    return useContainerRaw().get(key)!;
+}
+/**
+ * @since 3.0.0
+ * The plural version of {@link Service}
+ * @returns array of dependencies, in the same order of keys provided
+ */
+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 DefaultServices.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,2 @@
+export { useContainerRaw, makeDependencies } from './base';
+export { Service, Services, single, transient } from './dependency-injection';

src/core/module-loading.ts

@@ -0,0 +1,141 @@
+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 assert from 'assert';
+import { createRequire } from 'node:module';
+import type { ImportPayload, Wrapper } from '../types/core';
+import type { Module } from '../types/core-modules';
+
+export type ModuleResult<T> = Promise<ImportPayload<T>>;
+
+/**
+ * Import any module based on the absolute path.
+ * This can accept four types of exported modules
+ * commonjs, javascript :
+ * ```js
+ * exports = commandModule({ })
+ *
+ * //or
+ * exports.default = commandModule({ })
+ * ```
+ * esm javascript, typescript, and commonjs typescript
+ * export default commandModule({})
+ */
+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)?',
+    );
+    if ('default' in module) {
+        module = module.default;
+    }
+    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)?",
+    );
+    return { 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<ImportPayload<T>> {
+    return from(input).pipe(mergeMap(defaultModuleLoader<T>));
+}
+
+export const getFullPathTree = (dir: string, mode: boolean) => readPaths(resolve(dir), mode);
+
+export const filename = (path: string) => fmtFileName(basename(path));
+
+const isSkippable = (filename: string) => {
+    //empty string is for non extension files (directories)
+    const validExtensions = ['.js', '.cjs', '.mts', '.mjs', '.cts', '.ts', ''];
+    return filename[0] === '!' || !validExtensions.includes(extname(filename));
+};
+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);
+            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);
+                }
+            } else {
+                if (isSkippable(base)) {
+                    if (shouldDebug) console.info(`ignored: ${fullPath}`);
+                } else {
+                    yield 'file:///' + fullPath;
+                }
+            }
+        }
+    } catch (err) {
+        throw err;
+    }
+}
+
+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,
+        };
+    }
+    return wrapper;
+}

src/core/modules.ts

@@ -0,0 +1,112 @@
+import { ClientEvents } from 'discord.js';
+import { CommandType, EventType, PluginType } from '../core/structures';
+import type {
+    AnyCommandPlugin,
+    AnyEventPlugin,
+    CommandArgs,
+    ControlPlugin,
+    EventArgs,
+    InitPlugin,
+} from '../types/core-plugin';
+import type {
+    CommandModule,
+    EventModule,
+    InputCommand,
+    InputEvent,
+    Module,
+} from '../types/core-modules';
+import { partitionPlugins } from './_internal';
+import type { Awaitable } from '../types/utility';
+
+/**
+ * @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/core/operators.ts

@@ -0,0 +1,71 @@
+/**
+ * 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.
+ */
+import {
+    concatMap,
+    defaultIfEmpty,
+    EMPTY,
+    every,
+    fromEvent,
+    map,
+    Observable,
+    of,
+    OperatorFunction,
+    pipe,
+    share,
+} from 'rxjs';
+import { Emitter, ErrorHandling, Logging } from './contracts';
+import util from 'node:util';
+import type { PluginResult, VoidResult } from '../types/core-plugin';
+/**
+ * if {src} is true, mapTo V, else ignore
+ * @param item
+ */
+export function filterMapTo<V>(item: () => V): OperatorFunction<boolean, V> {
+    return concatMap(shouldKeep => (shouldKeep ? of(item()) : EMPTY));
+}
+
+/**
+ * Calls any plugin with {args}.
+ * @param args if an array, its spread and plugin called.
+ */
+export function callPlugin(args: unknown): OperatorFunction<
+    {
+        execute: (...args: unknown[]) => PluginResult;
+    },
+    VoidResult
+> {
+    return concatMap(async plugin => {
+        if (Array.isArray(args)) {
+            return plugin.execute(...args);
+        }
+        return plugin.execute(args);
+    });
+}
+
+export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]) : [src]));
+
+/**
+ * Checks if the stream of results is all ok.
+ */
+export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
+    every(result => result.ok),
+    defaultIfEmpty(true),
+);
+
+export const sharedEventStream = <T>(e: Emitter, 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 type {
+    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/context.ts

@@ -0,0 +1,95 @@
+import {
+    BaseInteraction,
+    ChatInputCommandInteraction,
+    Client,
+    InteractionReplyOptions,
+    Message,
+    MessageReplyOptions,
+    Snowflake,
+    User,
+} from 'discord.js';
+import { CoreContext } from '../structures/core-context';
+import { Result, Ok, Err } from 'ts-results-es';
+import * as assert from 'assert';
+
+type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;
+
+/**
+ * @since 1.0.0
+ * Provides values shared between
+ * Message and ChatInputCommandInteraction
+ */
+export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
+    /*
+     * @Experimental
+     */
+    get options() {
+        return this.interaction.options;
+    }
+    protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
+        super(ctx);
+    }
+
+    public get id(): Snowflake {
+        return this.ctx.val.id;
+    }
+
+    public get channel() {
+        return this.ctx.val.channel;
+    }
+    /**
+     * 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));
+    }
+
+    public get createdTimestamp(): number {
+        return this.ctx.val.createdTimestamp;
+    }
+
+    public get guild() {
+        return this.ctx.val.guild;
+    }
+
+    public get guildId() {
+        return this.ctx.val.guildId;
+    }
+    /*
+     * interactions can return APIGuildMember if the guild it is emitted from is not cached
+     */
+    public get member() {
+        return this.ctx.val.member;
+    }
+
+    public get client(): Client {
+        return this.ctx.val.client;
+    }
+
+    public get inGuild(): boolean {
+        return this.ctx.val.inGuild();
+    }
+
+    public async reply(content: ReplyOptions) {
+        return safeUnwrap(
+            this.ctx
+                .map(m => m.reply(content as string | MessageReplyOptions))
+                .mapErr(i =>
+                    i.reply(content as string | InteractionReplyOptions).then(() => i.fetchReply()),
+                ),
+        );
+    }
+
+    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,32 @@
+import { Result as Either } from 'ts-results-es';
+import { SernError } from '../_internal';
+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;
+
+    static wrap(_: unknown): unknown {
+        throw Error('You need to override this method; cannot wrap an abstract class');
+    }
+}

src/core/structures/enums.ts

@@ -0,0 +1,142 @@
+/**
+ * @since 1.0.0
+ * A bitfield that discriminates command modules
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default commandModule({
+ *     // highlight-next-line
+ *     type : CommandType.Text,
+ *     name : 'a text command'
+ *     execute(message) {
+ *         console.log(message.content)
+ *     }
+ * })
+ * ```
+ */
+export enum CommandType {
+    Text = 1 << 0,
+    Slash = 1 << 1,
+    Both = 3,
+    CtxUser = 1 << 2,
+    CtxMsg = 1 << 3,
+    Button = 1 << 4,
+    StringSelect = 1 << 5,
+    Modal = 1 << 6,
+    UserSelect = 1 << 7,
+    RoleSelect = 1 << 8,
+    MentionableSelect = 1 << 9,
+    ChannelSelect = 1 << 10,
+}
+
+/**
+ * A bitfield that discriminates event modules
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default eventModule({
+ *     //highlight-next-line
+ *     type : EventType.Discord,
+ *     name : 'guildMemberAdd'
+ *     execute(member : GuildMember) {
+ *         console.log(member)
+ *     }
+ * })
+ * ```
+ */
+export enum EventType {
+    /**
+     * The EventType for handling discord events
+     */
+    Discord = 1,
+    /**
+     * The EventType for handling sern events
+     */
+    Sern = 2,
+    /**
+     * The EventType for handling external events.
+     * Could be for example, `process` events, database events
+     */
+    External = 3,
+}
+
+/**
+ * A bitfield that discriminates plugins
+ * @enum { number }
+ * @example
+ * ```ts
+ * export default function myPlugin() : EventPlugin<CommandType.Text> {
+ *     //highlight-next-line
+ *     type : PluginType.Event,
+ *     execute([ctx, args], controller) {
+ *         return controller.next();
+ *     }
+ * }
+ * ```
+ */
+export enum PluginType {
+    /**
+     * The PluginType for InitPlugins
+     */
+    Init = 1,
+    /**
+     * The PluginType for EventPlugins
+     */
+    Control = 2,
+}
+/**
+ * @enum { string }
+ */
+export enum PayloadType {
+    /**
+     * The PayloadType for a SernEmitter success event
+     */
+    Success = 'success',
+    /**
+     * The PayloadType for a SernEmitter failure event
+     */
+    Failure = 'failure',
+    /**
+     * The PayloadType for a SernEmitter warning event
+     */
+    Warning = 'warning',
+}
+
+/**
+ * @enum { string }
+ */
+export const enum SernError {
+    /**
+     * Throws when registering an invalid module.
+     * This means it is undefined or an invalid command type was provided
+     */
+    InvalidModuleType = 'Detected an unknown module type',
+    /**
+     * Attempted to lookup module in command module store. Nothing was found!
+     */
+    UndefinedModule = `A module could not be detected`,
+    /**
+     * Attempted to lookup module in command module store. Nothing was found!
+     */
+    MismatchModule = `A module type mismatched with event emitted!`,
+    /**
+     * Unsupported interaction at this moment.
+     */
+    NotSupportedInteraction = `This interaction is not supported.`,
+    /**
+     * One plugin called `controller.stop()` (end command execution / loading)
+     */
+    PluginFailure = `A plugin failed to call controller.next()`,
+    /**
+     * A crash that occurs when accessing an invalid property of Context
+     */
+    MismatchEvent = `You cannot use message when an interaction fired or vice versa`,
+    /**
+     * Unsupported feature attempted to access at this time
+     */
+    NotSupportedYet = `This feature is not supported yet`,
+    /**
+     * Required Dependency not found
+     */
+    MissingRequired = `@sern/client is required but was not found`,
+}

src/core/structures/index.ts

@@ -0,0 +1,5 @@
+export { CommandType, PluginType, PayloadType, EventType } 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 { CommandMeta, Module } from '../../types/core-modules';
+import { CoreModuleStore } from '../contracts';
+
+/*
+ * @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

@@ -0,0 +1,89 @@
+import { EventEmitter } from 'node:events';
+import { PayloadType } from '../../core/structures';
+import { Module } from '../../types/core-modules';
+import { SernEventsMapping, Payload } from '../../types/utility';
+
+/**
+ * @since 1.0.0
+ */
+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
+     * @param listener what to do with the data
+     */
+    public override on<T extends keyof SernEventsMapping>(
+        eventName: T,
+        listener: (...args: SernEventsMapping[T][]) => void,
+    ): this {
+        return super.on(eventName, listener);
+    }
+    /**
+     * Listening to sern events with on. This event stays on until a crash or a normal exit
+     * @param eventName
+     * @param listener what to do with the data
+     */
+    public override once<T extends keyof SernEventsMapping>(
+        eventName: T,
+        listener: (...args: SernEventsMapping[T][]) => void,
+    ): this {
+        return super.once(eventName, listener);
+    }
+    /**
+     * Listening to sern events with on. This event stays on until a crash or a normal exit
+     * @param eventName
+     * @param args the arguments for emitting the eventName
+     */
+    public override emit<T extends keyof SernEventsMapping>(
+        eventName: T,
+        ...args: SernEventsMapping[T]
+    ): boolean {
+        return super.emit(eventName, ...args);
+    }
+    private static payload<T extends Payload>(
+        type: PayloadType,
+        module?: Module,
+        reason?: unknown,
+    ) {
+        return { type, module, reason } as T;
+    }
+
+    /**
+     * Creates a compliant SernEmitter failure payload
+     * @param module
+     * @param reason
+     */
+    static failure(module?: Module, reason?: unknown) {
+        //The generic cast Payload & { type : PayloadType.* } coerces the type to be a failure payload
+        // same goes to the other methods below
+        return SernEmitter.payload<Payload & { type: PayloadType.Failure }>(
+            PayloadType.Failure,
+            module,
+            reason,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module success payload
+     * @param module
+     */
+    static success(module: Module) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Success }>(
+            PayloadType.Success,
+            module,
+        );
+    }
+    /**
+     * Creates a compliant SernEmitter module warning payload
+     * @param reason
+     */
+    static warning(reason: unknown) {
+        return SernEmitter.payload<Payload & { type: PayloadType.Warning }>(
+            PayloadType.Warning,
+            undefined,
+            reason,
+        );
+    }
+}

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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,25 @@
+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();
+    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/structures/services/module-manager.ts

@@ -0,0 +1,50 @@
+import * as Id from '../../../core/id';
+import { CoreModuleStore, ModuleManager } from '../../contracts';
+import { Files } from '../../_internal';
+import { CommandMeta, CommandModule, CommandModuleDefs, Module } from '../../../types/core-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(Id.create(name, commandType));
+        if (!id) {
+            return undefined;
+        }
+        return Files.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 ' + m);
+        }
+        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]) => Files.importModule<CommandModule>(path)),
+        );
+    }
+}