feat: v4 (#361)

* step 1

* Refactorings

* command modules do not depend on anything but itself

* tearing it up

* Remove module store, manager, and Intializable type

* consolidate interfaces in single file

* consolidate default services in single file

* TEAR IT UP

* fix text compile

* the end of sern init??

* Presence namespaced types removed

* internal namespace

* clean up dependencies

* fix test

* fix circular dependency

* still broken but progress

* remove barrel for core/structs

* reffactor

* refactor allat

* more refactoring

* prototyping linking static handler

* cleanup tests, codegen, and importing handler

* some refactor

* generify partition

* for now copy paste new ioc system

* removeiti

* fdsfD

* ensure container is init'd

* fix absPath gen

* working on bun compat

* refactor and clean up and reenter v3 module loading

* dsfsd

* refactor, add cron types, reinstante module loader

* ready handler revamped so much cleaner

* fdssdf

* refactor deps list

* add more tests, polish up ioc

* up to speed with event modules

* i think cron works

* cron works now, poc

* ksdjkldsfld

* updating ioc api, experimenting with cron

* save b4 thunder and lightning

* plugin data reduction & args changes

* freeze module after plugins, updateModule, and more

* simplify plugin args and prepare for reduction among plugins

* add deps to plugin calls and execute

* plugin system loking better, tbd type

* porg

* initplugins inject deps, inconspicuos

* fix faiklling test

* fix initPlugins not reassigning

* parsingParams kinda

* proper mapping

* dynamic customIds

* handling customId params working

* testing n shi

* inlineinignsd

* consolidate fmt

* once on eventModules

* refact,simplf

* readd vitest and Asset fn

* fix typings

* assets fn complete

* more intuitive context.options and Asset typings

* add init hooks not firing

* -file,-updateModule,publish?

* fix: ioc deps not created correctly

* documentation, add json for Asset

* remove asset

* ss

* finish ioc transition

* nvm, now i did

* s

* update locals api, docs, tests

* fix tests

* fix up tests and cleanup

* fix

* Update src/core/functions.ts

Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>

* better documentation

* temp fix

* namespace presence types again

* revising cron modules and better error messages

* scheduler ids

* more descriptive errors

* refactor to not type leak and job cancellation

* refactor n better signatures for task scheduler

* documentation

* fix swap not accepting functions

* change task signature

---------

Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>

src/types/core-modules.ts

@@ -14,17 +14,20 @@ import type {
     StringSelectMenuInteraction,
     UserContextMenuCommandInteraction,
     UserSelectMenuInteraction,
+    ChatInputCommandInteraction,
 } from 'discord.js';
-import { CommandType, Context, EventType } from '../../src/core';
-import { AnyCommandPlugin, AnyEventPlugin, ControlPlugin, InitPlugin } from './core-plugin';
-import { Awaitable, Args, SlashOptions, SernEventsMapping } from './utility';
+import type { CommandType, EventType } from '../core/structures/enums';
+import { Context } from '../core/structures/context'
+import { ControlPlugin, InitPlugin, Plugin } from './core-plugin';
+import { Awaitable, SernEventsMapping, UnpackedDependencies } from './utility';
 
-
-export interface CommandMeta {
-    fullPath: string;
-    id: string;
-    isClass: boolean;
-}
+//state, deps, type (very original)
+export type SDT = {
+    state: Record<string,unknown>;
+    deps: Dependencies;
+    type: CommandType,
+    params?: string
+};
 
 export type Processed<T> = T & { name: string; description: string };
 
@@ -34,6 +37,11 @@ export interface Module {
     onEvent: ControlPlugin[];
     plugins: InitPlugin[];
     description?: string;
+    meta: {
+        id: string;
+        absPath: string;
+    }
+    locals: Record<string,unknown>
     execute(...args: any[]): Awaitable<any>;
 }
 
@@ -43,6 +51,7 @@ export interface SernEventCommand<T extends keyof SernEventsMapping = keyof Sern
     type: EventType.Sern;
     execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
 }
+
 export interface ExternalEventCommand extends Module {
     name?: string;
     emitter: keyof Dependencies;
@@ -50,54 +59,54 @@ export interface ExternalEventCommand extends Module {
     execute(...args: unknown[]): Awaitable<unknown>;
 }
 
+
 export interface ContextMenuUser extends Module {
     type: CommandType.CtxUser;
-    execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
+    execute: (ctx: UserContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ContextMenuMsg extends Module {
     type: CommandType.CtxMsg;
-    execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
+    execute: (ctx: MessageContextMenuCommandInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ButtonCommand extends Module {
     type: CommandType.Button;
-    execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
+    execute: (ctx: ButtonInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface StringSelectCommand extends Module {
     type: CommandType.StringSelect;
-    execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: StringSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ChannelSelectCommand extends Module {
     type: CommandType.ChannelSelect;
-    execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: ChannelSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface RoleSelectCommand extends Module {
     type: CommandType.RoleSelect;
-    execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: RoleSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface MentionableSelectCommand extends Module {
     type: CommandType.MentionableSelect;
-    execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: MentionableSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface UserSelectCommand extends Module {
     type: CommandType.UserSelect;
-    execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
+    execute: (ctx: UserSelectMenuInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface ModalSubmitCommand extends Module {
     type: CommandType.Modal;
-    execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
+    execute: (ctx: ModalSubmitInteraction, tbd: SDT) => Awaitable<unknown>;
 }
 
-export interface AutocompleteCommand
-    extends Omit<Module, 'name' | 'type' | 'plugins' | 'description'> {
-    onEvent: ControlPlugin[];
+export interface AutocompleteCommand {
+    onEvent?: ControlPlugin[];
     execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
 }
 
@@ -109,26 +118,24 @@ export interface DiscordEventCommand<T extends keyof ClientEvents = keyof Client
 }
 export interface TextCommand extends Module {
     type: CommandType.Text;
-    alias?: string[];
-    execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
+    execute: (ctx: Context & { get options(): string[] }, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface SlashCommand extends Module {
     type: CommandType.Slash;
     description: string;
     options?: SernOptionsData[];
-    execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
+    execute: (ctx: Context  & { get options(): ChatInputCommandInteraction['options']}, tbd: SDT) => Awaitable<unknown>;
 }
 
 export interface BothCommand extends Module {
     type: CommandType.Both;
-    alias?: string[];
     description: string;
     options?: SernOptionsData[];
-    execute: (ctx: Context, args: Args) => Awaitable<unknown>;
+    execute: (ctx: Context, tbd: SDT) => Awaitable<unknown>;
 }
 
-export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
+export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;  
 export type CommandModule =
     | TextCommand
     | SlashCommand
@@ -143,7 +150,6 @@ export type CommandModule =
     | RoleSelectCommand
     | ModalSubmitCommand;
 
-export type AnyModule = CommandModule | EventModule;
 //https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
 // Explicit Module Definitions for mapping
 export interface CommandModuleDefs {
@@ -178,19 +184,22 @@ export interface SernAutocompleteData
 }
 
 type CommandModuleNoPlugins = {
-    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
+    [T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'>;
 };
 type EventModulesNoPlugins = {
-    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
+    [T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent' | 'meta' | 'locals'> ;
 };
 
 export type InputEvent = {
-    [T in EventType]: EventModulesNoPlugins[T] & { plugins?: AnyEventPlugin[] };
+    [T in EventType]: EventModulesNoPlugins[T] & {
+        once?: boolean;
+        plugins?: InitPlugin[] 
+    };
 }[EventType];
 
 export type InputCommand = {
     [T in CommandType]: CommandModuleNoPlugins[T] & {
-        plugins?: AnyCommandPlugin[];
+        plugins?: Plugin[];
     };
 }[CommandType];
 
@@ -213,3 +222,37 @@ export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsDa
     type: ApplicationCommandOptionType.SubcommandGroup;
     options?: SernSubCommandData[];
 }
+
+
+export interface ScheduledTaskContext {
+     
+    /**
+     * the uuid of the current task being run
+     */
+    id: string;
+    /**
+     * the last time this task was executed. If this is the first time, it is null.
+     */
+    lastTimeExecution: Date | null;
+    /**
+      * The next time this task will be executed.
+      */
+    nextTimeExecution: Date | null;
+}
+
+//name subject to change
+interface TaskAttrs {
+    /**
+     * An object of dependencies configured in `makeDependencies`
+     */
+    deps: UnpackedDependencies
+}
+
+export interface ScheduledTask {
+    name?: string;
+    trigger: string | Date;
+    timezone?: string;
+    execute(tasks: ScheduledTaskContext, sdt: TaskAttrs): Awaitable<void>
+}
+
+

src/types/core-plugin.ts

@@ -11,34 +11,18 @@
  * Plugins are reminiscent of middleware in express.
  */
 
-import type { Err, Ok, Result } from 'ts-results-es';
+import type { Result } from 'ts-results-es';
 import type {
-    BothCommand,
-    ButtonCommand,
-    ChannelSelectCommand,
-    CommandModule,
-    ContextMenuMsg,
-    ContextMenuUser,
-    DiscordEventCommand,
-    EventModule,
-    ExternalEventCommand,
-    MentionableSelectCommand,
-    ModalSubmitCommand,
     Module,
     Processed,
-    RoleSelectCommand,
-    SernEventCommand,
-    SlashCommand,
-    StringSelectCommand,
-    TextCommand,
-    UserSelectCommand,
+    SDT,
 } from './core-modules';
-import type { Args, Awaitable, Payload, SlashOptions } from './utility';
-import type { CommandType, Context, EventType, PluginType } from '../core';
+import type { Awaitable } from './utility';
+import type { CommandType, PluginType } from '../core/structures/enums'
+import type { Context } from '../core/structures/context'
 import type {
     ButtonInteraction,
     ChannelSelectMenuInteraction,
-    ClientEvents,
     MentionableSelectMenuInteraction,
     MessageContextMenuCommandInteraction,
     ModalSubmitInteraction,
@@ -48,106 +32,40 @@ import type {
     UserSelectMenuInteraction,
 } from 'discord.js';
 
-export type PluginResult = Awaitable<VoidResult>;
-export type VoidResult = Result<void, void>;
-
-export interface InitArgs<T extends Processed<Module>> {
+export type PluginResult = Awaitable<Result<Record<string,unknown>|undefined, string|undefined>>;
+export interface InitArgs<T extends Processed<Module> = Processed<Module>> {
     module: T;
     absPath: string;
-}
-export interface Controller {
-    next: () => Ok<void>;
-    stop: () => Err<void>;
+    deps: Dependencies
 }
 export interface Plugin<Args extends any[] = any[]> {
     type: PluginType;
     execute: (...args: Args) => PluginResult;
 }
 
-export interface InitPlugin<Args extends any[] = any[]> {
+export interface InitPlugin<Args extends any[] = any[]> extends Plugin<Args> {
     type: PluginType.Init;
     execute: (...args: Args) => PluginResult;
 }
-export interface ControlPlugin<Args extends any[] = any[]> {
+export interface ControlPlugin<Args extends any[] = any[]> extends Plugin<Args> {
     type: PluginType.Control;
-    execute: (...args: Args) => PluginResult;
 }
 
-export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
-export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;
+export type AnyPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<Module>>]>;
 
-export type CommandArgs<
-    I extends CommandType = CommandType,
-    J extends PluginType = PluginType,
-> = CommandArgsMatrix[I][J];
-
-export type EventArgs<
-    I extends EventType = EventType,
-    J extends PluginType = PluginType,
-> = EventArgsMatrix[I][J];
+export type CommandArgs<I extends CommandType = CommandType> = CommandArgsMatrix[I]
 
 interface CommandArgsMatrix {
-    [CommandType.Text]: {
-        [PluginType.Control]: [Context, ['text', string[]]];
-        [PluginType.Init]: [InitArgs<Processed<TextCommand>>];
-    };
-    [CommandType.Slash]: {
-        [PluginType.Control]: [Context, ['slash', /* library coupled */ SlashOptions]];
-        [PluginType.Init]: [InitArgs<Processed<SlashCommand>>];
-    };
-    [CommandType.Both]: {
-        [PluginType.Control]: [Context, Args];
-        [PluginType.Init]: [InitArgs<Processed<BothCommand>>];
-    };
-    [CommandType.CtxMsg]: {
-        [PluginType.Control]: [/* library coupled */ MessageContextMenuCommandInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ContextMenuMsg>>];
-    };
-    [CommandType.CtxUser]: {
-        [PluginType.Control]: [/* library coupled */ UserContextMenuCommandInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ContextMenuUser>>];
-    };
-    [CommandType.Button]: {
-        [PluginType.Control]: [/* library coupled */ ButtonInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ButtonCommand>>];
-    };
-    [CommandType.StringSelect]: {
-        [PluginType.Control]: [/* library coupled */ StringSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<StringSelectCommand>>];
-    };
-    [CommandType.RoleSelect]: {
-        [PluginType.Control]: [/* library coupled */ RoleSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<RoleSelectCommand>>];
-    };
-    [CommandType.ChannelSelect]: {
-        [PluginType.Control]: [/* library coupled */ ChannelSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ChannelSelectCommand>>];
-    };
-    [CommandType.MentionableSelect]: {
-        [PluginType.Control]: [/* library coupled */ MentionableSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<MentionableSelectCommand>>];
-    };
-    [CommandType.UserSelect]: {
-        [PluginType.Control]: [/* library coupled */ UserSelectMenuInteraction];
-        [PluginType.Init]: [InitArgs<Processed<UserSelectCommand>>];
-    };
-    [CommandType.Modal]: {
-        [PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
-        [PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
-    };
-}
-
-interface EventArgsMatrix {
-    [EventType.Discord]: {
-        [PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
-        [PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
-    };
-    [EventType.Sern]: {
-        [PluginType.Control]: [Payload];
-        [PluginType.Init]: [InitArgs<Processed<SernEventCommand>>];
-    };
-    [EventType.External]: {
-        [PluginType.Control]: unknown[];
-        [PluginType.Init]: [InitArgs<Processed<ExternalEventCommand>>];
-    };
+    [CommandType.Text]: [Context, SDT];
+    [CommandType.Slash]: [Context, SDT];
+    [CommandType.Both]: [Context, SDT];
+    [CommandType.CtxMsg]: [MessageContextMenuCommandInteraction, SDT];
+    [CommandType.CtxUser]: [UserContextMenuCommandInteraction, SDT];
+    [CommandType.Button]: [ButtonInteraction, SDT];
+    [CommandType.StringSelect]: [StringSelectMenuInteraction, SDT];
+    [CommandType.RoleSelect]: [RoleSelectMenuInteraction, SDT];
+    [CommandType.ChannelSelect]: [ChannelSelectMenuInteraction, SDT];
+    [CommandType.MentionableSelect]: [MentionableSelectMenuInteraction, SDT];
+    [CommandType.UserSelect]: [UserSelectMenuInteraction, SDT];
+    [CommandType.Modal]: [ModalSubmitInteraction, SDT];
 }

src/types/core.ts

@@ -1,23 +0,0 @@
-
-export interface ImportPayload<T> {
-    module: T;
-    absPath: string;
-    [key: string]: unknown;
-}
-
-export interface Wrapper {
-    commands: string;
-    defaultPrefix?: string;
-    events?: string;
-    /**
-     * Overload to enable mode in case developer does not use a .env file.
-     * @deprecated - https://github.com/sern-handler/handler/pull/325
-     */
-    mode?: string
-    /*
-     * @deprecated
-     */
-    containerConfig?: {
-        get: (...keys: (keyof Dependencies)[]) => unknown[];
-    };
-}

src/types/dependencies.d.ts

@@ -4,9 +4,24 @@
 
 /* eslint-disable @typescript-eslint/consistent-type-imports */
 
-import { CoreDependencies } from './ioc';
+import { CoreDependencies } from '../core/ioc';
 
 declare global {
+   /**
+      * discord.js client. 
+      *   '@sern/client':  Client
+      * sern emitter listens to events that happen throughout
+      * the handler. some include module.register, module.activate.
+      *   '@sern/emitter': Contracts.Emitter;
+      * An error handler which is the final step before 
+      * the sern process actually crashes.
+         '@sern/errors':  Contracts.ErrorHandling;
+      * Optional logger. Performs ... logging
+      *  '@sern/logger'?: Contracts.Logging;
+      * Readonly module store. sern stores these 
+      * by module.meta.id -> Module
+      *  '@sern/modules': Map<string, Module>;
+      */
     interface Dependencies extends CoreDependencies {}
-
 }
+

src/types/ioc.ts

@@ -1,57 +0,0 @@
-import { Container, UnpackFunction } from 'iti';
-import * as Contracts from '../core/contracts';
-/**
-  * Type to annotate that something is a singleton. 
-  * T is created once and lazily.
-  */
-export type Singleton<T> = () => T;
-/**
-  * Type to annotate that something is transient. 
-  * Every time this is called, a new object is created
-  */
-export type Transient<T> = () => () => T;
-/**
-  * Type to annotate that something is initializable. 
-  * If T has an init method, this will be called.
-  */
-export type Initializable<T extends Contracts.Init> = T
-
-export type DependencyList = [
-    Contracts.Emitter,
-    Contracts.ErrorHandling,
-    Contracts.Logging | undefined,
-    Contracts.ModuleManager,
-    Contracts.Emitter,
-];
-
-export interface CoreDependencies {
-    '@sern/client': () => Contracts.Emitter;
-    '@sern/emitter': () => Contracts.Emitter;
-    /**
-      * @deprecated
-      * Will be removed and turned internal
-      */
-    '@sern/store': () => Contracts.CoreModuleStore;
-    '@sern/modules': () => Contracts.ModuleManager;
-    '@sern/errors': () => Contracts.ErrorHandling;
-    '@sern/logger'?: () => Contracts.Logging;
-}
-
-export type DependencyFromKey<T extends keyof Dependencies> = Dependencies[T];
-
-export type IntoDependencies<Tuple extends [...any[]]> = {
-    [Index in keyof Tuple]: UnpackFunction<NonNullable<DependencyFromKey<Tuple[Index]>>>; //Unpack and make NonNullable
-} & { length: Tuple['length'] };
-
-/**
-  * @deprecated This old signature will be incompatible with future versions of sern.
-  */
-export interface DependencyConfiguration {
-    /*
-     * @deprecated. Loggers will be opt-in the future
-     */
-    exclude?: Set<'@sern/logger'>;
-    build: (
-        root: Container<Omit<CoreDependencies, '@sern/client'>, {}>,
-    ) => Container<Dependencies, {}>;
-}

src/types/utility.ts

@@ -1,32 +1,27 @@
-import type { CommandInteractionOptionResolver, InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
-import type { PayloadType } from '../core';
-import type { AnyModule } from './core-modules';
+import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
+import type { Module } from './core-modules';
+import type { Result } from 'ts-results-es';
 
 export type Awaitable<T> = PromiseLike<T> | T;
 
-export type AnyFunction = (...args: unknown[]) => unknown;
-
-// Thanks to @kelsny
-type ParseType<T> = {
-    [K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
-}[keyof T];
-
-export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
-
-export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
+export type VoidResult = Result<void, void>;
+export type AnyFunction = (...args: any[]) => unknown;
 
 export interface SernEventsMapping {
     'module.register': [Payload];
     'module.activate': [Payload];
-    error: [{ type: PayloadType.Failure; module?: AnyModule; reason: string | Error }];
+    error: [{ type: 'failure'; module?: Module; reason: string | Error }];
     warning: [Payload];
     modulesLoaded: [never?];
 }
 
 export type Payload =
-    | { type: PayloadType.Success; module: AnyModule }
-    | { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
-    | { type: PayloadType.Warning; module: undefined; reason: string };
-
+    | { type: 'success'; module: Module }
+    | { type: 'failure'; module?: Module; reason: string | Error }
+    | { type: 'warning'; module: undefined; reason: string };
 
+export type UnpackFunction<T> = T extends (...args: any) => infer U ? U : T
+export type UnpackedDependencies = {
+    [K in keyof Dependencies]: UnpackFunction<Dependencies[K]>
+}
 export type ReplyOptions = string | Omit<InteractionReplyOptions, 'fetchReply'> | MessageReplyOptions;