refactor: cleanup (#348)

* some wip code

Co-authored-by: Jacob Nguyen <jacoobes@users.noreply.github.com>

* general idea

* style

* making shrimple truly optional

* got optional localizer working

* proposing api notation?

* prepare for localization map

* add localsFor

* merge some internals

* boss call

* add test for init functionality

* add documentation

* inline and cleanup

* feat: logging for experimental json loading

* loosen typings

* dev workflow and cleaning up comments

* cleaning up a bit more

* rename Localizer -> Localization

* more documentation, change dir for default localizer

* some tests

* "

* move stuff, refactor, deprecate

* yarnb

* Update index.ts

---------

Co-authored-by: Jacob Nguyen <jacoobes@users.noreply.github.com>
Co-authored-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>
Co-authored-by: jacob <jacoobes@sern.dev>

src/core/_internal.ts

@@ -1,6 +1,5 @@
 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';
@@ -8,3 +7,4 @@ export { SernError } from './structures/enums';
 export { ModuleStore } from './structures/module-store';
 export * as DefaultServices from './structures/services';
 export { useContainerRaw } from './ioc/base'
+

src/core/contracts/disposable.ts

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

src/core/contracts/emitter.ts

@@ -1,3 +1,5 @@
+//i deleted it, hmm so how should we allow users to enable localization?
+// a
 import type { AnyFunction } from '../../types/utility';
 
 export interface Emitter {

src/core/contracts/error-handling.ts

@@ -1,5 +1,3 @@
-import type { CommandModule,Processed, EventModule } from "../../types/core-modules";
-
 /**
  * @since 2.0.0
  */

src/core/contracts/hooks.ts

@@ -0,0 +1,16 @@
+
+/**
+ * Represents an initialization contract.
+ * Let dependencies implement this to initiate some logic.
+ */
+export interface Init {
+    init(): unknown;
+}
+
+/**
+ * Represents a Disposable contract.
+ * Let dependencies implement this to dispose and cleanup.
+ */
+export interface Disposable {
+    dispose(): unknown;
+}

src/core/contracts/index.ts

@@ -2,6 +2,5 @@ export * from './error-handling';
 export * from './logging';
 export * from './module-manager';
 export * from './module-store';
-export * from './init';
+export * from './hooks';
 export * from './emitter';
-export * from './disposable'

src/core/contracts/init.ts

@@ -1,9 +0,0 @@
-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/functions.ts

@@ -1,9 +1,19 @@
 import { Err, Ok } from 'ts-results-es';
-import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
-import type { SernAutocompleteData, SernOptionsData } from '../types/core-modules';
+import type { Module, SernAutocompleteData, SernOptionsData } from '../types/core-modules';
 import type { AnyCommandPlugin, AnyEventPlugin, Plugin } from '../types/core-plugin';
-import { PluginType } from './structures';
+import type {
+    AnySelectMenuInteraction,
+    ButtonInteraction,
+    ChatInputCommandInteraction,
+    MessageContextMenuCommandInteraction,
+    ModalSubmitInteraction,
+    UserContextMenuCommandInteraction,
+    AutocompleteInteraction
+} from 'discord.js';
+import { ApplicationCommandOptionType, InteractionType } from 'discord.js'
+import { PayloadType, PluginType } from './structures';
 import assert from 'assert';
+import { Payload } from '../types/utility';
 
 //function wrappers for empty ok / err
 export const ok = /* @__PURE__*/ () => Ok.EMPTY;
@@ -81,3 +91,33 @@ export function treeSearch(
         }
     }
 }
+
+
+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;
+}
+
+export function resultPayload<T extends PayloadType>
+(type: T, module?: Module, reason?: unknown) {
+    return { type, module, reason } as Payload & { type : T };
+}

src/core/ioc/base.ts

@@ -1,11 +1,12 @@
 import * as assert from 'assert';
-import { composeRoot, useContainer } from './dependency-injection';
-import type { DependencyConfiguration } from '../../types/ioc';
+import { useContainer } from './dependency-injection';
+import type { CoreDependencies, DependencyConfiguration } from '../../types/ioc';
 import { CoreContainer } from './container';
-import { Result } from 'ts-results-es'
+import { Result } from 'ts-results-es';
 import { DefaultServices } from '../_internal';
 import { AnyFunction } from '../../types/utility';
 import type { Logging } from '../contracts/logging';
+
 //SIDE EFFECT: GLOBAL DI
 let containerSubject: CoreContainer<Partial<Dependencies>>;
 
@@ -29,19 +30,18 @@ export function disposeAll(logger: Logging|undefined) {
         .then(() => logger?.info({ message: 'Cleaning container and crashing' }));
 }
 
-const dependencyBuilder = (container: any, excluded: string[]) => {
+const dependencyBuilder = (container: any, excluded: string[] ) => {
     type Insertable = 
         | ((container: CoreContainer<Dependencies>) => unknown )
-        | Record<PropertyKey, unknown>
+        | object
     return {
         /**
           * Insert a dependency into your container.
           * Supply the correct key and dependency
           */
         add(key: keyof Dependencies, v: Insertable) {
-            Result
-                .wrap(() => container.add({ [key]: v}))
-                .expect("Failed to add " + key);
+            Result.wrap(() => container.add({ [key]: v}))
+                  .expect("Failed to add " + key);
         },
         /**
           * Exclude any dependencies from being added.
@@ -50,15 +50,15 @@ const dependencyBuilder = (container: any, excluded: string[]) => {
         exclude(...keys: (keyof Dependencies)[]) {
             keys.forEach(key => excluded.push(key));
         },
+        
         /**
           * @param key the key of the dependency
           * @param v The dependency to swap out.
           * Swap out a preexisting dependency.
           */
         swap(key: keyof Dependencies, v: Insertable) {
-            Result
-                .wrap(() => container.upsert({ [key]: v }))
-                .expect("Failed to update " + key);
+            Result.wrap(() => container.upsert({ [key]: v }))
+                  .expect("Failed to update " + key);
         },
         /**
           * @param key the key of the dependency
@@ -70,9 +70,8 @@ const dependencyBuilder = (container: any, excluded: string[]) => {
           * Swap out a preexisting dependency.
           */
         addDisposer(key: keyof Dependencies, cleanup: AnyFunction) {
-            Result
-                .wrap(() => container.addDisposer({ [key] : cleanup }))
-                .expect("Failed to addDisposer for" + key);
+            Result.wrap(() => container.addDisposer({ [key] : cleanup }))
+                  .expect("Failed to addDisposer for" + key);
         }
    };
 };
@@ -87,15 +86,45 @@ export const insertLogger = (containerSubject: CoreContainer<any>) => {
     containerSubject
         .upsert({'@sern/logger': () => new DefaultServices.DefaultLogging});
 }
+
+
+/**
+ * Given the user's conf, check for any excluded/included 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
+ */
+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) {
+        insertLogger(container);
+    }
+    //Build the container based on the callback provided by the user
+    conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
+    
+    if (!hasLogger) {
+        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
+    }
+
+    container.ready();
+}
+
 export async function makeDependencies<const T extends Dependencies>
 (conf: ValidDependencyConfig) {
     containerSubject = new CoreContainer();
     if(typeof conf === 'function') {
         const excluded: string[] = [];
         conf(dependencyBuilder(containerSubject, excluded));
+        
+        const includeLogger = 
+            !excluded.includes('@sern/logger') 
+            && !containerSubject.getTokens()['@sern/logger'];
 
-        if(!excluded.includes('@sern/logger') 
-           && !containerSubject.getTokens()['@sern/logger']) {
+        if(includeLogger) {
             insertLogger(containerSubject);
         }
 
@@ -107,5 +136,3 @@ export async function makeDependencies<const T extends Dependencies>
     return useContainer<T>();
 }
 
-
-

src/core/ioc/container.ts

@@ -1,9 +1,10 @@
 import { Container } from 'iti';
-import { Disposable, SernEmitter } from '../';
+import { Disposable } from '../';
 import * as assert from 'node:assert';
 import { Subject } from 'rxjs';
 import { DefaultServices, ModuleStore } from '../_internal';
-import * as Hooks from './hooks'
+import * as Hooks from './hooks';
+import { EventEmitter } from 'node:events';
 
 
 /**
@@ -17,12 +18,13 @@ export class CoreContainer<T extends Partial<Dependencies>> extends Container<T,
         assert.ok(!this.isReady(), 'Listening for dispose & init should occur prior to sern being ready.');
 
         const { unsubscribe } = Hooks.createInitListener(this);
+
         this.ready$
             .subscribe({ complete: unsubscribe });
 
         (this as Container<{}, {}>)
-            .add({ '@sern/errors': () => new DefaultServices.DefaultErrorHandling(),
-                   '@sern/emitter': () => new SernEmitter,
+            .add({ '@sern/errors': () => new DefaultServices.DefaultErrorHandling,
+                   '@sern/emitter': () => new EventEmitter({ captureRejections: true }),
                    '@sern/store': () => new ModuleStore })
             .add(ctx => {
                 return { '@sern/modules': () =>
@@ -33,19 +35,25 @@ export class CoreContainer<T extends Partial<Dependencies>> extends Container<T,
     isReady() {
         return this.ready$.closed;
     }
+    
+    hasKey(key: string): boolean {
+        return Boolean((this as Container<any,any>)._context[key]);
+    }
 
     override async disposeAll() {
-        
         const otherDisposables = Object
             .entries(this._context)
             .flatMap(([key, value]) => 
                 'dispose' in value ? [key] : []);
-
-        for(const key of otherDisposables) {
+        otherDisposables.forEach(key => { 
+            //possible source of bug: dispose is a property.
             this.addDisposer({ [key]: (dep: Disposable) => dep.dispose() } as never);
-        }
-        await super.disposeAll() 
+        })
+        await super.disposeAll();
     }
+    
+    
+    
     ready() {
         this.ready$.complete();
         this.ready$.unsubscribe();

src/core/ioc/dependency-injection.ts

@@ -1,6 +1,6 @@
-import type { CoreDependencies, DependencyConfiguration, IntoDependencies } from '../../types/ioc';
-import { insertLogger, useContainerRaw } from './base';
-import { CoreContainer } from './container';
+import assert from 'node:assert';
+import type { IntoDependencies } from '../../types/ioc';
+import { useContainerRaw } from './base';
 
 /**
  * @__PURE__
@@ -25,6 +25,7 @@ export function transient<T>(cb: () => () => T) {
  * 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.
+ * Note: this method only works AFTER your container has been initiated
  * @since 3.0.0
  * @example
  * ```ts
@@ -34,7 +35,9 @@ export function transient<T>(cb: () => () => T) {
  *
  */
 export function Service<const T extends keyof Dependencies>(key: T) {
-    return useContainerRaw().get(key)!;
+    const dep = useContainerRaw().get(key)!;
+    assert(dep, "Requested key " + key + " returned undefined");
+    return dep;
 }
 /**
  * @since 3.0.0
@@ -46,32 +49,9 @@ export function Services<const T extends (keyof Dependencies)[]>(...keys: [...T]
     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 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) {
-        insertLogger(container);
-    }
-    //Build the container based on the callback provided by the user
-    conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
-    
-    if (!hasLogger) {
-        container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
-    }
-
-    container.ready();
-}
 
 export function useContainer<const T extends Dependencies>() {
     return <V extends (keyof T)[]>(...keys: [...V]) =>
         keys.map(key => useContainerRaw().get(key as keyof Dependencies)) as IntoDependencies<V>;
 }
+

src/core/ioc/hooks.ts

@@ -9,7 +9,7 @@ type HookName = 'init';
 export const createInitListener = (coreContainer : CoreContainer<any>) => {
     const initCalled = new Set<PropertyKey>();
     const hasCallableMethod = createPredicate(initCalled);
-    const unsubscribe = coreContainer.on('containerUpserted', async (event) => {
+    const unsubscribe = coreContainer.on('containerUpserted', async event => {
        
         if(isNotHookable(event)) {
             return;
@@ -21,6 +21,7 @@ export const createInitListener = (coreContainer : CoreContainer<any>) => {
         }
 
     });
+
     return { unsubscribe };
 }
 

src/core/module-loading.ts

@@ -7,6 +7,7 @@ import { createRequire } from 'node:module';
 import type { ImportPayload, Wrapper } from '../types/core';
 import type { Module } from '../types/core-modules';
 import { existsSync } from 'fs';
+import type { Logging } from './contracts/logging';
 
 export const shouldHandle = (path: string, fpath: string) => {
     const file_name = fpath+extname(path);
@@ -18,6 +19,7 @@ export const shouldHandle = (path: string, fpath: string) => {
 
 
 export type ModuleResult<T> = Promise<ImportPayload<T>>;
+
 /**
  * Import any module based on the absolute path.
  * This can accept four types of exported modules
@@ -104,13 +106,13 @@ async function* readPaths(dir: string): AsyncGenerator<string> {
     }
 }
 
-const requir = createRequire(import.meta.url);
+export const requir = createRequire(import.meta.url);
 
-export function loadConfig(wrapper: Wrapper | 'file'): Wrapper {
+export function loadConfig(wrapper: Wrapper | 'file', log: Logging | undefined): Wrapper {
     if (wrapper !== 'file') {
         return wrapper;
     }
-    console.log('Experimental loading of sern.config.json');
+    log?.info({ message: 'Experimental loading of sern.config.json'});
     const config = requir(resolve('sern.config.json')); 
 
     const makePath = (dir: PropertyKey) =>
@@ -118,14 +120,14 @@ export function loadConfig(wrapper: Wrapper | 'file'): Wrapper {
             ? join('dist', config.paths[dir]!)
             : join(config.paths[dir]!);
  
-    console.log('Loading config: ', config);
+    log?.info({ message: 'Loading config: ' + JSON.stringify(config, null, 4) });
     const commandsPath = makePath('commands');
  
-    console.log('Commands path is set to', commandsPath);
+    log?.info({ message: `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);
+        log?.info({ message: `Events path is set to ${eventsPath} `});
     }
 
     return { defaultPrefix: config.defaultPrefix,

src/core/operators.ts

@@ -71,8 +71,7 @@ export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
 }
 // Temporary until i get rxjs operators working on ts-results-es
 export const filterTap = <K, R>(onErr: (e: R) => void): OperatorFunction<Result<K, R>, K> => 
-    pipe(
-        concatMap(result => {
+    pipe(concatMap(result => {
             if(result.isOk()) {
                 return of(result.value)
             }

src/core/predicates.ts

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

@@ -1,4 +1,4 @@
-import {
+import type {
     BaseInteraction,
     ChatInputCommandInteraction,
     Client,

src/core/structures/index.ts

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

@@ -1,12 +1,11 @@
 import { CommandMeta, Module } from '../../types/core-modules';
-import { CoreModuleStore } from '../contracts';
 
 /*
- * @internal
+ * @deprecated
  * 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 {
+export class ModuleStore {
     metadata = new WeakMap<Module, CommandMeta>();
     commands = new Map<string, string>();
 }

src/core/structures/sern-emitter.ts

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