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>
2026-06-21 23:32:14 +00:00 · 2023-07-29 17:10:19 -05:00
parent 9144485c39
commit 7798e36458
89 changed files with 6229 additions and 2096 deletions
--- a/src/core/structures/context.ts
+++ b/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;
+}
--- a/src/core/structures/core-context.ts
+++ b/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');
+    }
+}
--- a/src/core/structures/enums.ts
+++ b/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`,
+}
--- a/src/core/structures/index.ts
+++ b/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';
--- a/src/core/structures/module-store.ts
+++ b/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>();
+}
--- a/src/core/structures/sern-emitter.ts
+++ b/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,
+        );
+    }
+}
--- a/src/core/structures/services/error-handling.ts
+++ b/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;
+        }
+    }
+}
--- a/src/core/structures/services/index.ts
+++ b/src/core/structures/services/index.ts
@@ -0,0 +1,3 @@
+export * from './error-handling';
+export * from './logger';
+export * from './module-manager';
--- a/src/core/structures/services/logger.ts
+++ b/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}`);
+    }
+}
--- a/src/core/structures/services/module-manager.ts
+++ b/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)),
+        );
+    }
+}