mirror of
https://github.com/sern-handler/handler
synced 2026-06-27 18:22:14 +00:00
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>
This commit is contained in:
Jacob Nguyen
9
src/core/_internal.ts
Normal file
9
src/core/_internal.ts
Normal file
@@ -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';
|
||||
7
src/core/contracts/emitter.ts
Normal file
7
src/core/contracts/emitter.ts
Normal file
@@ -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;
|
||||
}
|
||||
21
src/core/contracts/error-handling.ts
Normal file
21
src/core/contracts/error-handling.ts
Normal file
@@ -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;
|
||||
}
|
||||
6
src/core/contracts/index.ts
Normal file
6
src/core/contracts/index.ts
Normal file
@@ -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';
|
||||
9
src/core/contracts/init.ts
Normal file
9
src/core/contracts/init.ts
Normal file
@@ -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>;
|
||||
}
|
||||
11
src/core/contracts/logging.ts
Normal file
11
src/core/contracts/logging.ts
Normal file
@@ -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 };
|
||||
22
src/core/contracts/module-manager.ts
Normal file
22
src/core/contracts/module-manager.ts
Normal file
@@ -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;
|
||||
}
|
||||
9
src/core/contracts/module-store.ts
Normal file
9
src/core/contracts/module-store.ts
Normal file
@@ -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>;
|
||||
}
|
||||
@@ -1,8 +1,7 @@
|
||||
import { CommandType, EventType, PluginType } from '../structures';
|
||||
import type { Plugin, PluginResult } from '../../types/plugin';
|
||||
import type { CommandArgs, EventArgs } from './args';
|
||||
import { CommandType, EventType, PluginType } from './structures';
|
||||
import type { Plugin, PluginResult, EventArgs, CommandArgs } from '../types/core-plugin';
|
||||
import type { ClientEvents } from 'discord.js';
|
||||
export const guayin = Symbol('twice<3');
|
||||
|
||||
export function makePlugin<V extends unknown[]>(
|
||||
type: PluginType,
|
||||
execute: (...args: any[]) => any,
|
||||
@@ -10,12 +9,11 @@ export function makePlugin<V extends unknown[]>(
|
||||
return {
|
||||
type,
|
||||
execute,
|
||||
[guayin]: undefined,
|
||||
} as Plugin<V>;
|
||||
}
|
||||
/**
|
||||
* @since 2.5.0
|
||||
*
|
||||
* @__PURE__
|
||||
*/
|
||||
export function EventInitPlugin<I extends EventType>(
|
||||
execute: (...args: EventArgs<I, PluginType.Init>) => PluginResult,
|
||||
@@ -24,7 +22,7 @@ export function EventInitPlugin<I extends EventType>(
|
||||
}
|
||||
/**
|
||||
* @since 2.5.0
|
||||
*
|
||||
* @__PURE__
|
||||
*/
|
||||
export function CommandInitPlugin<I extends CommandType>(
|
||||
execute: (...args: CommandArgs<I, PluginType.Init>) => PluginResult,
|
||||
@@ -33,7 +31,7 @@ export function CommandInitPlugin<I extends CommandType>(
|
||||
}
|
||||
/**
|
||||
* @since 2.5.0
|
||||
*
|
||||
* @__PURE__
|
||||
*/
|
||||
export function CommandControlPlugin<I extends CommandType>(
|
||||
execute: (...args: CommandArgs<I, PluginType.Control>) => PluginResult,
|
||||
@@ -42,7 +40,7 @@ export function CommandControlPlugin<I extends CommandType>(
|
||||
}
|
||||
/**
|
||||
* @since 2.5.0
|
||||
*
|
||||
* @__PURE__
|
||||
*/
|
||||
export function EventControlPlugin<I extends EventType>(
|
||||
execute: (...args: EventArgs<I, PluginType.Control>) => PluginResult,
|
||||
83
src/core/functions.ts
Normal file
83
src/core/functions.ts
Normal file
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
63
src/core/id.ts
Normal file
63
src/core/id.ts
Normal file
@@ -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);
|
||||
}
|
||||
4
src/core/index.ts
Normal file
4
src/core/index.ts
Normal file
@@ -0,0 +1,4 @@
|
||||
export * from './contracts';
|
||||
export * from './create-plugins';
|
||||
export * from './structures';
|
||||
export * from './ioc';
|
||||
34
src/core/ioc/base.ts
Normal file
34
src/core/ioc/base.ts
Normal file
@@ -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>();
|
||||
}
|
||||
67
src/core/ioc/container.ts
Normal file
67
src/core/ioc/container.ts
Normal file
@@ -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();
|
||||
}
|
||||
}
|
||||
90
src/core/ioc/dependency-injection.ts
Normal file
90
src/core/ioc/dependency-injection.ts
Normal file
@@ -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>;
|
||||
}
|
||||
2
src/core/ioc/index.ts
Normal file
2
src/core/ioc/index.ts
Normal file
@@ -0,0 +1,2 @@
|
||||
export { useContainerRaw, makeDependencies } from './base';
|
||||
export { Service, Services, single, transient } from './dependency-injection';
|
||||
141
src/core/module-loading.ts
Normal file
141
src/core/module-loading.ts
Normal file
@@ -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;
|
||||
}
|
||||
112
src/core/modules.ts
Normal file
112
src/core/modules.ts
Normal file
@@ -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>;
|
||||
}
|
||||
71
src/core/operators.ts
Normal file
71
src/core/operators.ts
Normal file
@@ -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;
|
||||
};
|
||||
}
|
||||
34
src/core/predicates.ts
Normal file
34
src/core/predicates.ts
Normal file
@@ -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;
|
||||
}
|
||||
@@ -1,42 +1,33 @@
|
||||
import type {
|
||||
import {
|
||||
BaseInteraction,
|
||||
ChatInputCommandInteraction,
|
||||
Client,
|
||||
InteractionReplyOptions,
|
||||
Message,
|
||||
Snowflake,
|
||||
MessageReplyOptions,
|
||||
Snowflake,
|
||||
User,
|
||||
} from 'discord.js';
|
||||
import { Result as Either, Ok as Left, Err as Right } from 'ts-results-es';
|
||||
import type { ReplyOptions } from '../../types/handler';
|
||||
import { SernError } from './errors';
|
||||
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;
|
||||
|
||||
function safeUnwrap<T>(res: Either<T, T>) {
|
||||
return res.val;
|
||||
}
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* Provides values shared between
|
||||
* Message and ChatInputCommandInteraction
|
||||
*/
|
||||
export default class Context {
|
||||
private constructor(private ctx: Either<Message, ChatInputCommandInteraction>) {}
|
||||
|
||||
/**
|
||||
* Getting the Message object. Crashes if module type is
|
||||
* CommandType.Slash or the event fired in a Both command was
|
||||
* ChatInputCommandInteraction
|
||||
export class Context extends CoreContext<Message, ChatInputCommandInteraction> {
|
||||
/*
|
||||
* @Experimental
|
||||
*/
|
||||
public get message() {
|
||||
return this.ctx.expect(SernError.MismatchEvent);
|
||||
get options() {
|
||||
return this.interaction.options;
|
||||
}
|
||||
/**
|
||||
* Getting the ChatInputCommandInteraction object. Crashes if module type is
|
||||
* CommandType.Text or the event fired in a Both command was
|
||||
* Message
|
||||
*/
|
||||
public get interaction() {
|
||||
return this.ctx.expectErr(SernError.MismatchEvent);
|
||||
protected constructor(protected ctx: Result<Message, ChatInputCommandInteraction>) {
|
||||
super(ctx);
|
||||
}
|
||||
|
||||
public get id(): Snowflake {
|
||||
@@ -65,7 +56,6 @@ export default class Context {
|
||||
public get guildId() {
|
||||
return this.ctx.val.guildId;
|
||||
}
|
||||
|
||||
/*
|
||||
* interactions can return APIGuildMember if the guild it is emitted from is not cached
|
||||
*/
|
||||
@@ -80,22 +70,8 @@ export default class Context {
|
||||
public get inGuild(): boolean {
|
||||
return this.ctx.val.inGuild();
|
||||
}
|
||||
public isMessage() {
|
||||
return this.ctx.map(() => true).unwrapOr(false);
|
||||
}
|
||||
|
||||
public isSlash() {
|
||||
return !this.isMessage();
|
||||
}
|
||||
|
||||
static wrap(wrappable: ChatInputCommandInteraction | Message): Context {
|
||||
if ('token' in wrappable) {
|
||||
return new Context(Right(wrappable));
|
||||
}
|
||||
return new Context(Left(wrappable));
|
||||
}
|
||||
|
||||
public reply(content: ReplyOptions) {
|
||||
public async reply(content: ReplyOptions) {
|
||||
return safeUnwrap(
|
||||
this.ctx
|
||||
.map(m => m.reply(content as string | MessageReplyOptions))
|
||||
@@ -104,4 +80,16 @@ export default class Context {
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
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;
|
||||
}
|
||||
32
src/core/structures/core-context.ts
Normal file
32
src/core/structures/core-context.ts
Normal file
@@ -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');
|
||||
}
|
||||
}
|
||||
@@ -15,45 +15,18 @@
|
||||
* ```
|
||||
*/
|
||||
export enum CommandType {
|
||||
/**
|
||||
* The CommandType for text commands
|
||||
*/
|
||||
Text = 1,
|
||||
/**
|
||||
* The CommandType for slash commands
|
||||
*/
|
||||
Slash = 2,
|
||||
/**
|
||||
* The CommandType for hybrid commands, text and slash
|
||||
*/
|
||||
Text = 1 << 0,
|
||||
Slash = 1 << 1,
|
||||
Both = 3,
|
||||
/**
|
||||
* The CommandType for UserContextMenuInteraction commands
|
||||
*/
|
||||
CtxUser = 4,
|
||||
/**
|
||||
* The CommandType for MessageContextMenuInteraction commands
|
||||
*/
|
||||
CtxMsg = 8,
|
||||
/**
|
||||
* The CommandType for ButtonInteraction commands
|
||||
*/
|
||||
Button = 16,
|
||||
/**
|
||||
* The CommandType for StringSelectMenuInteraction commands
|
||||
*/
|
||||
StringSelect = 32,
|
||||
/**
|
||||
* The CommandType for ModalSubmitInteraction commands
|
||||
*/
|
||||
Modal = 64,
|
||||
/**
|
||||
* The CommandType for the other SelectMenuInteractions
|
||||
*/
|
||||
ChannelSelect = 256,
|
||||
MentionableSelect = 512,
|
||||
RoleSelect = 1024,
|
||||
UserSelect = 2048,
|
||||
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,
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -106,16 +79,6 @@ export enum PluginType {
|
||||
* The PluginType for InitPlugins
|
||||
*/
|
||||
Init = 1,
|
||||
/**
|
||||
* @deprecated
|
||||
* Use PluginType.Init instead
|
||||
*/
|
||||
Command = 1,
|
||||
/**
|
||||
* @deprecated
|
||||
* Use PluginType.Control instead
|
||||
*/
|
||||
Event = 2,
|
||||
/**
|
||||
* The PluginType for EventPlugins
|
||||
*/
|
||||
@@ -138,3 +101,42 @@ export enum PayloadType {
|
||||
*/
|
||||
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`,
|
||||
}
|
||||
5
src/core/structures/index.ts
Normal file
5
src/core/structures/index.ts
Normal file
@@ -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';
|
||||
12
src/core/structures/module-store.ts
Normal file
12
src/core/structures/module-store.ts
Normal file
@@ -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>();
|
||||
}
|
||||
@@ -1,12 +1,15 @@
|
||||
import { EventEmitter } from 'events';
|
||||
import type { Payload, SernEventsMapping } from '../types/handler';
|
||||
import { PayloadType } from './structures';
|
||||
import type { Module } from '../types/module';
|
||||
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
|
||||
*/
|
||||
class SernEmitter extends EventEmitter {
|
||||
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
|
||||
@@ -84,5 +87,3 @@ class SernEmitter extends EventEmitter {
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
export default SernEmitter;
|
||||
21
src/core/structures/services/error-handling.ts
Normal file
21
src/core/structures/services/error-handling.ts
Normal file
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
3
src/core/structures/services/index.ts
Normal file
3
src/core/structures/services/index.ts
Normal file
@@ -0,0 +1,3 @@
|
||||
export * from './error-handling';
|
||||
export * from './logger';
|
||||
export * from './module-manager';
|
||||
@@ -1,15 +1,9 @@
|
||||
import type { LogPayload } from '../../types/handler';
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface Logging<T = unknown> {
|
||||
error(payload: LogPayload<T>): void;
|
||||
warning(payload: LogPayload<T>): void;
|
||||
info(payload: LogPayload<T>): void;
|
||||
debug(payload: LogPayload<T>): void;
|
||||
}
|
||||
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();
|
||||
50
src/core/structures/services/module-manager.ts
Normal file
50
src/core/structures/services/module-manager.ts
Normal file
@@ -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)),
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
import type { Observable } from 'rxjs';
|
||||
import type { Logging } from './logging';
|
||||
import util from 'util';
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface ErrorHandling {
|
||||
/**
|
||||
* Number of times the process should throw an error until crashing and exiting
|
||||
*/
|
||||
keepAlive: number;
|
||||
|
||||
/**
|
||||
* Utility function to crash
|
||||
* @param error
|
||||
*/
|
||||
crash(error: Error): never;
|
||||
|
||||
/**
|
||||
* A function that is called on every crash. Updates keepAlive
|
||||
* @param error
|
||||
*/
|
||||
updateAlive(error: Error): void;
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export class DefaultErrorHandling implements ErrorHandling {
|
||||
keepAlive = 5;
|
||||
crash(error: Error): never {
|
||||
throw error;
|
||||
}
|
||||
updateAlive(_: Error) {
|
||||
this.keepAlive--;
|
||||
}
|
||||
}
|
||||
|
||||
export function handleError<C>(crashHandler: ErrorHandling, logging?: Logging) {
|
||||
return (pload: unknown, caught: Observable<C>) => {
|
||||
// This is done to fit the ErrorHandling contract
|
||||
const err = pload instanceof Error ? pload : Error(util.format(pload));
|
||||
if (crashHandler.keepAlive == 0) {
|
||||
crashHandler.crash(err);
|
||||
}
|
||||
//formatted payload
|
||||
logging?.error({ message: util.format(pload) });
|
||||
crashHandler.updateAlive(err);
|
||||
return caught;
|
||||
};
|
||||
}
|
||||
@@ -1,3 +0,0 @@
|
||||
export { ErrorHandling, DefaultErrorHandling } from './errorHandling';
|
||||
export { Logging, DefaultLogging } from './logging';
|
||||
export { ModuleManager, DefaultModuleManager } from './moduleManager';
|
||||
@@ -1,27 +0,0 @@
|
||||
import type { CommandModuleDefs } from '../../types/module';
|
||||
import type { CommandType, ModuleStore } from '../structures';
|
||||
import type { Processed } from '../../types/handler';
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export interface ModuleManager {
|
||||
get<T extends CommandType>(
|
||||
strat: (ms: ModuleStore) => Processed<CommandModuleDefs[T]> | undefined,
|
||||
): Processed<CommandModuleDefs[T]> | undefined;
|
||||
set(strat: (ms: ModuleStore) => void): void;
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
*/
|
||||
export class DefaultModuleManager implements ModuleManager {
|
||||
constructor(private moduleStore: ModuleStore) {}
|
||||
get<T extends CommandType>(
|
||||
strat: (ms: ModuleStore) => Processed<CommandModuleDefs[T]> | undefined,
|
||||
) {
|
||||
return strat(this.moduleStore);
|
||||
}
|
||||
|
||||
set(strat: (ms: ModuleStore) => void): void {
|
||||
strat(this.moduleStore);
|
||||
}
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
export { single, transient, many } from './lifetimeFunctions';
|
||||
export { useContainerRaw } from './provider';
|
||||
@@ -1,63 +0,0 @@
|
||||
import { _const } from '../utilities/functions';
|
||||
|
||||
type NotFunction =
|
||||
| string
|
||||
| number
|
||||
| boolean
|
||||
| null
|
||||
| undefined
|
||||
| bigint
|
||||
| readonly any[]
|
||||
| { apply?: never; [k: string]: any }
|
||||
| { call?: never; [k: string]: any };
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
* @param cb
|
||||
*/
|
||||
export function single<T extends NotFunction>(cb: T): () => T;
|
||||
/**
|
||||
* New signature
|
||||
* @since 2.0.0
|
||||
* @param cb
|
||||
*/
|
||||
export function single<T extends () => unknown>(cb: T): T;
|
||||
/**
|
||||
* @__PURE__
|
||||
* @since 2.0.0.
|
||||
* Please note that on intellij, the deprecation is for all signatures, which is unintended behavior (and
|
||||
* very annoying).
|
||||
* For future versions, ensure that single is being passed as a **callback!!**
|
||||
* @param cb
|
||||
*/
|
||||
export function single<T>(cb: T) {
|
||||
if (typeof cb === 'function') return cb;
|
||||
return () => cb;
|
||||
}
|
||||
/**
|
||||
* @deprecated
|
||||
* @param cb
|
||||
* Deprecated signature
|
||||
*/
|
||||
export function transient<T extends NotFunction>(cb: T): () => () => T;
|
||||
export function transient<T extends () => () => unknown>(cb: T): T;
|
||||
/**
|
||||
* @__PURE__
|
||||
* @since 2.0.0
|
||||
* Following iti's singleton and transient implementation,
|
||||
* use transient if you want a new dependency every time your container getter is called
|
||||
* @param cb
|
||||
*/
|
||||
export function transient<T>(cb: (() => () => T) | T) {
|
||||
if (typeof cb !== 'function') return () => () => cb;
|
||||
return cb;
|
||||
}
|
||||
|
||||
/**
|
||||
* @__PURE__
|
||||
* @deprecated
|
||||
* @param value
|
||||
* Please use the transient function instead
|
||||
*/
|
||||
// prettier-ignore
|
||||
export const many = <T>(value: T) => () => _const(value);
|
||||
@@ -1,86 +0,0 @@
|
||||
import type { Container } from 'iti';
|
||||
import type { Dependencies, DependencyConfiguration, MapDeps } from '../../types/handler';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import { DefaultErrorHandling, DefaultLogging, DefaultModuleManager } from '../contracts';
|
||||
import { Result } from 'ts-results-es';
|
||||
import { BehaviorSubject } from 'rxjs';
|
||||
import { createContainer } from 'iti';
|
||||
import { type Wrapper, ModuleStore, SernError } from '../structures';
|
||||
|
||||
export const containerSubject = new BehaviorSubject(defaultContainer());
|
||||
|
||||
/**
|
||||
* 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<T extends Dependencies>(conf: DependencyConfiguration<T>) {
|
||||
//Get the current container. This should have no client or possible logger yet.
|
||||
const currentContainer = containerSubject.getValue();
|
||||
const excludeLogger = conf.exclude?.has('@sern/logger');
|
||||
if (!excludeLogger) {
|
||||
currentContainer.add({
|
||||
'@sern/logger': () => new DefaultLogging(),
|
||||
});
|
||||
}
|
||||
//Build the container based on the callback provided by the user
|
||||
const container = conf.build(currentContainer);
|
||||
//Check if the built container contains @sern/client or throw
|
||||
// a runtime exception
|
||||
Result.wrap(() => container.get('@sern/client')).expect(SernError.MissingRequired);
|
||||
|
||||
if (!excludeLogger) {
|
||||
container.get('@sern/logger')?.info({ message: 'All dependencies loaded successfully.' });
|
||||
}
|
||||
//I'm sorry little one
|
||||
containerSubject.next(container as any);
|
||||
}
|
||||
|
||||
export function useContainer<T extends Dependencies>() {
|
||||
const container = containerSubject.getValue() as Container<T, {}>;
|
||||
return <V extends (keyof T)[]>(...keys: [...V]) =>
|
||||
keys.map(key => Result.wrap(() => container.get(key)).unwrapOr(undefined)) as MapDeps<T, V>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the underlying data structure holding all dependencies.
|
||||
* Please be careful as this only gets the client's current state.
|
||||
* Exposes some methods from iti
|
||||
*/
|
||||
export function useContainerRaw<T extends Dependencies>() {
|
||||
return containerSubject.getValue() as Container<T, {}>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Provides all the defaults for sern to function properly.
|
||||
* The only user provided dependency needs to be @sern/client
|
||||
*/
|
||||
function defaultContainer() {
|
||||
return createContainer()
|
||||
.add({ '@sern/errors': () => new DefaultErrorHandling() })
|
||||
.add({ '@sern/store': () => new ModuleStore() })
|
||||
.add(ctx => {
|
||||
return {
|
||||
'@sern/modules': () => new DefaultModuleManager(ctx['@sern/store']),
|
||||
};
|
||||
})
|
||||
.add({ '@sern/emitter': () => new SernEmitter() }) as Container<
|
||||
Omit<Dependencies, '@sern/client' | '@sern/logger'>,
|
||||
{}
|
||||
>;
|
||||
}
|
||||
|
||||
export function makeFetcher(wrapper: Wrapper) {
|
||||
const requiredDependencyKeys = [
|
||||
'@sern/emitter',
|
||||
'@sern/client',
|
||||
'@sern/errors',
|
||||
'@sern/logger',
|
||||
] as ['@sern/emitter', '@sern/client', '@sern/errors', '@sern/logger'];
|
||||
return <Keys extends (keyof Dependencies)[]>(otherKeys: [...Keys]) =>
|
||||
wrapper.containerConfig.get(...requiredDependencyKeys, ...otherKeys) as MapDeps<
|
||||
Dependencies,
|
||||
[...typeof requiredDependencyKeys, ...Keys]
|
||||
>;
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
import type { Processed } from '../../../types/handler';
|
||||
import type { AutocompleteInteraction } from 'discord.js';
|
||||
import { SernError } from '../../structures';
|
||||
import treeSearch from '../../utilities/treeSearch';
|
||||
import type { BothCommand, CommandModule, Module, SlashCommand } from '../../../types/module';
|
||||
import { EventEmitter } from 'events';
|
||||
import * as assert from 'assert';
|
||||
import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
|
||||
import { arrayifySource, callPlugin } from '../operators';
|
||||
import { createResultResolver } from '../observableHandling';
|
||||
|
||||
export function dispatchCommand(module: Processed<CommandModule>, createArgs: () => unknown[]) {
|
||||
const args = createArgs();
|
||||
return {
|
||||
module,
|
||||
args,
|
||||
};
|
||||
}
|
||||
|
||||
function intoPayload(module: Processed<Module>) {
|
||||
return pipe(
|
||||
arrayifySource,
|
||||
map(args => ({ module, args })),
|
||||
);
|
||||
}
|
||||
|
||||
const createResult = createResultResolver<
|
||||
Processed<Module>,
|
||||
{ module: Processed<Module>; args: unknown[] },
|
||||
unknown[]
|
||||
>({
|
||||
createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
|
||||
onNext: ({ args }) => args,
|
||||
});
|
||||
/**
|
||||
* Creates an observable from { source }
|
||||
* @param module
|
||||
* @param source
|
||||
*/
|
||||
export function eventDispatcher(module: Processed<Module>, source: unknown) {
|
||||
assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
|
||||
|
||||
const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
|
||||
module.execute(...args),
|
||||
);
|
||||
return fromEvent(source, module.name).pipe(
|
||||
intoPayload(module),
|
||||
concatMap(createResult),
|
||||
execute,
|
||||
);
|
||||
}
|
||||
|
||||
export function dispatchAutocomplete(
|
||||
module: Processed<BothCommand | SlashCommand>,
|
||||
interaction: AutocompleteInteraction,
|
||||
) {
|
||||
const option = treeSearch(interaction, module.options);
|
||||
if (option !== undefined) {
|
||||
return {
|
||||
module: option.command as Processed<Module>, //autocomplete is not a true "module" warning cast!
|
||||
args: [interaction],
|
||||
};
|
||||
}
|
||||
throw Error(
|
||||
SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`,
|
||||
);
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
import type { ChatInputCommandInteraction, Interaction, Message } from 'discord.js';
|
||||
import { Context } from '../../structures';
|
||||
import type { Args, SlashOptions } from '../../../types/handler';
|
||||
|
||||
/**
|
||||
* function overloads to create an arguments list for Context
|
||||
* @param wrap
|
||||
* @param messageArgs
|
||||
*/
|
||||
export function contextArgs(
|
||||
wrap: Message,
|
||||
messageArgs?: string[],
|
||||
): () => [Context, ['text', string[]]];
|
||||
export function contextArgs(wrap: Interaction): () => [Context, ['slash', SlashOptions]];
|
||||
export function contextArgs(wrap: Interaction | Message, messageArgs?: string[]) {
|
||||
const ctx = Context.wrap(wrap as ChatInputCommandInteraction | Message);
|
||||
const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.interaction.options];
|
||||
return () => [ctx, args] as [Context, Args];
|
||||
}
|
||||
|
||||
export function interactionArg<T extends Interaction>(interaction: T) {
|
||||
return () => [interaction] as [T];
|
||||
}
|
||||
@@ -1,118 +0,0 @@
|
||||
import { Interaction } from 'discord.js';
|
||||
import {
|
||||
catchError,
|
||||
concatMap,
|
||||
EMPTY,
|
||||
filter,
|
||||
finalize,
|
||||
fromEvent,
|
||||
map,
|
||||
Observable,
|
||||
of,
|
||||
OperatorFunction,
|
||||
pipe,
|
||||
} from 'rxjs';
|
||||
import { CommandType, type ModuleStore, SernError } from '../structures';
|
||||
import { contextArgs, dispatchAutocomplete, dispatchCommand, interactionArg } from './dispatchers';
|
||||
import { executeModule, makeModuleExecutor } from './observableHandling';
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import { ErrorHandling, handleError } from '../contracts/errorHandling';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import type { Processed } from '../../types/handler';
|
||||
import { useContainerRaw } from '../dependencies';
|
||||
import type { Logging, ModuleManager } from '../contracts';
|
||||
import type { EventEmitter } from 'node:events';
|
||||
|
||||
function makeInteractionProcessor(
|
||||
modules: ModuleManager,
|
||||
): OperatorFunction<Interaction, { module: Processed<CommandModule>; event: Interaction }> {
|
||||
const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
|
||||
return modules.get(cb);
|
||||
};
|
||||
return pipe(
|
||||
concatMap(event => {
|
||||
if (event.isMessageComponent()) {
|
||||
const customId = event.customId;
|
||||
const module = get(ms => {
|
||||
return ms.InteractionHandlers[event.componentType].get(customId);
|
||||
});
|
||||
return of({ module, event });
|
||||
} else if (event.isCommand() || event.isAutocomplete()) {
|
||||
const commandName = event.commandName;
|
||||
const module = get(
|
||||
ms =>
|
||||
/**
|
||||
* try to fetch from ApplicationCommands, if nothing, try BothCommands
|
||||
* exists on the API but not sern
|
||||
*/
|
||||
ms.ApplicationCommands[event.commandType].get(commandName) ??
|
||||
ms.BothCommands.get(commandName),
|
||||
);
|
||||
return of({ module, event });
|
||||
} else if (event.isModalSubmit()) {
|
||||
const module = get(ms => ms.ModalSubmit.get(event.customId));
|
||||
return of({ module, event });
|
||||
} else return EMPTY;
|
||||
}),
|
||||
filter(m => m.module !== undefined),
|
||||
) as OperatorFunction<Interaction, { module: Processed<CommandModule>; event: Interaction }>;
|
||||
}
|
||||
|
||||
export function makeInteractionCreate([s, client, err, log, modules]: [
|
||||
SernEmitter,
|
||||
EventEmitter,
|
||||
ErrorHandling,
|
||||
Logging | undefined,
|
||||
ModuleManager,
|
||||
]) {
|
||||
//map. If nothing again,this means a slash command
|
||||
const interactionStream$ = fromEvent(client, 'interactionCreate') as Observable<Interaction>;
|
||||
const interactionProcessor = makeInteractionProcessor(modules);
|
||||
return interactionStream$
|
||||
.pipe(
|
||||
interactionProcessor,
|
||||
map(createDispatcher),
|
||||
makeModuleExecutor(module => {
|
||||
s.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
|
||||
}),
|
||||
concatMap(module => executeModule(s, module)),
|
||||
catchError(handleError(err, log)),
|
||||
finalize(() => {
|
||||
log?.info({
|
||||
message: 'interactionCreate stream closed or reached end of lifetime',
|
||||
});
|
||||
useContainerRaw()
|
||||
?.disposeAll()
|
||||
.then(() => log?.info({ message: 'Cleaning container and crashing' }));
|
||||
}),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
|
||||
function createDispatcher({
|
||||
module,
|
||||
event,
|
||||
}: {
|
||||
event: Interaction;
|
||||
module: Processed<CommandModule>;
|
||||
}) {
|
||||
switch (module.type) {
|
||||
case CommandType.Text:
|
||||
throw Error(SernError.MismatchEvent);
|
||||
case CommandType.Slash:
|
||||
case CommandType.Both: {
|
||||
if (event.isAutocomplete()) {
|
||||
/**
|
||||
* Autocomplete is a special case that
|
||||
* must be handled separately, since it's
|
||||
* too different from regular command modules
|
||||
*/
|
||||
return dispatchAutocomplete(module, event);
|
||||
} else {
|
||||
return dispatchCommand(module, contextArgs(event));
|
||||
}
|
||||
}
|
||||
default:
|
||||
return dispatchCommand(module, interactionArg(event));
|
||||
}
|
||||
}
|
||||
@@ -1,92 +0,0 @@
|
||||
import { catchError, concatMap, EMPTY, finalize, fromEvent, map, Observable, of, pipe } from 'rxjs';
|
||||
import { type ModuleStore, SernError } from '../structures';
|
||||
import type { Message } from 'discord.js';
|
||||
import { executeModule, ignoreNonBot, makeModuleExecutor } from './observableHandling';
|
||||
import type { CommandModule, TextCommand } from '../../types/module';
|
||||
import { ErrorHandling, handleError } from '../contracts/errorHandling';
|
||||
import { contextArgs, dispatchCommand } from './dispatchers';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import type { Processed } from '../../types/handler';
|
||||
import { useContainerRaw } from '../dependencies';
|
||||
import type { Logging, ModuleManager } from '../contracts';
|
||||
import type { EventEmitter } from 'node:events';
|
||||
|
||||
/**
|
||||
* Removes the first character(s) _[depending on prefix length]_ of the message
|
||||
* @param msg
|
||||
* @param prefix The prefix to remove
|
||||
* @returns The message without the prefix
|
||||
* @example
|
||||
* message.content = '!ping';
|
||||
* console.log(fmt(message, '!'));
|
||||
* // [ 'ping' ]
|
||||
*/
|
||||
export function fmt(msg: string, prefix: string): string[] {
|
||||
return msg.slice(prefix.length).trim().split(/\s+/g);
|
||||
}
|
||||
|
||||
/**
|
||||
* An operator function that processes a message to fetch a command module and prepares context payload.
|
||||
* @param defaultPrefix
|
||||
* @param get
|
||||
*/
|
||||
const createMessageProcessor = (
|
||||
defaultPrefix: string,
|
||||
get: (
|
||||
cb: (ms: ModuleStore) => Processed<CommandModule> | undefined,
|
||||
) => CommandModule | undefined,
|
||||
) =>
|
||||
pipe(
|
||||
ignoreNonBot(defaultPrefix),
|
||||
//This concatMap checks if module is undefined, and if it is, do not continue.
|
||||
// Synonymous to filterMap, but I haven't thought of a generic implementation for filterMap yet
|
||||
concatMap(message => {
|
||||
const [prefix, ...rest] = fmt(message.content, defaultPrefix);
|
||||
const module = get(ms => ms.TextCommands.get(prefix) ?? ms.BothCommands.get(prefix));
|
||||
if (module === undefined) {
|
||||
return EMPTY;
|
||||
}
|
||||
const payload = {
|
||||
args: contextArgs(message, rest),
|
||||
module,
|
||||
};
|
||||
return of(payload);
|
||||
}),
|
||||
map(({ args, module }) => dispatchCommand(module as Processed<TextCommand>, args)),
|
||||
);
|
||||
|
||||
export function makeMessageCreate(
|
||||
[s, client, err, log, modules]: [
|
||||
SernEmitter,
|
||||
EventEmitter,
|
||||
ErrorHandling,
|
||||
Logging | undefined,
|
||||
ModuleManager,
|
||||
],
|
||||
defaultPrefix?: string,
|
||||
) {
|
||||
if (!defaultPrefix) {
|
||||
return EMPTY.subscribe();
|
||||
}
|
||||
const get = (cb: (ms: ModuleStore) => Processed<CommandModule> | undefined) => {
|
||||
return modules.get(cb);
|
||||
};
|
||||
const messageStream$ = fromEvent(client, 'messageCreate') as Observable<Message>;
|
||||
const messageProcessor = createMessageProcessor(defaultPrefix, get);
|
||||
return messageStream$
|
||||
.pipe(
|
||||
messageProcessor,
|
||||
makeModuleExecutor(module => {
|
||||
s.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
|
||||
}),
|
||||
concatMap(payload => executeModule(s, payload)),
|
||||
catchError(handleError(err, log)),
|
||||
finalize(() => {
|
||||
log?.info({ message: 'messageCreate stream closed or reached end of lifetime' });
|
||||
useContainerRaw()
|
||||
?.disposeAll()
|
||||
.then(() => log?.info({ message: 'Cleaning container and crashing' }));
|
||||
}),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
@@ -1,121 +0,0 @@
|
||||
import type { Awaitable, Message } from 'discord.js';
|
||||
import { concatMap, EMPTY, filter, from, Observable, of, tap, throwError } from 'rxjs';
|
||||
import { Result } from 'ts-results-es';
|
||||
import type { CommandModule, EventModule, Module } from '../../types/module';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import { callPlugin, everyPluginOk, filterMapTo } from './operators';
|
||||
import type { ImportPayload, Processed } from '../../types/handler';
|
||||
import type { ControlPlugin, VoidResult } from '../../types/plugin';
|
||||
|
||||
function hasPrefix(prefix: string, content: string) {
|
||||
const prefixInContent = content.slice(0, prefix.length);
|
||||
return prefixInContent.localeCompare(prefix, undefined, { sensitivity: 'accent' }) === 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ignores messages from any person / bot except itself
|
||||
* @param prefix
|
||||
*/
|
||||
export function ignoreNonBot(prefix: string) {
|
||||
const messageFromHumanAndHasPrefix = ({ author, content }: Message) =>
|
||||
!author.bot && hasPrefix(prefix, content);
|
||||
return filter(messageFromHumanAndHasPrefix);
|
||||
}
|
||||
|
||||
/**
|
||||
* Wraps the task in a Result as a try / catch.
|
||||
* if the task is ok, an event is emitted and the stream becomes empty
|
||||
* if the task is an error, throw an error down the stream which will be handled by catchError
|
||||
* @param emitter reference to SernEmitter that will emit a successful execution of module
|
||||
* @param module the module that will be executed with task
|
||||
* @param task the deferred execution which will be called
|
||||
*/
|
||||
export function executeModule(
|
||||
emitter: SernEmitter,
|
||||
{
|
||||
module,
|
||||
task,
|
||||
}: {
|
||||
module: Processed<Module>;
|
||||
task: () => Awaitable<unknown>;
|
||||
},
|
||||
) {
|
||||
return of(module).pipe(
|
||||
//converting the task into a promise so rxjs can resolve the Awaitable properly
|
||||
concatMap(() => Result.wrapAsync(async () => task())),
|
||||
concatMap(result => {
|
||||
if (result.ok) {
|
||||
emitter.emit('module.activate', SernEmitter.success(module));
|
||||
return EMPTY;
|
||||
} else {
|
||||
return throwError(() => SernEmitter.failure(module, result.val));
|
||||
}
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* A higher order function that
|
||||
* - creates a stream of {@link VoidResult} { config.createStream }
|
||||
* - any failures results to { config.onFailure } being called
|
||||
* - if all results are ok, the stream is converted to { config.onSuccess }
|
||||
* emit config.onSuccess Observable
|
||||
* @param config
|
||||
* @returns receiver function for flattening a stream of data
|
||||
*/
|
||||
export function createResultResolver<
|
||||
T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
|
||||
Args extends { module: T; [key: string]: unknown },
|
||||
Output,
|
||||
>(config: {
|
||||
onStop?: (module: T) => unknown;
|
||||
onNext: (args: Args) => Output;
|
||||
createStream: (args: Args) => Observable<VoidResult>;
|
||||
}) {
|
||||
return (args: Args) => {
|
||||
const task$ = config.createStream(args);
|
||||
return task$.pipe(
|
||||
tap(result => {
|
||||
if (result.err) {
|
||||
config.onStop?.(args.module);
|
||||
}
|
||||
}),
|
||||
everyPluginOk,
|
||||
filterMapTo(() => config.onNext(args)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Calls a module's init plugins and checks for Err. If so, call { onStop } and
|
||||
* ignore the module
|
||||
*/
|
||||
export function callInitPlugins<
|
||||
T extends Processed<CommandModule | EventModule>,
|
||||
Args extends ImportPayload<T>,
|
||||
>(config: { onStop?: (module: T) => unknown; onNext: (module: Args) => T }) {
|
||||
return concatMap(
|
||||
createResultResolver({
|
||||
createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
|
||||
...config,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an executable task ( execute the command ) if all control plugins are successful
|
||||
* @param onStop emits a failure response to the SernEmitter
|
||||
*/
|
||||
export function makeModuleExecutor<
|
||||
M extends Processed<Module>,
|
||||
Args extends { module: M; args: unknown[] },
|
||||
>(onStop: (m: M) => unknown) {
|
||||
const onNext = ({ args, module }: Args) => ({ task: () => module.execute(...args), module });
|
||||
return concatMap(
|
||||
createResultResolver({
|
||||
onStop,
|
||||
createStream: ({ args, module }) => from(module.onEvent).pipe(callPlugin(args)),
|
||||
onNext,
|
||||
}),
|
||||
);
|
||||
}
|
||||
@@ -1,82 +0,0 @@
|
||||
/**
|
||||
* 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, map, of, OperatorFunction, pipe } from 'rxjs';
|
||||
import type { AnyModule } from '../../../types/module';
|
||||
import { nameOrFilename } from '../../utilities/functions';
|
||||
import type { PluginResult, VoidResult } from '../../../types/plugin';
|
||||
import { guayin } from '../../plugins';
|
||||
import { controller } from '../../sern';
|
||||
import { Result } from 'ts-results-es';
|
||||
import { ImportPayload, Processed } from '../../../types/handler';
|
||||
/**
|
||||
* 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 => {
|
||||
const isNewPlugin = Reflect.has(plugin, guayin);
|
||||
if (isNewPlugin) {
|
||||
if (Array.isArray(args)) {
|
||||
return plugin.execute(...args);
|
||||
}
|
||||
return plugin.execute(args);
|
||||
} else {
|
||||
return plugin.execute(args, controller);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
export const arrayifySource = map(src => (Array.isArray(src) ? (src as unknown[]) : [src]));
|
||||
|
||||
export const fillDefaults = <T extends AnyModule>({ module, absPath }: ImportPayload<T>) => {
|
||||
return {
|
||||
absPath,
|
||||
module: {
|
||||
name: nameOrFilename(module?.name, absPath),
|
||||
description: module?.description ?? '...',
|
||||
...module,
|
||||
},
|
||||
};
|
||||
};
|
||||
|
||||
/**
|
||||
* If the current value in Result stream is an error, calls callback.
|
||||
* This also extracts the Ok value from Result
|
||||
* @param cb
|
||||
* @returns Observable<{ module: T; absPath: string }>
|
||||
*/
|
||||
export function errTap<Ok, Err>(cb: (err: Err) => void): OperatorFunction<Result<Ok, Err>, Ok> {
|
||||
return concatMap(result => {
|
||||
if (result.ok) {
|
||||
return of(result.val);
|
||||
} else {
|
||||
cb(result.val as Err);
|
||||
return EMPTY;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the stream of results is all ok.
|
||||
*/
|
||||
export const everyPluginOk: OperatorFunction<VoidResult, boolean> = pipe(
|
||||
every(result => result.ok),
|
||||
defaultIfEmpty(true),
|
||||
);
|
||||
@@ -1,106 +0,0 @@
|
||||
import { fromEvent, map, pipe, switchMap, take } from 'rxjs';
|
||||
import * as Files from '../module-loading/readFile';
|
||||
import { callInitPlugins } from './observableHandling';
|
||||
import { CommandType, type ModuleStore, SernError } from '../structures';
|
||||
import { Result } from 'ts-results-es';
|
||||
import { ApplicationCommandType, ComponentType } from 'discord.js';
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import type { Processed } from '../../types/handler';
|
||||
import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
|
||||
import { err, ok } from '../utilities/functions';
|
||||
import { errTap, fillDefaults } from './operators';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import type { EventEmitter } from 'node:events';
|
||||
|
||||
function buildCommandModules(commandDir: string, sernEmitter: SernEmitter) {
|
||||
return pipe(
|
||||
switchMap(() => Files.buildModuleStream<CommandModule>(commandDir)),
|
||||
errTap(error => {
|
||||
sernEmitter.emit('module.register', SernEmitter.failure(undefined, error));
|
||||
}),
|
||||
map(fillDefaults),
|
||||
);
|
||||
}
|
||||
export function makeReadyEvent(
|
||||
[sEmitter, client, errorHandler, , moduleManager]: [
|
||||
SernEmitter,
|
||||
EventEmitter,
|
||||
ErrorHandling,
|
||||
Logging | undefined,
|
||||
ModuleManager,
|
||||
],
|
||||
commandDir: string,
|
||||
) {
|
||||
const readyOnce$ = fromEvent(client, 'ready').pipe(take(1));
|
||||
return readyOnce$
|
||||
.pipe(
|
||||
buildCommandModules(commandDir, sEmitter),
|
||||
callInitPlugins({
|
||||
onStop: module => {
|
||||
sEmitter.emit(
|
||||
'module.register',
|
||||
SernEmitter.failure(module, SernError.PluginFailure),
|
||||
);
|
||||
},
|
||||
onNext: ({ module }) => {
|
||||
sEmitter.emit('module.register', SernEmitter.success(module));
|
||||
return module;
|
||||
},
|
||||
}),
|
||||
)
|
||||
.subscribe(module => {
|
||||
const result = registerModule(moduleManager, module as Processed<CommandModule>);
|
||||
if (result.err) {
|
||||
errorHandler.crash(Error(SernError.InvalidModuleType));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function registerModule<T extends Processed<CommandModule>>(
|
||||
manager: ModuleManager,
|
||||
mod: T,
|
||||
): Result<void, void> {
|
||||
const name = mod.name;
|
||||
const insert = (cb: (ms: ModuleStore) => void) => {
|
||||
const set = Result.wrap(() => manager.set(cb));
|
||||
return set.ok ? ok() : err();
|
||||
};
|
||||
switch (mod.type) {
|
||||
case CommandType.Text: {
|
||||
mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
|
||||
return insert(ms => ms.TextCommands.set(name, mod));
|
||||
}
|
||||
case CommandType.Slash:
|
||||
return insert(ms =>
|
||||
ms.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod),
|
||||
);
|
||||
case CommandType.Both: {
|
||||
mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
|
||||
return insert(ms => ms.BothCommands.set(name, mod));
|
||||
}
|
||||
case CommandType.CtxUser:
|
||||
return insert(ms => ms.ApplicationCommands[ApplicationCommandType.User].set(name, mod));
|
||||
case CommandType.CtxMsg:
|
||||
return insert(ms =>
|
||||
ms.ApplicationCommands[ApplicationCommandType.Message].set(name, mod),
|
||||
);
|
||||
case CommandType.Button:
|
||||
return insert(ms => ms.InteractionHandlers[ComponentType.Button].set(name, mod));
|
||||
case CommandType.StringSelect:
|
||||
return insert(ms => ms.InteractionHandlers[ComponentType.StringSelect].set(name, mod));
|
||||
case CommandType.MentionableSelect:
|
||||
return insert(ms =>
|
||||
ms.InteractionHandlers[ComponentType.MentionableSelect].set(name, mod),
|
||||
);
|
||||
case CommandType.UserSelect:
|
||||
return insert(ms => ms.InteractionHandlers[ComponentType.UserSelect].set(name, mod));
|
||||
case CommandType.ChannelSelect:
|
||||
return insert(ms => ms.InteractionHandlers[ComponentType.ChannelSelect].set(name, mod));
|
||||
case CommandType.RoleSelect:
|
||||
return insert(ms => ms.InteractionHandlers[ComponentType.RoleSelect].set(name, mod));
|
||||
case CommandType.Modal:
|
||||
return insert(ms => ms.ModalSubmit.set(name, mod));
|
||||
default:
|
||||
return err();
|
||||
}
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
import { catchError, finalize, map, mergeAll } from 'rxjs';
|
||||
import * as Files from '../module-loading/readFile';
|
||||
import type { Dependencies, Processed } from '../../types/handler';
|
||||
import { callInitPlugins } from './observableHandling';
|
||||
import type { CommandModule, EventModule } from '../../types/module';
|
||||
import type { EventEmitter } from 'events';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import type { ErrorHandling, Logging } from '../contracts';
|
||||
import { SernError, EventType, type Wrapper } from '../structures';
|
||||
import { eventDispatcher } from './dispatchers';
|
||||
import { handleError } from '../contracts/errorHandling';
|
||||
import { errTap, fillDefaults } from './operators';
|
||||
import { useContainerRaw } from '../dependencies';
|
||||
|
||||
export function makeEventsHandler(
|
||||
[s, client, err, log]: [SernEmitter, EventEmitter, ErrorHandling, Logging | undefined],
|
||||
eventsPath: string,
|
||||
containerGetter: Wrapper['containerConfig'],
|
||||
) {
|
||||
const lazy = (k: string) => containerGetter.get(k as keyof Dependencies)[0];
|
||||
const eventStream$ = eventObservable(eventsPath, s);
|
||||
|
||||
const eventCreation$ = eventStream$.pipe(
|
||||
map(fillDefaults),
|
||||
callInitPlugins({
|
||||
onStop: module =>
|
||||
s.emit('module.register', SernEmitter.failure(module, SernError.PluginFailure)),
|
||||
onNext: ({ module }) => {
|
||||
s.emit('module.register', SernEmitter.success(module));
|
||||
return module;
|
||||
},
|
||||
}),
|
||||
);
|
||||
const intoDispatcher = (e: Processed<EventModule | CommandModule>) => {
|
||||
switch (e.type) {
|
||||
case EventType.Sern:
|
||||
return eventDispatcher(e, s);
|
||||
case EventType.Discord:
|
||||
return eventDispatcher(e, client);
|
||||
case EventType.External:
|
||||
return eventDispatcher(e, lazy(e.emitter));
|
||||
default:
|
||||
return err.crash(
|
||||
Error(SernError.InvalidModuleType + ' while creating event handler'),
|
||||
);
|
||||
}
|
||||
};
|
||||
eventCreation$
|
||||
.pipe(
|
||||
map(intoDispatcher),
|
||||
/**
|
||||
* Where all events are turned on
|
||||
*/
|
||||
mergeAll(),
|
||||
catchError(handleError(err, log)),
|
||||
finalize(() => {
|
||||
log?.info({ message: 'an event module reached end of lifetime' });
|
||||
useContainerRaw()
|
||||
?.disposeAll()
|
||||
.then(() => {
|
||||
log?.info({ message: 'Cleaning container and crashing' });
|
||||
});
|
||||
}),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
|
||||
function eventObservable(events: string, emitter: SernEmitter) {
|
||||
return Files.buildModuleStream<EventModule>(events).pipe(
|
||||
errTap(reason => {
|
||||
emitter.emit('module.register', SernEmitter.failure(undefined, reason));
|
||||
}),
|
||||
);
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
import { readdirSync, statSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import { type Observable, from, mergeMap } from 'rxjs';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { type Result, Err, Ok } from 'ts-results-es';
|
||||
import { ImportPayload } from '../../types/handler';
|
||||
import { pathToFileURL } from 'node:url';
|
||||
|
||||
// Courtesy @Townsy45
|
||||
function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
|
||||
try {
|
||||
const files = readdirSync(dir);
|
||||
for (const file of files) {
|
||||
if (statSync(dir + '/' + file).isDirectory()) readPath(dir + '/' + file, arrayOfFiles);
|
||||
else arrayOfFiles.push(join(dir, '/', file));
|
||||
}
|
||||
} catch (err) {
|
||||
throw err;
|
||||
}
|
||||
|
||||
return arrayOfFiles;
|
||||
}
|
||||
export const fmtFileName = (n: string) => n.substring(0, n.length - 3);
|
||||
// export const isLazy = (n: string) => n.indexOf(".lazy.", n.length-9) !== -1;
|
||||
|
||||
export async function defaultModuleLoader<T>(
|
||||
absPath: string,
|
||||
): Promise<Result<ImportPayload<T>, SernError>> {
|
||||
// prettier-ignore
|
||||
let module: T | undefined
|
||||
/// #if MODE === 'esm'
|
||||
= (await import(pathToFileURL(absPath).toString())).default
|
||||
/// #elif MODE === 'cjs'
|
||||
= require(absPath).default; // eslint-disable-line
|
||||
/// #endif
|
||||
if (module === undefined) {
|
||||
return Err(SernError.UndefinedModule);
|
||||
}
|
||||
try {
|
||||
module = new (module as unknown as new () => T)();
|
||||
} catch {}
|
||||
return Ok({ module, absPath });
|
||||
}
|
||||
|
||||
/**
|
||||
* 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>(
|
||||
commandDir: string,
|
||||
): Observable<Result<ImportPayload<T>, SernError>> {
|
||||
const commands = getCommands(commandDir);
|
||||
return from(commands).pipe(mergeMap(defaultModuleLoader<T>));
|
||||
}
|
||||
|
||||
export function fullPathFrom(dir: string) {
|
||||
return join(process.cwd(), dir);
|
||||
}
|
||||
|
||||
export function getCommands(dir: string): string[] {
|
||||
return readPath(fullPathFrom(dir));
|
||||
}
|
||||
@@ -1,2 +0,0 @@
|
||||
export { EventArgs, InitArgs, CommandArgs } from './args';
|
||||
export * from './createPlugin';
|
||||
@@ -1,138 +0,0 @@
|
||||
import type Wrapper from './structures/wrapper';
|
||||
import { makeEventsHandler } from './events/userDefinedEventsHandling';
|
||||
import { CommandType, EventType, PluginType } from './structures/enums';
|
||||
import type { AnyEventPlugin, ControlPlugin, InitPlugin, Plugin } from '../types/plugin';
|
||||
import { makeInteractionCreate } from './events/interactionHandler';
|
||||
import { makeReadyEvent } from './events/readyHandler';
|
||||
import { makeMessageCreate } from './events/messageHandler';
|
||||
import type {
|
||||
CommandModule,
|
||||
CommandModuleDefs,
|
||||
EventModule,
|
||||
EventModuleDefs,
|
||||
InputCommand,
|
||||
InputEvent,
|
||||
} from '../types/module';
|
||||
import type { Dependencies, DependencyConfiguration } from '../types/handler';
|
||||
import { composeRoot, makeFetcher, useContainer } from './dependencies/provider';
|
||||
import type { Logging } from './contracts';
|
||||
import { err, ok, partition } from './utilities/functions';
|
||||
import type { Awaitable, ClientEvents } from 'discord.js';
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* @param wrapper Options to pass into sern.
|
||||
* Function to start the handler up
|
||||
* @example
|
||||
* ```ts title="src/index.ts"
|
||||
* Sern.init({
|
||||
* defaultPrefix: '!',
|
||||
* commands: 'dist/commands',
|
||||
* events: 'dist/events',
|
||||
* containerConfig : {
|
||||
* get: useContainer
|
||||
* }
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
export function init(wrapper: Wrapper) {
|
||||
const logger = wrapper.containerConfig.get('@sern/logger')[0] as Logging | undefined;
|
||||
const requiredDependenciesAnd = makeFetcher(wrapper);
|
||||
const startTime = performance.now();
|
||||
const { events } = wrapper;
|
||||
if (events !== undefined) {
|
||||
makeEventsHandler(requiredDependenciesAnd([]), events, wrapper.containerConfig);
|
||||
}
|
||||
const dependencies = requiredDependenciesAnd(['@sern/modules']);
|
||||
makeReadyEvent(dependencies, wrapper.commands);
|
||||
makeMessageCreate(dependencies, wrapper.defaultPrefix);
|
||||
makeInteractionCreate(dependencies);
|
||||
const endTime = performance.now();
|
||||
logger?.info({ message: `sern : ${(endTime - startTime).toFixed(2)} ms` });
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* The object passed into every plugin to control a command's behavior
|
||||
*/
|
||||
export const controller = {
|
||||
next: ok,
|
||||
stop: err,
|
||||
};
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* The wrapper function to define command modules for sern
|
||||
* @param mod
|
||||
*/
|
||||
export function commandModule(mod: InputCommand): CommandModule {
|
||||
const [onEvent, plugins] = partition(
|
||||
mod.plugins ?? [],
|
||||
el => (el as Plugin).type === PluginType.Control,
|
||||
);
|
||||
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] = partition(
|
||||
mod.plugins ?? [],
|
||||
el => (el as Plugin).type === PluginType.Control,
|
||||
);
|
||||
return {
|
||||
...mod,
|
||||
onEvent,
|
||||
plugins,
|
||||
} as EventModule;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create event modules from discord.js client events,
|
||||
* This is an {@link eventModule} for discord events,
|
||||
* where typings can be very bad.
|
||||
* @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 });
|
||||
}
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* @param conf a configuration for creating your project dependencies
|
||||
*/
|
||||
export function makeDependencies<T extends Dependencies>(conf: DependencyConfiguration<T>) {
|
||||
//Until there are more optional dependencies, just check if the logger exists
|
||||
composeRoot(conf);
|
||||
return useContainer<T>();
|
||||
}
|
||||
|
||||
/**
|
||||
* @Experimental
|
||||
* Will be refactored / changed in future
|
||||
*/
|
||||
export abstract class CommandExecutable<Type extends CommandType> {
|
||||
abstract type: Type;
|
||||
plugins: InitPlugin[] = [];
|
||||
onEvent: ControlPlugin[] = [];
|
||||
abstract execute: CommandModuleDefs[Type]['execute'];
|
||||
}
|
||||
/**
|
||||
* @Experimental
|
||||
* Will be refactored in future
|
||||
*/
|
||||
export abstract class EventExecutable<Type extends EventType> {
|
||||
abstract type: Type;
|
||||
plugins: InitPlugin[] = [];
|
||||
onEvent: ControlPlugin[] = [];
|
||||
abstract execute: EventModuleDefs[Type]['execute'];
|
||||
}
|
||||
@@ -1,38 +0,0 @@
|
||||
/**
|
||||
* @enum { string }
|
||||
*/
|
||||
export 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`,
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
import Context from './context';
|
||||
import type Wrapper from './wrapper';
|
||||
import { ModuleStore } from './moduleStore';
|
||||
export * from './errors';
|
||||
export * from './enums';
|
||||
export { Context, Wrapper, ModuleStore };
|
||||
@@ -1,27 +0,0 @@
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import { ApplicationCommandType, ComponentType } from 'discord.js';
|
||||
import type { Processed } from '../../types/handler';
|
||||
|
||||
/**
|
||||
* @since 2.0.0
|
||||
* Storing all command modules
|
||||
* This dependency is usually injected into ModuleManager
|
||||
*/
|
||||
export class ModuleStore {
|
||||
readonly BothCommands = new Map<string, Processed<CommandModule>>();
|
||||
readonly ApplicationCommands = {
|
||||
[ApplicationCommandType.User]: new Map<string, Processed<CommandModule>>(),
|
||||
[ApplicationCommandType.Message]: new Map<string, Processed<CommandModule>>(),
|
||||
[ApplicationCommandType.ChatInput]: new Map<string, Processed<CommandModule>>(),
|
||||
};
|
||||
readonly ModalSubmit = new Map<string, Processed<CommandModule>>();
|
||||
readonly TextCommands = new Map<string, Processed<CommandModule>>();
|
||||
readonly InteractionHandlers = {
|
||||
[ComponentType.Button]: new Map<string, Processed<CommandModule>>(),
|
||||
[ComponentType.StringSelect]: new Map<string, Processed<CommandModule>>(),
|
||||
[ComponentType.ChannelSelect]: new Map<string, Processed<CommandModule>>(),
|
||||
[ComponentType.MentionableSelect]: new Map<string, Processed<CommandModule>>(),
|
||||
[ComponentType.RoleSelect]: new Map<string, Processed<CommandModule>>(),
|
||||
[ComponentType.UserSelect]: new Map<string, Processed<CommandModule>>(),
|
||||
};
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
import type { Dependencies } from '../../types/handler';
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* An object to be passed into Sern#init() function.
|
||||
* @typedef {object} Wrapper
|
||||
*/
|
||||
interface Wrapper {
|
||||
/**
|
||||
* @deprecated
|
||||
* This will be moved to a new field in 3.0.0
|
||||
*/
|
||||
readonly defaultPrefix?: string;
|
||||
readonly commands: string;
|
||||
readonly events?: string;
|
||||
readonly containerConfig: {
|
||||
get: (...keys: (keyof Dependencies)[]) => unknown[];
|
||||
};
|
||||
}
|
||||
export default Wrapper;
|
||||
@@ -1,36 +0,0 @@
|
||||
import * as Files from '../module-loading/readFile';
|
||||
import { basename } from 'path';
|
||||
import { Err, Ok } from 'ts-results-es';
|
||||
/**
|
||||
* A function that returns whatever value is provided.
|
||||
* Warning: this evaluates { @param value }. It does not defer a value.
|
||||
* @param value
|
||||
* @__PURE__
|
||||
*/
|
||||
// prettier-ignore
|
||||
export const _const = <T>(value: T) => () => value;
|
||||
/**
|
||||
*
|
||||
* @param modName
|
||||
* @param absPath
|
||||
*/
|
||||
export function nameOrFilename(modName: string | undefined, absPath: string) {
|
||||
return modName ?? Files.fmtFileName(basename(absPath));
|
||||
}
|
||||
|
||||
//function wrappers for empty ok / err
|
||||
export const ok = _const(Ok.EMPTY);
|
||||
export const err = _const(Err.EMPTY);
|
||||
|
||||
export function partition<T, V>(arr: (T & V)[], condition: (e: T & V) => boolean): [T[], V[]] {
|
||||
const t: T[] = [];
|
||||
const v: V[] = [];
|
||||
for (const el of arr) {
|
||||
if (condition(el)) {
|
||||
t.push(el as T);
|
||||
} else {
|
||||
v.push(el as V);
|
||||
}
|
||||
}
|
||||
return [t, v];
|
||||
}
|
||||
@@ -1,54 +0,0 @@
|
||||
import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
|
||||
import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
|
||||
import assert from 'assert';
|
||||
|
||||
/**
|
||||
* Uses an iterative DFS to check if an autocomplete node exists
|
||||
* @param iAutocomplete
|
||||
* @param options
|
||||
*/
|
||||
export default 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;
|
||||
}
|
||||
}}
|
||||
@@ -1,2 +1,2 @@
|
||||
export * from './dispatchers';
|
||||
export * from './provideArgs';
|
||||
export * from './event-utils';
|
||||
117
src/handlers/dispatchers.ts
Normal file
117
src/handlers/dispatchers.ts
Normal file
@@ -0,0 +1,117 @@
|
||||
import { EventEmitter } from 'node:events';
|
||||
import * as assert from 'node:assert';
|
||||
import { concatMap, from, fromEvent, map, OperatorFunction, pipe } from 'rxjs';
|
||||
import {
|
||||
arrayifySource,
|
||||
callPlugin,
|
||||
isAutocomplete,
|
||||
treeSearch,
|
||||
SernError,
|
||||
} from '../core/_internal';
|
||||
import { createResultResolver } from './event-utils';
|
||||
import { AutocompleteInteraction, BaseInteraction, Message } from 'discord.js';
|
||||
import { CommandType, Context } from '../core';
|
||||
import type { Args } from '../types/utility';
|
||||
import type { BothCommand, CommandModule, Module, Processed } from '../types/core-modules';
|
||||
|
||||
function dispatchInteraction<T extends CommandModule, V extends BaseInteraction | Message>(
|
||||
payload: { module: Processed<T>; event: V },
|
||||
createArgs: (m: typeof payload.event) => unknown[],
|
||||
) {
|
||||
return {
|
||||
module: payload.module,
|
||||
args: createArgs(payload.event),
|
||||
};
|
||||
}
|
||||
//TODO: refactor dispatchers so that it implements a strategy for each different type of payload?
|
||||
export function dispatchMessage(module: Processed<CommandModule>, args: [Context, Args]) {
|
||||
return {
|
||||
module,
|
||||
args,
|
||||
};
|
||||
}
|
||||
|
||||
function dispatchAutocomplete(payload: {
|
||||
module: Processed<BothCommand>;
|
||||
event: AutocompleteInteraction;
|
||||
}) {
|
||||
const option = treeSearch(payload.event, payload.module.options);
|
||||
assert.ok(
|
||||
option,
|
||||
Error(SernError.NotSupportedInteraction + ` There is no autocomplete tag for this option`),
|
||||
);
|
||||
return {
|
||||
module: option.command as Processed<Module>, //autocomplete is not a true "module" warning cast!
|
||||
args: [payload.event],
|
||||
};
|
||||
}
|
||||
|
||||
export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?: string[]) {
|
||||
const ctx = Context.wrap(wrappable);
|
||||
const args = ctx.isMessage() ? ['text', messageArgs!] : ['slash', ctx.options];
|
||||
return [ctx, args] as [Context, Args];
|
||||
}
|
||||
|
||||
function interactionArg<T extends BaseInteraction>(interaction: T) {
|
||||
return [interaction] as [T];
|
||||
}
|
||||
|
||||
function intoPayload(module: Processed<Module>) {
|
||||
return pipe(
|
||||
arrayifySource,
|
||||
map(args => ({ module, args })),
|
||||
);
|
||||
}
|
||||
|
||||
const createResult = createResultResolver<
|
||||
Processed<Module>,
|
||||
{ module: Processed<Module>; args: unknown[] },
|
||||
unknown[]
|
||||
>({
|
||||
createStream: ({ module, args }) => from(module.onEvent).pipe(callPlugin(args)),
|
||||
onNext: ({ args }) => args,
|
||||
});
|
||||
/**
|
||||
* Creates an observable from { source }
|
||||
* @param module
|
||||
* @param source
|
||||
*/
|
||||
export function eventDispatcher(module: Processed<Module>, source: unknown) {
|
||||
assert.ok(source instanceof EventEmitter, `${source} is not an EventEmitter`);
|
||||
|
||||
const execute: OperatorFunction<unknown[], unknown> = concatMap(async args =>
|
||||
module.execute(...args),
|
||||
);
|
||||
return fromEvent(source, module.name).pipe(
|
||||
intoPayload(module),
|
||||
concatMap(createResult),
|
||||
execute,
|
||||
);
|
||||
}
|
||||
|
||||
export function createDispatcher(payload: {
|
||||
module: Processed<CommandModule>;
|
||||
event: BaseInteraction;
|
||||
}) {
|
||||
assert.ok(
|
||||
CommandType.Text !== payload.module.type,
|
||||
SernError.MismatchEvent + 'Found text command in interaction stream',
|
||||
);
|
||||
switch (payload.module.type) {
|
||||
case CommandType.Slash:
|
||||
case CommandType.Both: {
|
||||
if (isAutocomplete(payload.event)) {
|
||||
/**
|
||||
* Autocomplete is a special case that
|
||||
* must be handled separately, since it's
|
||||
* too different from regular command modules
|
||||
* CAST SAFETY: payload is already guaranteed to be a slash command or both command
|
||||
*/
|
||||
return dispatchAutocomplete(payload as never);
|
||||
}
|
||||
return dispatchInteraction(payload, contextArgs);
|
||||
}
|
||||
default:
|
||||
return dispatchInteraction(payload, interactionArg);
|
||||
}
|
||||
}
|
||||
237
src/handlers/event-utils.ts
Normal file
237
src/handlers/event-utils.ts
Normal file
@@ -0,0 +1,237 @@
|
||||
import { Interaction, Message } from 'discord.js';
|
||||
import {
|
||||
EMPTY,
|
||||
Observable,
|
||||
concatMap,
|
||||
filter,
|
||||
from,
|
||||
of,
|
||||
throwError,
|
||||
tap,
|
||||
MonoTypeOperatorFunction,
|
||||
catchError,
|
||||
finalize,
|
||||
} from 'rxjs';
|
||||
import {
|
||||
Files,
|
||||
Id,
|
||||
callPlugin,
|
||||
everyPluginOk,
|
||||
filterMapTo,
|
||||
handleError,
|
||||
SernError,
|
||||
VoidResult,
|
||||
} from '../core/_internal';
|
||||
import { Emitter, ErrorHandling, Logging, ModuleManager, useContainerRaw } from '../core';
|
||||
import { contextArgs, createDispatcher, dispatchMessage } from './dispatchers';
|
||||
import { ObservableInput, pipe } from 'rxjs';
|
||||
import { SernEmitter } from '../core';
|
||||
import { Result } from 'ts-results-es';
|
||||
import type { Awaitable } from '../types/utility';
|
||||
import assert from 'node:assert';
|
||||
import type { ControlPlugin } from '../types/core-plugin';
|
||||
import type { AnyModule, CommandModule, Module, Processed } from '../types/core-modules';
|
||||
import type { ImportPayload } from '../types/core';
|
||||
|
||||
function createGenericHandler<Source, Narrowed extends Source, Output>(
|
||||
source: Observable<Source>,
|
||||
makeModule: (event: Narrowed) => Promise<Output>,
|
||||
) {
|
||||
return (pred: (i: Source) => i is Narrowed) => source.pipe(filter(pred), concatMap(makeModule));
|
||||
}
|
||||
|
||||
/**
|
||||
* Removes the first character(s) _[depending on prefix length]_ of the message
|
||||
* @param msg
|
||||
* @param prefix The prefix to remove
|
||||
* @returns The message without the prefix
|
||||
* @example
|
||||
* message.content = '!ping';
|
||||
* console.log(fmt(message, '!'));
|
||||
* // [ 'ping' ]
|
||||
*/
|
||||
export function fmt(msg: string, prefix: string): string[] {
|
||||
return msg.slice(prefix.length).trim().split(/\s+/g);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* Creates an RxJS observable that filters and maps incoming interactions to their respective modules.
|
||||
* @param i An RxJS observable of interactions.
|
||||
* @param mg The module manager instance used to retrieve the module path for each interaction.
|
||||
* @returns A handler to create a RxJS observable of dispatchers that take incoming interactions and execute their corresponding modules.
|
||||
*/
|
||||
export function createInteractionHandler<T extends Interaction>(
|
||||
source: Observable<Interaction>,
|
||||
mg: ModuleManager,
|
||||
) {
|
||||
return createGenericHandler<Interaction, T, ReturnType<typeof createDispatcher>>(
|
||||
source,
|
||||
async event => {
|
||||
const fullPath = mg.get(Id.reconstruct(event));
|
||||
assert(fullPath, SernError.UndefinedModule + ' No full path found in module store');
|
||||
return Files.defaultModuleLoader<Processed<CommandModule>>(fullPath).then(payload =>
|
||||
createDispatcher({ module: payload.module, event }),
|
||||
);
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
export function createMessageHandler(
|
||||
source: Observable<Message>,
|
||||
defaultPrefix: string,
|
||||
mg: ModuleManager,
|
||||
) {
|
||||
return createGenericHandler(source, async event => {
|
||||
const [prefix, ...rest] = fmt(event.content, defaultPrefix);
|
||||
const fullPath = mg.get(`${prefix}_A1`);
|
||||
|
||||
assert(fullPath, SernError.UndefinedModule + ' No full path found in module store');
|
||||
return Files.defaultModuleLoader<Processed<CommandModule>>(fullPath).then(payload => {
|
||||
const args = contextArgs(event, rest);
|
||||
return dispatchMessage(payload.module, args);
|
||||
});
|
||||
});
|
||||
}
|
||||
/**
|
||||
* IMPURE SIDE EFFECT
|
||||
* This function assigns remaining, incomplete data to each imported module.
|
||||
*/
|
||||
function assignDefaults<T extends Module>(
|
||||
moduleManager: ModuleManager,
|
||||
): MonoTypeOperatorFunction<ImportPayload<T>> {
|
||||
return tap(({ module, absPath }) => {
|
||||
module.name ??= Files.filename(absPath);
|
||||
module.description ??= '...';
|
||||
moduleManager.setMetadata(module, {
|
||||
isClass: module.constructor.name === 'Function',
|
||||
fullPath: absPath,
|
||||
id: Id.create(module.name, module.type),
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
export function buildModules<T extends AnyModule>(
|
||||
input: ObservableInput<string>,
|
||||
moduleManager: ModuleManager,
|
||||
) {
|
||||
return Files.buildModuleStream<Processed<T>>(input).pipe(assignDefaults(moduleManager));
|
||||
}
|
||||
|
||||
/**
|
||||
* Wraps the task in a Result as a try / catch.
|
||||
* if the task is ok, an event is emitted and the stream becomes empty
|
||||
* if the task is an error, throw an error down the stream which will be handled by catchError
|
||||
* @param emitter reference to SernEmitter that will emit a successful execution of module
|
||||
* @param module the module that will be executed with task
|
||||
* @param task the deferred execution which will be called
|
||||
*/
|
||||
export function executeModule(
|
||||
emitter: Emitter,
|
||||
{
|
||||
module,
|
||||
task,
|
||||
}: {
|
||||
module: Processed<Module>;
|
||||
task: () => Awaitable<unknown>;
|
||||
},
|
||||
) {
|
||||
return of(module).pipe(
|
||||
//converting the task into a promise so rxjs can resolve the Awaitable properly
|
||||
concatMap(() => Result.wrapAsync(async () => task())),
|
||||
concatMap(result => {
|
||||
if (result.ok) {
|
||||
emitter.emit('module.activate', SernEmitter.success(module));
|
||||
return EMPTY;
|
||||
} else {
|
||||
return throwError(() => SernEmitter.failure(module, result.val));
|
||||
}
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* A higher order function that
|
||||
* - creates a stream of {@link VoidResult} { config.createStream }
|
||||
* - any failures results to { config.onFailure } being called
|
||||
* - if all results are ok, the stream is converted to { config.onNext }
|
||||
* emit config.onSuccess Observable
|
||||
* @param config
|
||||
* @returns receiver function for flattening a stream of data
|
||||
*/
|
||||
export function createResultResolver<
|
||||
T extends { execute: (...args: any[]) => any; onEvent: ControlPlugin[] },
|
||||
Args extends { module: T; [key: string]: unknown },
|
||||
Output,
|
||||
>(config: {
|
||||
onStop?: (module: T) => unknown;
|
||||
onNext: (args: Args) => Output;
|
||||
createStream: (args: Args) => Observable<VoidResult>;
|
||||
}) {
|
||||
return (args: Args) => {
|
||||
const task$ = config.createStream(args);
|
||||
return task$.pipe(
|
||||
tap(result => {
|
||||
result.err && config.onStop?.(args.module);
|
||||
}),
|
||||
everyPluginOk,
|
||||
filterMapTo(() => config.onNext(args)),
|
||||
);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
* Calls a module's init plugins and checks for Err. If so, call { onStop } and
|
||||
* ignore the module
|
||||
*/
|
||||
export function callInitPlugins<T extends Processed<AnyModule>>(sernEmitter: Emitter) {
|
||||
return concatMap(
|
||||
createResultResolver({
|
||||
createStream: args => from(args.module.plugins).pipe(callPlugin(args)),
|
||||
onStop: (module: T) => {
|
||||
sernEmitter.emit(
|
||||
'module.register',
|
||||
SernEmitter.failure(module, SernError.PluginFailure),
|
||||
);
|
||||
},
|
||||
onNext: ({ module }) => {
|
||||
sernEmitter.emit('module.register', SernEmitter.success(module));
|
||||
return module;
|
||||
},
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an executable task ( execute the command ) if all control plugins are successful
|
||||
* @param onStop emits a failure response to the SernEmitter
|
||||
*/
|
||||
export function makeModuleExecutor<
|
||||
M extends Processed<Module>,
|
||||
Args extends { module: M; args: unknown[] },
|
||||
>(onStop: (m: M) => unknown) {
|
||||
const onNext = ({ args, module }: Args) => ({
|
||||
task: () => module.execute(...args),
|
||||
module,
|
||||
});
|
||||
return concatMap(
|
||||
createResultResolver({
|
||||
onStop,
|
||||
createStream: ({ args, module }) => from(module.onEvent).pipe(callPlugin(args)),
|
||||
onNext,
|
||||
}),
|
||||
);
|
||||
}
|
||||
|
||||
export const handleCrash = (err: ErrorHandling, log?: Logging) =>
|
||||
pipe(
|
||||
catchError(handleError(err, log)),
|
||||
finalize(() => {
|
||||
log?.info({
|
||||
message: 'A stream closed or reached end of lifetime',
|
||||
});
|
||||
useContainerRaw()
|
||||
?.disposeAll()
|
||||
.then(() => log?.info({ message: 'Cleaning container and crashing' }));
|
||||
}),
|
||||
);
|
||||
31
src/handlers/interaction-event.ts
Normal file
31
src/handlers/interaction-event.ts
Normal file
@@ -0,0 +1,31 @@
|
||||
import { Interaction } from 'discord.js';
|
||||
import { concatMap, merge } from 'rxjs';
|
||||
import { SernEmitter } from '../core';
|
||||
import {
|
||||
isAutocomplete,
|
||||
isCommand,
|
||||
isMessageComponent,
|
||||
isModal,
|
||||
sharedEventStream,
|
||||
SernError,
|
||||
} from '../core/_internal';
|
||||
import { createInteractionHandler, executeModule, makeModuleExecutor } from './_internal';
|
||||
import type { DependencyList } from '../types/ioc';
|
||||
|
||||
export function interactionHandler([emitter, , , modules, client]: DependencyList) {
|
||||
const interactionStream$ = sharedEventStream<Interaction>(client, 'interactionCreate');
|
||||
const handle = createInteractionHandler(interactionStream$, modules);
|
||||
|
||||
const interactionHandler$ = merge(
|
||||
handle(isMessageComponent),
|
||||
handle(isAutocomplete),
|
||||
handle(isCommand),
|
||||
handle(isModal),
|
||||
);
|
||||
return interactionHandler$.pipe(
|
||||
makeModuleExecutor(module => {
|
||||
emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
|
||||
}),
|
||||
concatMap(payload => executeModule(emitter, payload)),
|
||||
);
|
||||
}
|
||||
46
src/handlers/message-event.ts
Normal file
46
src/handlers/message-event.ts
Normal file
@@ -0,0 +1,46 @@
|
||||
import { concatMap, EMPTY } from 'rxjs';
|
||||
import type { Message } from 'discord.js';
|
||||
import { SernEmitter } from '../core';
|
||||
import { sharedEventStream, SernError } from '../core/_internal';
|
||||
import { createMessageHandler, executeModule, makeModuleExecutor } from './_internal';
|
||||
import type { DependencyList } from '../types/ioc';
|
||||
|
||||
/**
|
||||
* Ignores messages from any person / bot except itself
|
||||
* @param prefix
|
||||
*/
|
||||
function isNonBot(prefix: string) {
|
||||
return (msg: Message): msg is Message => !msg.author.bot && hasPrefix(prefix, msg.content);
|
||||
}
|
||||
|
||||
function hasPrefix(prefix: string, content: string) {
|
||||
const prefixInContent = content.slice(0, prefix.length);
|
||||
return (
|
||||
prefixInContent.localeCompare(prefix, undefined, {
|
||||
sensitivity: 'accent',
|
||||
}) === 0
|
||||
);
|
||||
}
|
||||
|
||||
export function messageHandler(
|
||||
[emitter, , log, modules, client]: DependencyList,
|
||||
defaultPrefix: string | undefined,
|
||||
) {
|
||||
if (!defaultPrefix) {
|
||||
log?.debug({
|
||||
message: 'No prefix found. message handler shutting down',
|
||||
});
|
||||
return EMPTY;
|
||||
}
|
||||
const messageStream$ = sharedEventStream<Message>(client, 'messageCreate');
|
||||
const handle = createMessageHandler(messageStream$, defaultPrefix, modules);
|
||||
|
||||
const msgCommands$ = handle(isNonBot(defaultPrefix));
|
||||
|
||||
return msgCommands$.pipe(
|
||||
makeModuleExecutor(module => {
|
||||
emitter.emit('module.activate', SernEmitter.failure(module, SernError.PluginFailure));
|
||||
}),
|
||||
concatMap(payload => executeModule(emitter, payload)),
|
||||
);
|
||||
}
|
||||
48
src/handlers/ready-event.ts
Normal file
48
src/handlers/ready-event.ts
Normal file
@@ -0,0 +1,48 @@
|
||||
import { ObservableInput, concat, first, fromEvent, ignoreElements, pipe } from 'rxjs';
|
||||
import { CommandType } from '../core/structures';
|
||||
import { SernError } from '../core/_internal';
|
||||
import { Result } from 'ts-results-es';
|
||||
import { ModuleManager } from '../core/contracts';
|
||||
import { buildModules, callInitPlugins } from './_internal';
|
||||
import * as assert from 'node:assert';
|
||||
import * as util from 'node:util';
|
||||
import type { DependencyList } from '../types/ioc';
|
||||
import type { AnyModule, Processed } from '../types/core-modules';
|
||||
|
||||
export function startReadyEvent(
|
||||
[sEmitter, , , moduleManager, client]: DependencyList,
|
||||
allPaths: ObservableInput<string>,
|
||||
) {
|
||||
const ready$ = fromEvent(client!, 'ready').pipe(once());
|
||||
|
||||
return concat(ready$, buildModules<AnyModule>(allPaths, moduleManager))
|
||||
.pipe(callInitPlugins(sEmitter))
|
||||
.subscribe(module => {
|
||||
register(moduleManager, module).expect(
|
||||
SernError.InvalidModuleType + ' ' + util.inspect(module),
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
const once = () => pipe(
|
||||
first(),
|
||||
ignoreElements()
|
||||
)
|
||||
|
||||
|
||||
function register<T extends Processed<AnyModule>>(
|
||||
manager: ModuleManager,
|
||||
module: T,
|
||||
): Result<void, void> {
|
||||
const { id, fullPath } = manager.getMetadata(module)!;
|
||||
|
||||
const validModuleType = module.type >= 0 && module.type <= 1 << 10;
|
||||
assert.ok(
|
||||
validModuleType,
|
||||
`Found ${module.name} at ${fullPath}, which does not have a valid type`,
|
||||
);
|
||||
if (module.type === CommandType.Both || module.type === CommandType.Text) {
|
||||
module.alias?.forEach(a => manager.set(`${a}_A1`, fullPath));
|
||||
}
|
||||
return Result.wrap(() => manager.set(id, fullPath));
|
||||
}
|
||||
37
src/handlers/user-defined-events.ts
Normal file
37
src/handlers/user-defined-events.ts
Normal file
@@ -0,0 +1,37 @@
|
||||
import { ObservableInput, map, mergeAll } from 'rxjs';
|
||||
import { EventType } from '../core/structures';
|
||||
import { SernError } from '../core/_internal';
|
||||
import { buildModules, callInitPlugins, handleCrash, eventDispatcher } from './_internal';
|
||||
import { Service } from '../core/ioc';
|
||||
import type { DependencyList } from '../types/ioc';
|
||||
import type { CommandModule, EventModule, Processed } from '../types/core-modules';
|
||||
|
||||
export function eventsHandler(
|
||||
[emitter, err, log, moduleManager, client]: DependencyList,
|
||||
allPaths: ObservableInput<string>,
|
||||
) {
|
||||
//code smell
|
||||
const intoDispatcher = (e: Processed<EventModule | CommandModule>) => {
|
||||
switch (e.type) {
|
||||
case EventType.Sern:
|
||||
return eventDispatcher(e, emitter);
|
||||
case EventType.Discord:
|
||||
return eventDispatcher(e, client);
|
||||
case EventType.External:
|
||||
return eventDispatcher(e, Service(e.emitter));
|
||||
default:
|
||||
throw Error(SernError.InvalidModuleType + ' while creating event handler');
|
||||
}
|
||||
};
|
||||
buildModules<EventModule>(allPaths, moduleManager)
|
||||
.pipe(
|
||||
callInitPlugins(emitter),
|
||||
map(intoDispatcher),
|
||||
/**
|
||||
* Where all events are turned on
|
||||
*/
|
||||
mergeAll(),
|
||||
handleCrash(err, log),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
63
src/index.ts
63
src/index.ts
@@ -1,18 +1,53 @@
|
||||
import SernEmitter from './handler/sernEmitter';
|
||||
export * as Sern from './sern';
|
||||
export * from './core';
|
||||
export type {
|
||||
CommandModule,
|
||||
EventModule,
|
||||
BothCommand,
|
||||
ContextMenuMsg,
|
||||
ContextMenuUser,
|
||||
SlashCommand,
|
||||
TextCommand,
|
||||
ButtonCommand,
|
||||
StringSelectCommand,
|
||||
MentionableSelectCommand,
|
||||
UserSelectCommand,
|
||||
ChannelSelectCommand,
|
||||
RoleSelectCommand,
|
||||
ModalSubmitCommand,
|
||||
DiscordEventCommand,
|
||||
SernEventCommand,
|
||||
ExternalEventCommand,
|
||||
CommandModuleDefs,
|
||||
EventModuleDefs,
|
||||
SernAutocompleteData,
|
||||
SernOptionsData,
|
||||
SernSubCommandData,
|
||||
SernSubCommandGroupData,
|
||||
} from './types/core-modules';
|
||||
|
||||
export type {
|
||||
Controller,
|
||||
PluginResult,
|
||||
InitPlugin,
|
||||
ControlPlugin,
|
||||
Plugin,
|
||||
AnyEventPlugin,
|
||||
AnyCommandPlugin,
|
||||
} from './types/core-plugin';
|
||||
|
||||
export type { Wrapper } from './types/core';
|
||||
|
||||
export type { Args, SlashOptions, Payload, SernEventsMapping } from './types/utility';
|
||||
|
||||
export type { Singleton, Transient, CoreDependencies, Initializable } from './types/ioc';
|
||||
|
||||
export {
|
||||
eventModule,
|
||||
commandModule,
|
||||
eventModule,
|
||||
discordEvent,
|
||||
EventExecutable,
|
||||
CommandExecutable,
|
||||
controller,
|
||||
discordEvent,
|
||||
} from './handler/sern';
|
||||
export * as Sern from './handler/sern';
|
||||
export * from './types/handler';
|
||||
export * from './types/module';
|
||||
export * from './types/plugin';
|
||||
export * from './handler/structures';
|
||||
export * from './handler/plugins';
|
||||
export * from './handler/contracts';
|
||||
export { SernEmitter };
|
||||
export * from './handler/dependencies';
|
||||
} from './core/modules';
|
||||
|
||||
export { controller } from './sern';
|
||||
|
||||
75
src/sern.ts
Normal file
75
src/sern.ts
Normal file
@@ -0,0 +1,75 @@
|
||||
import { handleCrash } from './handlers/_internal';
|
||||
import { err, ok, Files } from './core/_internal';
|
||||
import { merge } from 'rxjs';
|
||||
import { Services } from './core/ioc';
|
||||
import { Wrapper } from './types/core';
|
||||
import { eventsHandler } from './handlers/user-defined-events';
|
||||
import { startReadyEvent } from './handlers/ready-event';
|
||||
import { messageHandler } from './handlers/message-event';
|
||||
import { interactionHandler } from './handlers/interaction-event';
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* @param wrapper Options to pass into sern.
|
||||
* Function to start the handler up
|
||||
* @example
|
||||
* ```ts title="src/index.ts"
|
||||
* Sern.init({
|
||||
* commands: 'dist/commands',
|
||||
* events: 'dist/events',
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
|
||||
export function init(maybeWrapper: Wrapper | 'file') {
|
||||
const startTime = performance.now();
|
||||
const wrapper = Files.loadConfig(maybeWrapper);
|
||||
const dependencies = useDependencies();
|
||||
const logger = dependencies[2],
|
||||
errorHandler = dependencies[1];
|
||||
const mode = isDevMode(wrapper.mode ?? process.env.MODE);
|
||||
|
||||
if (wrapper.events !== undefined) {
|
||||
eventsHandler(dependencies, Files.getFullPathTree(wrapper.events, mode));
|
||||
}
|
||||
//Ready event: load all modules and when finished, time should be taken and logged
|
||||
startReadyEvent(dependencies, Files.getFullPathTree(wrapper.commands, mode)).add(() => {
|
||||
const time = ((performance.now() - startTime) / 1000).toFixed(2);
|
||||
dependencies[0].emit('modulesLoaded');
|
||||
logger?.info({
|
||||
message: `sern: registered all modules in ${time} s`,
|
||||
});
|
||||
});
|
||||
|
||||
const messages$ = messageHandler(dependencies, wrapper.defaultPrefix);
|
||||
const interactions$ = interactionHandler(dependencies);
|
||||
// listening to the message stream and interaction stream
|
||||
merge(messages$, interactions$).pipe(handleCrash(errorHandler, logger)).subscribe();
|
||||
}
|
||||
|
||||
function isDevMode(mode: string | undefined) {
|
||||
console.info(`Detected mode: "${mode}"`);
|
||||
if (mode === undefined) {
|
||||
console.info('No mode found in process.env, assuming DEV');
|
||||
}
|
||||
return mode === 'DEV' || mode == undefined;
|
||||
}
|
||||
|
||||
function useDependencies() {
|
||||
return Services(
|
||||
'@sern/emitter',
|
||||
'@sern/errors',
|
||||
'@sern/logger',
|
||||
'@sern/modules',
|
||||
'@sern/client',
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* @since 1.0.0
|
||||
* The object passed into every plugin to control a command's behavior
|
||||
*/
|
||||
export const controller = {
|
||||
next: ok,
|
||||
stop: err,
|
||||
};
|
||||
@@ -1,34 +1,31 @@
|
||||
import type {
|
||||
ApplicationCommandAttachmentOption,
|
||||
ApplicationCommandChannelOptionData,
|
||||
ApplicationCommandChoicesData,
|
||||
ApplicationCommandNonOptionsData,
|
||||
ApplicationCommandNumericOptionData,
|
||||
ApplicationCommandOptionData,
|
||||
APIApplicationCommandBasicOption,
|
||||
APIApplicationCommandOptionBase,
|
||||
ApplicationCommandOptionType,
|
||||
ApplicationCommandSubCommandData,
|
||||
ApplicationCommandSubGroupData,
|
||||
AutocompleteInteraction,
|
||||
Awaitable,
|
||||
BaseApplicationCommandOptionsData,
|
||||
AutocompleteInteraction,
|
||||
ButtonInteraction,
|
||||
ChannelSelectMenuInteraction,
|
||||
ClientEvents,
|
||||
MentionableSelectMenuInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
ModalSubmitInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
ChannelSelectMenuInteraction,
|
||||
MentionableSelectMenuInteraction,
|
||||
RoleSelectMenuInteraction,
|
||||
StringSelectMenuInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
UserSelectMenuInteraction,
|
||||
} from 'discord.js';
|
||||
import { CommandType } from '../handler/structures/enums';
|
||||
import type { Args, SlashOptions } from './handler';
|
||||
import type Context from '../handler/structures/context';
|
||||
import type { InitPlugin, ControlPlugin } from './plugin';
|
||||
import { EventType } from '../handler/structures/enums';
|
||||
import type { AnyCommandPlugin, AnyEventPlugin } from './plugin';
|
||||
import type { SernEventsMapping } from './handler';
|
||||
import type { ClientEvents } 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';
|
||||
|
||||
export interface CommandMeta {
|
||||
fullPath: string;
|
||||
id: string;
|
||||
isClass: boolean;
|
||||
}
|
||||
|
||||
export type Processed<T> = T & { name: string; description: string };
|
||||
|
||||
export interface Module {
|
||||
type: CommandType | EventType;
|
||||
@@ -36,28 +33,20 @@ export interface Module {
|
||||
onEvent: ControlPlugin[];
|
||||
plugins: InitPlugin[];
|
||||
description?: string;
|
||||
execute: (...args: any[]) => Awaitable<any>;
|
||||
execute(...args: any[]): Awaitable<any>;
|
||||
}
|
||||
|
||||
export interface TextCommand extends Module {
|
||||
type: CommandType.Text;
|
||||
alias?: string[];
|
||||
execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
|
||||
export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
|
||||
extends Module {
|
||||
name?: T;
|
||||
type: EventType.Sern;
|
||||
execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface SlashCommand extends Module {
|
||||
type: CommandType.Slash;
|
||||
description: string;
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface BothCommand extends Module {
|
||||
type: CommandType.Both;
|
||||
alias?: string[];
|
||||
description: string;
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: Args) => Awaitable<unknown>;
|
||||
export interface ExternalEventCommand extends Module {
|
||||
name?: string;
|
||||
emitter: keyof Dependencies;
|
||||
type: EventType.External;
|
||||
execute(...args: unknown[]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ContextMenuUser extends Module {
|
||||
@@ -111,25 +100,31 @@ export interface AutocompleteCommand
|
||||
execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping>
|
||||
extends Module {
|
||||
name?: T;
|
||||
type: EventType.Sern;
|
||||
execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents>
|
||||
extends Module {
|
||||
name?: T;
|
||||
type: EventType.Discord;
|
||||
execute(...args: ClientEvents[T]): Awaitable<unknown>;
|
||||
}
|
||||
export interface TextCommand extends Module {
|
||||
type: CommandType.Text;
|
||||
alias?: string[];
|
||||
execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ExternalEventCommand extends Module {
|
||||
name?: string;
|
||||
emitter: string;
|
||||
type: EventType.External;
|
||||
execute(...args: unknown[]): Awaitable<unknown>;
|
||||
export interface SlashCommand extends Module {
|
||||
type: CommandType.Slash;
|
||||
description: string;
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface BothCommand extends Module {
|
||||
type: CommandType.Both;
|
||||
alias?: string[];
|
||||
description: string;
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: Args) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
|
||||
@@ -148,10 +143,9 @@ export type CommandModule =
|
||||
| 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 type CommandModuleDefs = {
|
||||
export interface CommandModuleDefs {
|
||||
[CommandType.Text]: TextCommand;
|
||||
[CommandType.Slash]: SlashCommand;
|
||||
[CommandType.Both]: BothCommand;
|
||||
@@ -164,13 +158,13 @@ export type CommandModuleDefs = {
|
||||
[CommandType.MentionableSelect]: MentionableSelectCommand;
|
||||
[CommandType.UserSelect]: UserSelectCommand;
|
||||
[CommandType.Modal]: ModalSubmitCommand;
|
||||
};
|
||||
}
|
||||
|
||||
export type EventModuleDefs = {
|
||||
export interface EventModuleDefs {
|
||||
[EventType.Sern]: SernEventCommand;
|
||||
[EventType.Discord]: DiscordEventCommand;
|
||||
[EventType.External]: ExternalEventCommand;
|
||||
};
|
||||
}
|
||||
|
||||
export interface SernAutocompleteData
|
||||
extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
|
||||
@@ -182,10 +176,10 @@ export interface SernAutocompleteData
|
||||
command: AutocompleteCommand;
|
||||
}
|
||||
|
||||
export type CommandModuleNoPlugins = {
|
||||
type CommandModuleNoPlugins = {
|
||||
[T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
|
||||
};
|
||||
export type EventModulesNoPlugins = {
|
||||
type EventModulesNoPlugins = {
|
||||
[T in EventType]: Omit<EventModuleDefs[T], 'plugins' | 'onEvent'>;
|
||||
};
|
||||
|
||||
@@ -194,35 +188,27 @@ export type InputEvent = {
|
||||
}[EventType];
|
||||
|
||||
export type InputCommand = {
|
||||
[T in CommandType]: CommandModuleNoPlugins[T] & { plugins?: AnyCommandPlugin[] };
|
||||
[T in CommandType]: CommandModuleNoPlugins[T] & {
|
||||
plugins?: AnyCommandPlugin[];
|
||||
};
|
||||
}[CommandType];
|
||||
|
||||
/**
|
||||
* Type that replaces autocomplete with {@link SernAutocompleteData}
|
||||
*/
|
||||
export type BaseOptions =
|
||||
| ApplicationCommandChoicesData
|
||||
| ApplicationCommandNonOptionsData
|
||||
| ApplicationCommandChannelOptionData
|
||||
| ApplicationCommandNumericOptionData
|
||||
| ApplicationCommandAttachmentOption
|
||||
export type SernOptionsData =
|
||||
| SernSubCommandData
|
||||
| SernSubCommandGroupData
|
||||
| APIApplicationCommandBasicOption
|
||||
| SernAutocompleteData;
|
||||
|
||||
export interface SernSubCommandData extends BaseApplicationCommandOptionsData {
|
||||
export interface SernSubCommandData
|
||||
extends APIApplicationCommandOptionBase<ApplicationCommandOptionType.Subcommand> {
|
||||
type: ApplicationCommandOptionType.Subcommand;
|
||||
required?: never;
|
||||
options?: BaseOptions[];
|
||||
options?: SernOptionsData[];
|
||||
}
|
||||
|
||||
export interface SernSubCommandGroupData extends BaseApplicationCommandOptionsData {
|
||||
type: ApplicationCommandOptionType.SubcommandGroup;
|
||||
required?: never;
|
||||
options?: SernSubCommandData[];
|
||||
}
|
||||
|
||||
export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
|
||||
U extends ApplicationCommandSubCommandData
|
||||
? SernSubCommandData
|
||||
: U extends ApplicationCommandSubGroupData
|
||||
? SernSubCommandGroupData
|
||||
: BaseOptions;
|
||||
@@ -1,42 +1,92 @@
|
||||
import type { CommandType } from '../structures/enums';
|
||||
import type { PluginType } from '../structures/enums';
|
||||
import type { ClientEvents } from 'discord.js';
|
||||
/*
|
||||
* Plugins can be inserted on all commands and are emitted
|
||||
*
|
||||
* 1. On ready event, where all commands are loaded.
|
||||
* 2. On corresponding observable (when command triggers)
|
||||
*
|
||||
* The goal of plugins is to organize commands and
|
||||
* provide extensions to repetitive patterns
|
||||
* examples include refreshing modules,
|
||||
* categorizing commands, cool-downs, permissions, etc.
|
||||
* Plugins are reminiscent of middleware in express.
|
||||
*/
|
||||
|
||||
import type { Err, Ok, 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,
|
||||
ContextMenuMsg,
|
||||
Module,
|
||||
} from '../../types/module';
|
||||
import type { Args, Payload, Processed, SlashOptions } from '../../types/handler';
|
||||
import type Context from '../structures/context';
|
||||
import type { MessageContextMenuCommandInteraction } from 'discord.js';
|
||||
import type {
|
||||
} from './core-modules';
|
||||
import { Args, Awaitable, Payload, SlashOptions } from './utility';
|
||||
import { CommandType, Context, EventType, PluginType } from '../core';
|
||||
import {
|
||||
ButtonInteraction,
|
||||
ChannelSelectMenuInteraction,
|
||||
ClientEvents,
|
||||
MentionableSelectMenuInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
ModalSubmitInteraction,
|
||||
RoleSelectMenuInteraction,
|
||||
StringSelectMenuInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
} from 'discord.js';
|
||||
import type {
|
||||
ChannelSelectMenuInteraction,
|
||||
MentionableSelectMenuInteraction,
|
||||
ModalSubmitInteraction,
|
||||
UserSelectMenuInteraction,
|
||||
} from 'discord.js';
|
||||
import { EventType } from '../structures/enums';
|
||||
|
||||
type CommandArgsMatrix = {
|
||||
export type PluginResult = Awaitable<VoidResult>;
|
||||
export type VoidResult = Result<void, void>;
|
||||
|
||||
export interface InitArgs<T extends Processed<Module>> {
|
||||
module: T;
|
||||
absPath: string;
|
||||
}
|
||||
export interface Controller {
|
||||
next: () => Ok<void>;
|
||||
stop: () => Err<void>;
|
||||
}
|
||||
export interface Plugin<Args extends any[] = any[]> {
|
||||
type: PluginType;
|
||||
execute: (...args: Args) => PluginResult;
|
||||
}
|
||||
|
||||
export interface InitPlugin<Args extends any[] = any[]> {
|
||||
type: PluginType.Init;
|
||||
execute: (...args: Args) => PluginResult;
|
||||
}
|
||||
export interface ControlPlugin<Args extends any[] = any[]> {
|
||||
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 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];
|
||||
|
||||
interface CommandArgsMatrix {
|
||||
[CommandType.Text]: {
|
||||
[PluginType.Control]: [Context, ['text', string[]]];
|
||||
[PluginType.Init]: [InitArgs<Processed<TextCommand>>];
|
||||
@@ -85,9 +135,9 @@ type CommandArgsMatrix = {
|
||||
[PluginType.Control]: [/* library coupled */ ModalSubmitInteraction];
|
||||
[PluginType.Init]: [InitArgs<Processed<ModalSubmitCommand>>];
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
type EventArgsMatrix = {
|
||||
interface EventArgsMatrix {
|
||||
[EventType.Discord]: {
|
||||
[PluginType.Control]: /* library coupled */ ClientEvents[keyof ClientEvents];
|
||||
[PluginType.Init]: [InitArgs<Processed<DiscordEventCommand>>];
|
||||
@@ -100,18 +150,4 @@ type EventArgsMatrix = {
|
||||
[PluginType.Control]: unknown[];
|
||||
[PluginType.Init]: [InitArgs<Processed<ExternalEventCommand>>];
|
||||
};
|
||||
};
|
||||
|
||||
export interface InitArgs<T extends Processed<Module>> {
|
||||
module: T;
|
||||
absPath: string;
|
||||
}
|
||||
|
||||
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];
|
||||
21
src/types/core.ts
Normal file
21
src/types/core.ts
Normal file
@@ -0,0 +1,21 @@
|
||||
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.
|
||||
*/
|
||||
mode?: 'DEV' | 'PROD';
|
||||
/*
|
||||
* @deprecated
|
||||
*/
|
||||
containerConfig?: {
|
||||
get: (...keys: (keyof Dependencies)[]) => unknown[];
|
||||
};
|
||||
}
|
||||
12
src/types/dependencies.d.ts
vendored
Normal file
12
src/types/dependencies.d.ts
vendored
Normal file
@@ -0,0 +1,12 @@
|
||||
// This file serves an the interface for developers to augment the Dependencies interface
|
||||
// Developers will have to create a new file dependencies.d.ts in the root directory, augmenting
|
||||
// this type
|
||||
|
||||
/* eslint-disable @typescript-eslint/consistent-type-imports */
|
||||
|
||||
import { CoreDependencies } from './ioc';
|
||||
|
||||
declare global {
|
||||
interface Dependencies extends CoreDependencies {}
|
||||
|
||||
}
|
||||
@@ -1,71 +0,0 @@
|
||||
import type { CommandInteractionOptionResolver } from 'discord.js';
|
||||
import type { PayloadType } from '../handler/structures/enums';
|
||||
import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
|
||||
import type { EventEmitter } from 'events';
|
||||
import type { CommandModule, EventModule, AnyModule } from './module';
|
||||
import type { UnpackFunction } from 'iti';
|
||||
import type { ErrorHandling, Logging, ModuleManager } from '../handler/contracts';
|
||||
import type { ModuleStore } from '../handler/structures/moduleStore';
|
||||
import type SernEmitter from '../handler/sernEmitter';
|
||||
import type { Container } from 'iti';
|
||||
// Thanks to @kelsny
|
||||
export type ParseType<T> = {
|
||||
[K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
|
||||
}[keyof T];
|
||||
|
||||
export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
|
||||
|
||||
export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
|
||||
|
||||
/**
|
||||
* After modules are transformed, name and description are given default values if none
|
||||
* are provided to Module. This type represents that transformation
|
||||
*/
|
||||
export type AnyDefinedModule = Processed<CommandModule | EventModule>;
|
||||
export type Payload =
|
||||
| { type: PayloadType.Success; module: AnyModule }
|
||||
| { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
|
||||
| { type: PayloadType.Warning; reason: string };
|
||||
export type SernEventsMapping = {
|
||||
'module.register': [Payload];
|
||||
'module.activate': [Payload];
|
||||
error: [Payload];
|
||||
warning: [Payload];
|
||||
};
|
||||
export type LogPayload<T = unknown> = { message: T };
|
||||
export type Singleton<T> = () => T;
|
||||
export type Transient<T> = () => () => T;
|
||||
|
||||
export interface Dependencies {
|
||||
'@sern/client': Singleton<EventEmitter>;
|
||||
'@sern/logger'?: Singleton<Logging>;
|
||||
'@sern/emitter': Singleton<SernEmitter>;
|
||||
'@sern/store': Singleton<ModuleStore>;
|
||||
'@sern/modules': Singleton<ModuleManager>;
|
||||
'@sern/errors': Singleton<ErrorHandling>;
|
||||
}
|
||||
|
||||
export type ReplyOptions =
|
||||
| string
|
||||
| Omit<InteractionReplyOptions, 'fetchReply'>
|
||||
| MessageReplyOptions;
|
||||
//prettier-ignore
|
||||
export type MapDeps<Deps extends Dependencies, T extends readonly unknown[]> = T extends [
|
||||
infer First extends keyof Deps,
|
||||
...infer Rest extends readonly unknown[],
|
||||
]
|
||||
? [
|
||||
UnpackFunction<Deps[First]>,
|
||||
...(MapDeps<Deps, Rest> extends [never] ? [] : MapDeps<Deps, Rest>),
|
||||
]
|
||||
: [never];
|
||||
//Basically, '@sern/client' | '@sern/store' | '@sern/modules' | '@sern/error' | '@sern/emitter' will be provided defaults, and you can exclude the rest
|
||||
export type OptionalDependencies = '@sern/logger';
|
||||
export type Processed<T> = T & { name: string; description: string };
|
||||
export type Deprecated<Message extends string> = [never, Message];
|
||||
export interface DependencyConfiguration<T extends Dependencies> {
|
||||
exclude?: Set<OptionalDependencies>;
|
||||
build: (root: Container<Omit<Dependencies, '@sern/client'>, {}>) => Container<T, {}>;
|
||||
}
|
||||
|
||||
export type ImportPayload<T> = { module: T; absPath: string };
|
||||
48
src/types/ioc.ts
Normal file
48
src/types/ioc.ts
Normal file
@@ -0,0 +1,48 @@
|
||||
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/logger'?: () => Contracts.Logging;
|
||||
'@sern/emitter': () => Contracts.Emitter;
|
||||
'@sern/store': () => Contracts.CoreModuleStore;
|
||||
'@sern/modules': () => Contracts.ModuleManager;
|
||||
'@sern/errors': () => Contracts.ErrorHandling;
|
||||
}
|
||||
|
||||
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'] };
|
||||
|
||||
export interface DependencyConfiguration {
|
||||
//@deprecated. Loggers will always be included in the future
|
||||
exclude?: Set<'@sern/logger'>;
|
||||
build: (
|
||||
root: Container<Omit<CoreDependencies, '@sern/client'>, {}>,
|
||||
) => Container<Dependencies, {}>;
|
||||
}
|
||||
@@ -1,74 +0,0 @@
|
||||
/*
|
||||
* Plugins can be inserted on all commands and are emitted
|
||||
*
|
||||
* 1. On ready event, where all commands are loaded.
|
||||
* 2. On corresponding observable (when command triggers)
|
||||
*
|
||||
* The goal of plugins is to organize commands and
|
||||
* provide extensions to repetitive patterns
|
||||
* examples include refreshing modules,
|
||||
* categorizing commands, cool-downs, permissions, etc.
|
||||
* Plugins are reminiscent of middleware in express.
|
||||
*/
|
||||
|
||||
import type { Awaitable } from 'discord.js';
|
||||
import type { Err, Ok, Result } from 'ts-results-es';
|
||||
import type { PluginType } from '../handler/structures/enums';
|
||||
import type { CommandModule, EventModule } from './module';
|
||||
import type { CommandArgs, InitArgs } from '../handler/plugins';
|
||||
import type { Deprecated, Processed } from './handler';
|
||||
import type { CommandType } from '../handler/structures/enums';
|
||||
export type PluginResult = Awaitable<VoidResult>;
|
||||
export type VoidResult = Result<void, void>;
|
||||
|
||||
export interface Controller {
|
||||
next: () => Ok<void>;
|
||||
stop: () => Err<void>;
|
||||
}
|
||||
export interface Plugin<Args extends any[] = any[]> {
|
||||
type: PluginType;
|
||||
execute: (...args: Args) => PluginResult;
|
||||
}
|
||||
|
||||
export interface InitPlugin<Args extends any[] = any[]> {
|
||||
type: PluginType.Init;
|
||||
execute: (...args: Args) => PluginResult;
|
||||
}
|
||||
export interface ControlPlugin<Args extends any[] = any[]> {
|
||||
type: PluginType.Control;
|
||||
execute: (...args: Args) => PluginResult;
|
||||
}
|
||||
|
||||
export type AnyCommandPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<CommandModule>>]>;
|
||||
export type AnyEventPlugin = ControlPlugin | InitPlugin<[InitArgs<Processed<EventModule>>]>;
|
||||
|
||||
/**
|
||||
* @deprecated
|
||||
* Use the newer helper functions and import { controller } from '@sern/handler'
|
||||
*/
|
||||
export interface CommandPlugin<T extends CommandType = CommandType> {
|
||||
name?: string;
|
||||
description?: string;
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
m: InitArgs<Processed<CommandModule>>,
|
||||
controller?: Deprecated<'Please import controller instead'>,
|
||||
) => PluginResult;
|
||||
}
|
||||
/**
|
||||
* @deprecated
|
||||
* Use the newer helper functions
|
||||
*/
|
||||
export interface EventPlugin<T extends CommandType> {
|
||||
name?: string;
|
||||
description?: string;
|
||||
type: PluginType.Event;
|
||||
execute: (args: CommandArgs<T, PluginType.Event>, controller?: Controller) => PluginResult;
|
||||
}
|
||||
export type DiscordEmitterPlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type ExternalEmitterPlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type SernEmitterPlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type AutocompletePlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type SernEventPlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type ExternalEventPlugin = Deprecated<'Please view alternatives: '>;
|
||||
export type DiscordEventPlugin = Deprecated<'Please view alternatives: '>;
|
||||
29
src/types/utility.ts
Normal file
29
src/types/utility.ts
Normal file
@@ -0,0 +1,29 @@
|
||||
import { CommandInteractionOptionResolver } from 'discord.js';
|
||||
import { PayloadType } from '../core';
|
||||
import { AnyModule } from './core-modules';
|
||||
|
||||
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 interface SernEventsMapping {
|
||||
'module.register': [Payload];
|
||||
'module.activate': [Payload];
|
||||
error: [Payload];
|
||||
warning: [Payload];
|
||||
modulesLoaded: [never?];
|
||||
}
|
||||
|
||||
export type Payload =
|
||||
| { type: PayloadType.Success; module: AnyModule }
|
||||
| { type: PayloadType.Failure; module?: AnyModule; reason: string | Error }
|
||||
| { type: PayloadType.Warning; reason: string };
|
||||
Reference in New Issue
Block a user