mirror of
https://github.com/sern-handler/handler
synced 2026-06-06 01:16:55 +00:00
feat!:(2.0 global services) (#156)
* style: prettier line feed changes
* style: prettier line feed changes
* feat: prototyping module manager
* feat: removing unused types
* feat: update location of module typings
* revert: port back to original interaction type checkers
* revert: port back to original interaction type checkers
* revert: remove unneeded type predicates
* feat: moving modules to its own contained class
* feat: getting global plugins some typings and adding contracts
* chore: fixing up and cleaning code
* feat: adding ModuleConfiguration helper fn and default module manager
* feat: solidifying contract
* revert: delete files
* chore: saving for later
* feat: prototyping module manager
* feat: removing unused types
* feat: update location of module typings
* revert: port back to original interaction type checkers
* revert: port back to original interaction type checkers
* revert: remove unneeded type predicates
* feat: moving modules to its own contained class
* feat: getting global plugins some typings and adding contracts
* chore: fixing up and cleaning code
* feat: adding ModuleConfiguration helper fn and default module manager
* feat: solidifying contract
* revert: delete files
* chore: saving for later
* feat: more merge conflicts
* feat: starting from scratch, add new typings
* feat: refactor ScopedPlugin typing
* feat: strengthening contracts
* chore: edit eslint
* feat: add addDependencies
* feat: add iti di
* feat: constfn util
* revert: delete old files
* remove: ModuleConfiguration
* feat: add sanity checker
* feat: add new error and update dependency
* feat: add sanity check for iti
* feat: add function helpers for di
* feat: add POC for sern di IOC
* feat: refactor DependenciesMap
* revert: remove old code
* feat: refactor makeDependencies fn
* chore(deps): update dependency @typescript-eslint/parser to v5.36.1 (#127)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
* chore(deps): update dependency @typescript-eslint/eslint-plugin to v5.36.1 (#126)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
* docs: Fix the code example (#128)
* chore(deps): update dependency @typescript-eslint/eslint-plugin to v5.36.2 (#130)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>
* chore(deps): update dependency @typescript-eslint/parser to v5.36.2 (#131)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>
* feat: allow constructable modules (#133)
* Update readFile.ts
* Update userDefinedEventsHandling.ts
* Update readyHandler.ts
* fix: ts error
Co-authored-by: Jacob Nguyen <76754747+jacoobes@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>
* revert: feat of allow constructable modules (#138)
Revert "feat: allow constructable modules (#133)"
This reverts commit 03936eb2ea.
* feat: update CODEOWNERS
* feat: classmodules@arcs (#143)
* feat: add class based commands
* docs: add deprecation warnings
* feat: add deprecation warnings
* feat: add more deprecation warnings
* feat: add prototype ClassModule abstract class
* feat: add EventModuleClass prototype, change names
* feat: more flexible contract
* feat: EventExecutable
* fix: typo
* feat: made abstract classes because of defaults
* fix: typings
* feat: update Context typings, update to djs v15
* chore: update typescript dependency
* chore: bump version
* chore: update ignore
* chore: prettier
* docs: change readme to be docusaurus compliant
* chore(main): release 1.2.0 (#145)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
* fix(autocomplete): now support multiple autocomplete options (#147)
* chore(main): release 1.2.1 (#148)
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
* feat: update location of module typings
* feat: getting global plugins some typings and adding contracts
* feat: adding ModuleConfiguration helper fn and default module manager
* feat: solidifying contract
* feat: removing unused types
* feat: update location of module typings
* feat: moving modules to its own contained class
* feat: getting global plugins some typings and adding contracts
* feat: solidifying contract
* revert: delete files
* chore: saving for later
* feat: more merge conflicts
* feat: starting from scratch, add new typings
* feat: strengthening contracts
* feat: add sanity check for iti
* feat: refactor DependenciesMap
* feat: adding POC back
* docs: add some deprecation warnings
* feat: remove client and sernEmitter
* feat: rebase global_services
* chore: oops rebase pkgjson fix
* fix: typings
* feat: iti update and getting di working
* feat: adding contracts and default provider
* feat: update typings and change logger
* fix: MapDeps typings and useContainer typings
* feat: moving handlers to 2.0
* feat: injecting crash handler
* feat: alpha logging injection?
* feat: injecting modulemanager in interactionhandler
* fix: typos and fixups
* fix: typos and fixups
* feat: moduleManager injection
* fix: crash on no module
* feat: i think optional dependencies work
* feat: add more optional support
* feat: make exclusion optional
* perf: simplify typings and reduce compile time
* fix: some typings adjustment, deprecating a field
* perf: simplifying plugin typings
* feat: remove addExternal
* feat: more simplifying typings
* perf: allow any and interfacify some types
* revert: remove horrendous Override type
* revert: delete interaction type predicates
* fix: unchecked cast to EventEmitter
* perf: remove unneeded creation of instance members
* feat: init test dir
* refactor: rename fn and short circuit name fn
* refactor: insert function
* feat: starting event module onEvent plugins and log payload
* feat: basic eventmodule event plugins?
* refactor: DRY
* feat: unify warning typing
* fix: typings
* feat: more progress on new eventModules
* feat: event modules with plugins!!?!?
* feat: making sernEmitter create default!!, readjust typings
* feat: inject sernEmitter emits and catch possible errors
* feat: add optionality to Logger dep type
* feat: context upgrade, fix circular emissions, crap ton of shit
* feat!: Module -> AnyModule, Added new SelectMenuInteractions, Changed some CommandType names
* feat: rudimentary onClick handler
* feat!: rename select menu command types, no distinguishing between text and alias
* docs: adding docs
* fix: forgot to change
* fix: logging undefined
* revert: remove spreadparams
* feat: export useContainerRaw function and fix smol bug
* feat: add iti DI disposeAll on crash
* fix: deferred execute
* feat!: rename BasePlugin -> Plugin
* feat: commandplugins for event modules, ill test later
* refactor: rename
* refactor: remove import
* feat: add deprecation warnings
* feat: update documentation comments
* perf: static'ify command plugin and event plugin typings
* refactor: remove redundant assignment
* feat: switch to pnpm
* chore: update pnpm lock
* fix: errors crashing and completing subscription
* feat: update example
* fix: overriding dependencies no matter what
* fix: bad rxjs docs
* refactor: destructuring
* feat: update typings for addDisposer
* feat: update packageManager field in package.json
* feat: grammar
Co-authored-by: jacoobes <jacobnguyend@gmail.com>
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: xxDeveloper <77380166+Murtatrxx@users.noreply.github.com>
Co-authored-by: Arcs <73959934+HighArcs@users.noreply.github.com>
Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Evo <85353424+EvolutionX-10@users.noreply.github.com>
This commit is contained in:
Jacob Nguyen
@@ -6,6 +6,8 @@
|
||||
"@typescript-eslint/no-non-null-assertion": "off",
|
||||
"quotes": [2, "single", { "avoidEscape": true, "allowTemplateLiterals": true }],
|
||||
"semi": ["error", "always"],
|
||||
"@typescript-eslint/no-empty-interface": 0
|
||||
"@typescript-eslint/no-empty-interface": 0,
|
||||
"@typescript-eslint/ban-types" : 0,
|
||||
"@typescript-eslint/no-explicit-any": "off"
|
||||
}
|
||||
}
|
||||
|
||||
15
README.md
15
README.md
@@ -58,11 +58,20 @@ const client = new Client({
|
||||
GatewayIntentBits.GuildMessages
|
||||
]
|
||||
});
|
||||
export const useContainer = Sern.makeDependencies({
|
||||
build: root => root
|
||||
.add({ '@sern/client': single(client) })
|
||||
.add({ '@sern/logger': single(new DefaultLogging()) })
|
||||
});
|
||||
|
||||
//View docs for all options
|
||||
Sern.init({
|
||||
client,
|
||||
defaultPrefix,
|
||||
commands : 'src/commands',
|
||||
defaultPrefix: '!', // removing defaultPrefix will shut down text commands
|
||||
commands: 'src/commands',
|
||||
// events: 'src/events' (optional),
|
||||
containerConfig : {
|
||||
get: useContainer
|
||||
}
|
||||
});
|
||||
|
||||
client.login(token);
|
||||
|
||||
4878
package-lock.json
generated
4878
package-lock.json
generated
File diff suppressed because it is too large
Load Diff
11
package.json
11
package.json
@@ -1,6 +1,7 @@
|
||||
{
|
||||
"name": "@sern/handler",
|
||||
"version": "1.2.1",
|
||||
"packageManager": "pnpm@7.18.2",
|
||||
"version": "2.0.0",
|
||||
"description": "A customizable, batteries-included, powerful discord.js framework to automate and streamline bot development.",
|
||||
"main": "dist/cjs/index.cjs",
|
||||
"module": "dist/esm/index.mjs",
|
||||
@@ -17,7 +18,8 @@
|
||||
"lint": "eslint src/**/*.ts",
|
||||
"format": "eslint src/**/*.ts --fix",
|
||||
"build": "tsup && node scripts/mkjson.mjs dist/cjs dist/esm && tsup --dts-only --outDir dist",
|
||||
"publish": "npm run build && npm publish"
|
||||
"publish": "npm run build && npm publish",
|
||||
"pretty": "prettier --write ."
|
||||
},
|
||||
"keywords": [
|
||||
"sern-handler",
|
||||
@@ -31,6 +33,7 @@
|
||||
"author": "SernDevs",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"iti": "^0.5.0",
|
||||
"rxjs": "^7.5.6",
|
||||
"ts-pattern": "^4.0.2",
|
||||
"ts-results-es": "^3.5.0"
|
||||
@@ -41,10 +44,10 @@
|
||||
"eslint": "8.25.0",
|
||||
"prettier": "2.7.1",
|
||||
"tsup": "^6.1.3",
|
||||
"typescript": "^4.8.3"
|
||||
"typescript": "4.9.4"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"discord.js": "^14.5.x"
|
||||
"discord.js": ">= ^14.7.x"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
|
||||
1738
pnpm-lock.yaml
generated
Normal file
1738
pnpm-lock.yaml
generated
Normal file
File diff suppressed because it is too large
Load Diff
49
src/handler/contracts/errorHandling.ts
Normal file
49
src/handler/contracts/errorHandling.ts
Normal file
@@ -0,0 +1,49 @@
|
||||
import type { Observable } from 'rxjs';
|
||||
import type { Logging } from './logging';
|
||||
import { useContainerRaw } from '../dependencies/provider';
|
||||
import util from 'util';
|
||||
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
|
||||
}
|
||||
|
||||
export class DefaultErrorHandling implements ErrorHandling {
|
||||
keepAlive = 5;
|
||||
crash(error: Error): never {
|
||||
throw error;
|
||||
}
|
||||
updateAlive(e: 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) {
|
||||
useContainerRaw()?.disposeAll().then(() => {
|
||||
logging?.info({ message: 'Cleaning container and crashing' });
|
||||
});
|
||||
crashHandler.crash(err);
|
||||
}
|
||||
//formatted payload
|
||||
logging?.error({ message: util.format(pload) });
|
||||
crashHandler.updateAlive(err);
|
||||
return caught;
|
||||
};
|
||||
}
|
||||
3
src/handler/contracts/index.ts
Normal file
3
src/handler/contracts/index.ts
Normal file
@@ -0,0 +1,3 @@
|
||||
export { ErrorHandling, DefaultErrorHandling } from './errorHandling';
|
||||
export { Logging, DefaultLogging } from './logging';
|
||||
export { ModuleManager, DefaultModuleManager } from './moduleManager';
|
||||
28
src/handler/contracts/logging.ts
Normal file
28
src/handler/contracts/logging.ts
Normal file
@@ -0,0 +1,28 @@
|
||||
import type { LogPayload } from '../../types/handler';
|
||||
|
||||
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 class DefaultLogging implements Logging {
|
||||
private date = () => new Date();
|
||||
debug(payload: LogPayload): void {
|
||||
console.debug(`DEBUG: ${this.date().toISOString()} -> ${payload.message}`);
|
||||
}
|
||||
|
||||
error(payload: LogPayload): void {
|
||||
console.error(`ERROR: ${this.date().toISOString()} -> ${payload.message}`);
|
||||
}
|
||||
|
||||
info(payload: LogPayload): void {
|
||||
console.info(`INFO: ${this.date().toISOString()} -> ${payload.message}`);
|
||||
}
|
||||
|
||||
warning(payload: LogPayload): void {
|
||||
console.warn(`WARN: ${this.date().toISOString()} -> ${payload.message}`);
|
||||
}
|
||||
|
||||
}
|
||||
20
src/handler/contracts/moduleManager.ts
Normal file
20
src/handler/contracts/moduleManager.ts
Normal file
@@ -0,0 +1,20 @@
|
||||
import type { CommandModuleDefs } from '../../types/module';
|
||||
import type { CommandType } from '../structures/enums';
|
||||
import type { ModuleStore } from '../structures/moduleStore';
|
||||
|
||||
|
||||
export interface ModuleManager {
|
||||
get<T extends CommandType>(strat : (ms: ModuleStore) => CommandModuleDefs[T] | undefined) : CommandModuleDefs[T] | undefined
|
||||
set(strat: (ms: ModuleStore) => void) : void
|
||||
}
|
||||
|
||||
export class DefaultModuleManager implements ModuleManager {
|
||||
constructor(private moduleStore: ModuleStore) {}
|
||||
get<T extends CommandType>(strat: (ms: ModuleStore) => CommandModuleDefs[T] | undefined) {
|
||||
return strat(this.moduleStore);
|
||||
}
|
||||
|
||||
set(strat: (ms: ModuleStore) => void): void {
|
||||
strat(this.moduleStore);
|
||||
}
|
||||
}
|
||||
3
src/handler/dependencies/index.ts
Normal file
3
src/handler/dependencies/index.ts
Normal file
@@ -0,0 +1,3 @@
|
||||
export {
|
||||
useContainer
|
||||
} from './provider';
|
||||
83
src/handler/dependencies/provider.ts
Normal file
83
src/handler/dependencies/provider.ts
Normal file
@@ -0,0 +1,83 @@
|
||||
import type { Container } from 'iti';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { BehaviorSubject } from 'rxjs';
|
||||
import * as assert from 'assert';
|
||||
import type { Dependencies, MapDeps } from '../../types/handler';
|
||||
import SernEmitter from '../sernEmitter';
|
||||
import { _const, ok } from '../utilities/functions';
|
||||
import { DefaultErrorHandling, DefaultModuleManager, Logging } from '../contracts';
|
||||
import { ModuleStore } from '../structures/moduleStore';
|
||||
import { Ok, Result } from 'ts-results-es';
|
||||
import { DefaultLogging } from '../contracts';
|
||||
|
||||
export const containerSubject = new BehaviorSubject<Container<Dependencies, Partial<Dependencies>> | null>(null);
|
||||
export function composeRoot<T extends Dependencies>(root: Container<Partial<T>, Partial<Dependencies>>, exclusion: Set<keyof Dependencies>) {
|
||||
const client = root.get('@sern/client');
|
||||
assert.ok(client !== undefined, SernError.MissingRequired);
|
||||
//A utility function checking if a dependency has been declared excluded
|
||||
const excluded = (key: keyof Dependencies) => exclusion.has(key);
|
||||
//Wraps a fetch to the container in a Result, deferring the action
|
||||
const get = <T>(key : keyof Dependencies) => Result.wrap(() => root.get(key) as T);
|
||||
const getOr = (key: keyof Dependencies, elseAction: () => unknown) => {
|
||||
//Gets dependency but if an Err, map to a function that upserts.
|
||||
const dep = get(key).mapErr(() => elseAction);
|
||||
if(dep.err) {
|
||||
//Defers upsert until final check here
|
||||
return dep.val();
|
||||
}
|
||||
};
|
||||
const xGetOr = (key: keyof Dependencies, action: () => unknown) => {
|
||||
if(excluded(key)) {
|
||||
get(key) //if dev created a dependency but excluded, deletes on root composition
|
||||
.andThen(() => Ok(root.delete(key)))
|
||||
.unwrapOr(ok());
|
||||
} else {
|
||||
getOr(key, action);
|
||||
}
|
||||
|
||||
};
|
||||
xGetOr('@sern/emitter', () => root.upsert({
|
||||
'@sern/emitter' : _const(new SernEmitter())
|
||||
})
|
||||
);
|
||||
//An "optional" dependency
|
||||
xGetOr('@sern/logger', () => {
|
||||
root.upsert({
|
||||
'@sern/logger' : _const(new DefaultLogging())
|
||||
});
|
||||
}
|
||||
);
|
||||
xGetOr('@sern/store', () => root.upsert({
|
||||
'@sern/store' : _const(new ModuleStore())
|
||||
})
|
||||
);
|
||||
xGetOr('@sern/modules', () => root.upsert((ctx) => ({
|
||||
'@sern/modules' : _const(new DefaultModuleManager(ctx['@sern/store'] as ModuleStore))
|
||||
}))
|
||||
);
|
||||
xGetOr('@sern/errors', () => root.upsert({
|
||||
'@sern/errors': _const(new DefaultErrorHandling())
|
||||
})
|
||||
);
|
||||
//If logger exists, log info, else do nothing.
|
||||
get<Logging>('@sern/logger')
|
||||
.map((logger => logger.info({ message: 'All dependencies loaded successfully' })))
|
||||
.unwrapOr(ok());
|
||||
}
|
||||
|
||||
|
||||
export function useContainer<T extends Dependencies>() {
|
||||
const container = containerSubject.getValue()! as unknown as Container<T, {}>;
|
||||
assert.ok(container !== null, 'useContainer was called before Sern#init');
|
||||
//weird edge case, why can i not use _const here?
|
||||
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.
|
||||
* Exposes some methods from iti
|
||||
*/
|
||||
export function useContainerRaw() {
|
||||
return containerSubject.getValue();
|
||||
}
|
||||
@@ -1,32 +1,36 @@
|
||||
import type {
|
||||
BothCommand,
|
||||
ButtonCommand,
|
||||
ContextMenuMsg,
|
||||
ContextMenuUser,
|
||||
ModalSubmitCommand,
|
||||
SelectMenuCommand,
|
||||
SlashCommand,
|
||||
} from '../structures/module';
|
||||
import Context from '../structures/context';
|
||||
import type { SlashOptions } from '../../types/handler';
|
||||
import { asyncResolveArray } from '../utilities/asyncResolveArray';
|
||||
import type { Payload, SlashOptions } from '../../types/handler';
|
||||
import { arrAsync } from '../utilities/arrAsync';
|
||||
import { controller } from '../sern';
|
||||
import type {
|
||||
ButtonInteraction,
|
||||
ModalSubmitInteraction,
|
||||
SelectMenuInteraction,
|
||||
AutocompleteInteraction,
|
||||
ChatInputCommandInteraction,
|
||||
Interaction,
|
||||
UserContextMenuCommandInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
} from 'discord.js';
|
||||
import { isAutocomplete } from '../utilities/predicates';
|
||||
import { SernError } from '../structures/errors';
|
||||
import treeSearch from '../utilities/treeSearch';
|
||||
import type {
|
||||
BothCommand,
|
||||
ButtonCommand, ContextMenuMsg,
|
||||
ContextMenuUser,
|
||||
ModalSubmitCommand,
|
||||
StringSelectCommand,
|
||||
SlashCommand, UserSelectCommand, ChannelSelectCommand, MentionableSelectCommand, RoleSelectCommand,
|
||||
} from '../../types/module';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import { EventEmitter } from 'events';
|
||||
import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from '../structures/events';
|
||||
import * as assert from 'assert';
|
||||
import { reducePlugins } from '../utilities/functions';
|
||||
import { concatMap, from, fromEvent, map, of } from 'rxjs';
|
||||
import type { MessageComponentInteraction } from 'discord.js';
|
||||
|
||||
export function applicationCommandDispatcher(interaction: Interaction) {
|
||||
if (isAutocomplete(interaction)) {
|
||||
if (interaction.isAutocomplete()) {
|
||||
return dispatchAutocomplete(interaction);
|
||||
} else {
|
||||
const ctx = Context.wrap(interaction as ChatInputCommandInteraction);
|
||||
@@ -34,7 +38,7 @@ export function applicationCommandDispatcher(interaction: Interaction) {
|
||||
return (mod: BothCommand | SlashCommand) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(ctx, args),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([ctx, args], controller)),
|
||||
),
|
||||
});
|
||||
@@ -48,7 +52,7 @@ export function dispatchAutocomplete(interaction: AutocompleteInteraction) {
|
||||
return {
|
||||
mod,
|
||||
execute: () => selectedOption.command.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
selectedOption.command.onEvent.map(e => e.execute(interaction, controller)),
|
||||
),
|
||||
};
|
||||
@@ -63,7 +67,7 @@ export function modalCommandDispatcher(interaction: ModalSubmitInteraction) {
|
||||
return (mod: ModalSubmitCommand) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
|
||||
),
|
||||
});
|
||||
@@ -73,18 +77,19 @@ export function buttonCommandDispatcher(interaction: ButtonInteraction) {
|
||||
return (mod: ButtonCommand) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function selectMenuCommandDispatcher(interaction: SelectMenuInteraction) {
|
||||
return (mod: SelectMenuCommand) => ({
|
||||
export function selectMenuCommandDispatcher(interaction: MessageComponentInteraction) {
|
||||
//safe casts because command type runtime check
|
||||
return (mod: StringSelectCommand | UserSelectCommand | ChannelSelectCommand | MentionableSelectCommand | RoleSelectCommand) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
|
||||
execute: () => mod.execute(interaction as never),
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction as never], controller)),
|
||||
),
|
||||
});
|
||||
}
|
||||
@@ -93,7 +98,7 @@ export function ctxMenuUserDispatcher(interaction: UserContextMenuCommandInterac
|
||||
return (mod: ContextMenuUser) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
|
||||
),
|
||||
});
|
||||
@@ -103,8 +108,63 @@ export function ctxMenuMsgDispatcher(interaction: MessageContextMenuCommandInter
|
||||
return (mod: ContextMenuMsg) => ({
|
||||
mod,
|
||||
execute: () => mod.execute(interaction),
|
||||
eventPluginRes: asyncResolveArray(
|
||||
eventPluginRes: arrAsync(
|
||||
mod.onEvent.map(plugs => plugs.execute([interaction], controller)),
|
||||
),
|
||||
});
|
||||
}
|
||||
|
||||
export function sernEmitterDispatcher(e: SernEmitter) {
|
||||
return(cmd: SernEventCommand & { name: string }) => ({
|
||||
source: e,
|
||||
cmd,
|
||||
execute: fromEvent(e, cmd.name)
|
||||
.pipe( map( event => ({
|
||||
event,
|
||||
executeEvent: of(event).pipe(concatMap(event =>
|
||||
reducePlugins(from(
|
||||
arrAsync(
|
||||
cmd.onEvent.map(plug => plug.execute([event as Payload], controller))
|
||||
))
|
||||
)))
|
||||
})))
|
||||
});
|
||||
}
|
||||
|
||||
export function discordEventDispatcher(e: EventEmitter) {
|
||||
return (cmd: DiscordEventCommand & { name: string }) => ({
|
||||
source: e,
|
||||
cmd,
|
||||
execute: fromEvent(e, cmd.name)
|
||||
.pipe( map( event => ({
|
||||
event,
|
||||
executeEvent: of(event).pipe(concatMap( event =>
|
||||
reducePlugins(from(
|
||||
arrAsync(
|
||||
// god forbid I use any!!!
|
||||
cmd.onEvent.map(plug => plug.execute([event as any], controller))
|
||||
))
|
||||
)))
|
||||
})))
|
||||
});
|
||||
}
|
||||
|
||||
export function externalEventDispatcher(e: (e:ExternalEventCommand) => unknown) {
|
||||
return (cmd: ExternalEventCommand & { name: string}) => {
|
||||
const external = e(cmd);
|
||||
assert.ok(external instanceof EventEmitter, `${e} is not an EventEmitter`);
|
||||
return {
|
||||
source: external,
|
||||
cmd,
|
||||
execute: fromEvent(external, cmd.name)
|
||||
.pipe(map(event => ({
|
||||
event,
|
||||
executeEvent : of(event).pipe(concatMap(event =>
|
||||
reducePlugins(from(arrAsync(
|
||||
cmd.onEvent.map(plug => plug.execute([event], controller))
|
||||
)))
|
||||
)),
|
||||
})))
|
||||
};
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,10 +1,31 @@
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
import { Subject, type Observable } from 'rxjs';
|
||||
import type { EventEmitter } from 'events';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import type { ErrorHandling, Logging, ModuleManager } from '../contracts';
|
||||
|
||||
export abstract class EventsHandler<T> {
|
||||
protected payloadSubject = new Subject<T>();
|
||||
protected abstract discordEvent: Observable<unknown>;
|
||||
protected constructor(protected wrapper: Wrapper) {}
|
||||
protected client: EventEmitter;
|
||||
protected emitter: SernEmitter;
|
||||
protected crashHandler: ErrorHandling;
|
||||
protected logger?: Logging;
|
||||
protected modules: ModuleManager;
|
||||
protected constructor({ containerConfig }: Wrapper) {
|
||||
const [
|
||||
client,
|
||||
emitter,
|
||||
crash,
|
||||
modules,
|
||||
logger,
|
||||
] = containerConfig.get('@sern/client', '@sern/emitter', '@sern/errors', '@sern/modules', '@sern/logger');
|
||||
this.logger = logger as Logging|undefined;
|
||||
this.modules = modules as ModuleManager;
|
||||
this.client = client as EventEmitter;
|
||||
this.emitter = emitter as SernEmitter;
|
||||
this.crashHandler = crash as ErrorHandling;
|
||||
}
|
||||
protected abstract init(): void;
|
||||
protected abstract setState(state: T): void;
|
||||
}
|
||||
|
||||
@@ -2,14 +2,6 @@ import type { Interaction } from 'discord.js';
|
||||
import { catchError, concatMap, from, fromEvent, map, Observable } from 'rxjs';
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
import { EventsHandler } from './eventsHandler';
|
||||
import {
|
||||
isApplicationCommand,
|
||||
isAutocomplete,
|
||||
isMessageComponent,
|
||||
isModalSubmit,
|
||||
} from '../utilities/predicates';
|
||||
import * as Files from '../utilities/readFile';
|
||||
import type { CommandModule } from '../structures/module';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { CommandType, PayloadType } from '../structures/enums';
|
||||
import { match, P } from 'ts-pattern';
|
||||
@@ -24,69 +16,69 @@ import {
|
||||
import type {
|
||||
ButtonInteraction,
|
||||
ModalSubmitInteraction,
|
||||
SelectMenuInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
} from 'discord.js';
|
||||
import { executeModule } from './observableHandling';
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import { handleError } from '../contracts/errorHandling';
|
||||
import type { ModuleStore } from '../structures/moduleStore';
|
||||
import type { MessageComponentInteraction } from 'discord.js';
|
||||
|
||||
export default class InteractionHandler extends EventsHandler<{
|
||||
event: Interaction;
|
||||
mod: CommandModule;
|
||||
}> {
|
||||
protected override discordEvent: Observable<Interaction>;
|
||||
|
||||
constructor(protected wrapper: Wrapper) {
|
||||
constructor(wrapper: Wrapper) {
|
||||
super(wrapper);
|
||||
this.discordEvent = <Observable<Interaction>>fromEvent(wrapper.client, 'interactionCreate');
|
||||
this.discordEvent = <Observable<Interaction>>fromEvent(this.client, 'interactionCreate');
|
||||
this.init();
|
||||
|
||||
this.payloadSubject
|
||||
.pipe(
|
||||
map(this.processModules),
|
||||
concatMap(({ mod, execute, eventPluginRes }) => {
|
||||
//resolve all the Results from event plugins
|
||||
return from(eventPluginRes).pipe(map(res => ({ mod, res, execute })));
|
||||
}),
|
||||
concatMap(({ mod, execute, eventPluginRes }) =>
|
||||
from(eventPluginRes).pipe(map(res => ({ mod, res, execute }))) //resolve all the Results from event plugins
|
||||
),
|
||||
concatMap(payload => executeModule(wrapper, payload)),
|
||||
catchError((err, caught) => {
|
||||
wrapper.sernEmitter?.emit('error', err);
|
||||
return caught;
|
||||
}),
|
||||
catchError(handleError(this.crashHandler, this.logger)),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
|
||||
override init() {
|
||||
const get = (cb: (ms: ModuleStore) => CommandModule|undefined) => {
|
||||
return this.modules.get(cb);
|
||||
};
|
||||
this.discordEvent.subscribe({
|
||||
next: event => {
|
||||
if (isMessageComponent(event)) {
|
||||
const mod = Files.MessageCompCommands[event.componentType].get(event.customId);
|
||||
if (event.isMessageComponent()) {
|
||||
const mod = get(ms =>
|
||||
ms.InteractionHandlers[event.componentType].get(event.customId));
|
||||
this.setState({ event, mod });
|
||||
} else if (isApplicationCommand(event) || isAutocomplete(event)) {
|
||||
const mod =
|
||||
Files.ApplicationCommands[event.commandType].get(event.commandName) ??
|
||||
Files.BothCommands.get(event.commandName);
|
||||
} else if (event.isCommand() || event.isAutocomplete()) {
|
||||
const mod = get(ms =>
|
||||
ms.ApplicationCommands[event.commandType].get(event.commandName) ??
|
||||
ms.BothCommands.get(event.commandName)
|
||||
);
|
||||
this.setState({ event, mod });
|
||||
} else if (isModalSubmit(event)) {
|
||||
/**
|
||||
* maybe move modal submits into message component object maps?
|
||||
*/
|
||||
const mod = Files.ModalSubmitCommands.get(event.customId);
|
||||
} else if (event.isModalSubmit()) {
|
||||
const mod = get((ms) => ms.InteractionHandlers[5].get(event.customId));
|
||||
this.setState({ event, mod });
|
||||
} else {
|
||||
throw Error('This interaction is not supported yet');
|
||||
}
|
||||
},
|
||||
error: reason => {
|
||||
this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason });
|
||||
this.emitter.emit('error', { type: PayloadType.Failure, reason });
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
protected setState(state: { event: Interaction; mod: CommandModule | undefined }): void {
|
||||
if (state.mod === undefined) {
|
||||
this.wrapper?.sernEmitter?.emit('warning', 'Found no module for this interaction');
|
||||
this.emitter.emit('warning',{ type: PayloadType.Warning, reason: 'Found no module for this interaction' });
|
||||
} else {
|
||||
//if statement above checks already, safe cast
|
||||
this.payloadSubject.next(state as { event: Interaction; mod: CommandModule });
|
||||
@@ -105,19 +97,23 @@ export default class InteractionHandler extends EventsHandler<{
|
||||
)
|
||||
.with({ type: CommandType.Button }, buttonCommandDispatcher(event as ButtonInteraction))
|
||||
.with(
|
||||
{ type: CommandType.MenuSelect },
|
||||
selectMenuCommandDispatcher(event as SelectMenuInteraction),
|
||||
{ type: P.union(
|
||||
CommandType.RoleSelect,
|
||||
CommandType.StringSelect,
|
||||
CommandType.UserSelect,
|
||||
CommandType.MentionableSelect,
|
||||
CommandType.ChannelSelect
|
||||
) },
|
||||
selectMenuCommandDispatcher(event as MessageComponentInteraction),
|
||||
)
|
||||
.with(
|
||||
{ type: CommandType.MenuUser },
|
||||
{ type: CommandType.CtxUser },
|
||||
ctxMenuUserDispatcher(event as UserContextMenuCommandInteraction),
|
||||
)
|
||||
.with(
|
||||
{ type: CommandType.MenuMsg },
|
||||
{ type: CommandType.CtxMsg },
|
||||
ctxMenuMsgDispatcher(event as MessageContextMenuCommandInteraction),
|
||||
)
|
||||
.otherwise(() => {
|
||||
throw Error(SernError.MismatchModule);
|
||||
});
|
||||
.otherwise(() => this.crashHandler.crash(Error(SernError.MismatchModule)));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -5,11 +5,12 @@ import type { Message } from 'discord.js';
|
||||
import { executeModule, ignoreNonBot, isOneOfCorrectModules } from './observableHandling';
|
||||
import { fmt } from '../utilities/messageHelpers';
|
||||
import Context from '../structures/context';
|
||||
import * as Files from '../utilities/readFile';
|
||||
import type { TextCommand } from '../structures/module';
|
||||
import { CommandType, PayloadType } from '../structures/enums';
|
||||
import { asyncResolveArray } from '../utilities/asyncResolveArray';
|
||||
import { arrAsync } from '../utilities/arrAsync';
|
||||
import { controller } from '../sern';
|
||||
import type { CommandModule, TextCommand } from '../../types/module';
|
||||
import { handleError } from '../contracts/errorHandling';
|
||||
import type { ModuleStore } from '../structures/moduleStore';
|
||||
|
||||
export default class MessageHandler extends EventsHandler<{
|
||||
ctx: Context;
|
||||
@@ -17,29 +18,22 @@ export default class MessageHandler extends EventsHandler<{
|
||||
mod: TextCommand;
|
||||
}> {
|
||||
protected discordEvent: Observable<Message>;
|
||||
public constructor(wrapper: Wrapper) {
|
||||
public constructor(protected wrapper: Wrapper) {
|
||||
super(wrapper);
|
||||
this.discordEvent = <Observable<Message>>fromEvent(wrapper.client, 'messageCreate');
|
||||
this.discordEvent = <Observable<Message>>fromEvent(this.client, 'messageCreate');
|
||||
this.init();
|
||||
this.payloadSubject
|
||||
.pipe(
|
||||
switchMap(({ mod, ctx, args }) => {
|
||||
const res = asyncResolveArray(
|
||||
mod.onEvent.map(ePlug => {
|
||||
return ePlug.execute([ctx, args], controller);
|
||||
}),
|
||||
const res = arrAsync(
|
||||
mod.onEvent.map(ep => ep.execute([ctx, args], controller)),
|
||||
);
|
||||
const execute = () => {
|
||||
return mod.execute(ctx, args);
|
||||
};
|
||||
const execute = () => mod.execute(ctx, args);
|
||||
//resolves the promise and re-emits it back into source
|
||||
return from(res).pipe(map(res => ({ mod, execute, res })));
|
||||
}),
|
||||
concatMap(payload => executeModule(wrapper, payload)),
|
||||
catchError((err, caught) => {
|
||||
wrapper.sernEmitter?.emit('error', err);
|
||||
return caught;
|
||||
}),
|
||||
catchError(handleError(this.crashHandler, this.logger)),
|
||||
)
|
||||
.subscribe();
|
||||
}
|
||||
@@ -47,6 +41,9 @@ export default class MessageHandler extends EventsHandler<{
|
||||
protected init(): void {
|
||||
if (this.wrapper.defaultPrefix === undefined) return; //for now, just ignore if prefix doesn't exist
|
||||
const { defaultPrefix } = this.wrapper;
|
||||
const get = (cb: (ms: ModuleStore) => CommandModule | undefined) => {
|
||||
return this.modules.get(cb);
|
||||
};
|
||||
this.discordEvent
|
||||
.pipe(
|
||||
ignoreNonBot(this.wrapper.defaultPrefix),
|
||||
@@ -55,10 +52,10 @@ export default class MessageHandler extends EventsHandler<{
|
||||
return {
|
||||
ctx: Context.wrap(message),
|
||||
args: <['text', string[]]>['text', rest],
|
||||
mod:
|
||||
Files.TextCommands.text.get(prefix) ??
|
||||
Files.BothCommands.get(prefix) ??
|
||||
Files.TextCommands.aliases.get(prefix),
|
||||
mod: get(ms =>
|
||||
ms.TextCommands.get(prefix) ??
|
||||
ms.BothCommands.get(prefix)
|
||||
),
|
||||
};
|
||||
}),
|
||||
concatMap(element =>
|
||||
@@ -71,7 +68,7 @@ export default class MessageHandler extends EventsHandler<{
|
||||
.subscribe({
|
||||
next: value => this.setState(value),
|
||||
error: reason =>
|
||||
this.wrapper.sernEmitter?.emit('error', { type: PayloadType.Failure, reason }),
|
||||
this.emitter.emit('error', { type: PayloadType.Failure, reason }),
|
||||
});
|
||||
}
|
||||
|
||||
|
||||
@@ -1,11 +1,16 @@
|
||||
import type { Message } from 'discord.js';
|
||||
import { concatMap, from, Observable, of, tap, throwError } from 'rxjs';
|
||||
import { concatMap, from, map, Observable, of, switchMap, tap, throwError, toArray } from 'rxjs';
|
||||
import { SernError } from '../structures/errors';
|
||||
import type { Module, CommandModuleDefs, CommandModule } from '../structures/module';
|
||||
import { Result } from 'ts-results-es';
|
||||
import type { CommandType } from '../structures/enums';
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
import { PayloadType } from '../structures/enums';
|
||||
import { PayloadType, PluginType } from '../structures/enums';
|
||||
import type { CommandModule, CommandModuleDefs, AnyModule } from '../../types/module';
|
||||
import { _const } from '../utilities/functions';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
|
||||
import type { Awaitable } from 'discord.js';
|
||||
import { processCommandPlugins } from './userDefinedEventsHandling';
|
||||
|
||||
export function ignoreNonBot(prefix: string) {
|
||||
return (src: Observable<Message>) =>
|
||||
@@ -31,7 +36,7 @@ export function ignoreNonBot(prefix: string) {
|
||||
* If the current value in Result stream is an error, calls callback.
|
||||
* @param cb
|
||||
*/
|
||||
export function errTap<T extends Module>(cb: (err: SernError) => void) {
|
||||
export function errTap<T extends AnyModule>(cb: (err: SernError) => void) {
|
||||
return (src: Observable<Result<{ mod: T; absPath: string }, SernError>>) =>
|
||||
new Observable<{ mod: T; absPath: string }>(subscriber => {
|
||||
return src.subscribe({
|
||||
@@ -55,12 +60,12 @@ export function isOneOfCorrectModules<T extends readonly CommandType[]>(...input
|
||||
return src.subscribe({
|
||||
next(mod) {
|
||||
if (mod === undefined) {
|
||||
return throwError(() => SernError.UndefinedModule);
|
||||
return throwError(_const(SernError.UndefinedModule));
|
||||
}
|
||||
if (inputs.some(type => (mod.type & type) !== 0)) {
|
||||
subscriber.next(mod as CommandModuleDefs[T[number]]);
|
||||
} else {
|
||||
return throwError(() => SernError.MismatchModule);
|
||||
return throwError(_const(SernError.MismatchModule));
|
||||
}
|
||||
},
|
||||
error: e => subscriber.error(e),
|
||||
@@ -78,10 +83,9 @@ export function executeModule(
|
||||
res: Result<void, void>[];
|
||||
},
|
||||
) {
|
||||
const emitter = wrapper.containerConfig.get('@sern/emitter')[0] as SernEmitter;
|
||||
if (payload.res.every(el => el.ok)) {
|
||||
const executeFn = Result.wrapAsync<unknown, Error | string>(() =>
|
||||
Promise.resolve(payload.execute()),
|
||||
);
|
||||
const executeFn = Result.wrapAsync<unknown, Error | string>(() => Promise.resolve(payload.execute()));
|
||||
return from(executeFn).pipe(
|
||||
concatMap(res => {
|
||||
if (res.err) {
|
||||
@@ -93,7 +97,7 @@ export function executeModule(
|
||||
}
|
||||
return of(res.val).pipe(
|
||||
tap(() =>
|
||||
wrapper.sernEmitter?.emit('module.activate', {
|
||||
emitter.emit('module.activate', {
|
||||
type: PayloadType.Success,
|
||||
module: payload.mod,
|
||||
}),
|
||||
@@ -102,7 +106,7 @@ export function executeModule(
|
||||
}),
|
||||
);
|
||||
} else {
|
||||
wrapper.sernEmitter?.emit('module.activate', {
|
||||
emitter.emit('module.activate', {
|
||||
type: PayloadType.Failure,
|
||||
module: payload.mod,
|
||||
reason: SernError.PluginFailure,
|
||||
@@ -110,3 +114,30 @@ export function executeModule(
|
||||
return of(undefined);
|
||||
}
|
||||
}
|
||||
|
||||
export function resolvePlugins({ mod, cmdPluginRes }: {
|
||||
mod: DefinedCommandModule | DefinedEventModule;
|
||||
cmdPluginRes: {
|
||||
execute: Awaitable<Result<void, void>>;
|
||||
type: PluginType.Command;
|
||||
}[];
|
||||
}) {
|
||||
if (mod.plugins.length === 0) {
|
||||
return of({ mod, pluginRes: [] });
|
||||
}
|
||||
// modules with no event plugins are ignored in the previous
|
||||
return from(cmdPluginRes).pipe(
|
||||
switchMap(pl =>
|
||||
from(pl.execute).pipe(
|
||||
map(execute => ({ ...pl, execute })),
|
||||
toArray(),
|
||||
),
|
||||
),
|
||||
map(pluginRes => ({ mod, pluginRes })),
|
||||
);
|
||||
}
|
||||
|
||||
export function processPlugins(payload: { mod: DefinedCommandModule | DefinedEventModule; absPath: string }) {
|
||||
const cmdPluginRes = processCommandPlugins(payload);
|
||||
return of({ mod: payload.mod, cmdPluginRes });
|
||||
}
|
||||
@@ -1,18 +1,18 @@
|
||||
import { EventsHandler } from './eventsHandler';
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
import { concatMap, fromEvent, Observable, map, take, of, from, toArray, switchMap } from 'rxjs';
|
||||
import type { CommandModule } from '../structures/module';
|
||||
import { concatMap, fromEvent, Observable, map, take } from 'rxjs';
|
||||
import * as Files from '../utilities/readFile';
|
||||
import { errTap } from './observableHandling';
|
||||
import type { DefinedCommandModule } from '../../types/handler';
|
||||
import { basename } from 'path';
|
||||
import { CommandType, PayloadType, PluginType } from '../structures/enums';
|
||||
import { processCommandPlugins } from './userDefinedEventsHandling';
|
||||
import type { Awaitable } from 'discord.js';
|
||||
import { errTap, processPlugins, resolvePlugins } from './observableHandling';
|
||||
import { CommandType, PayloadType } from '../structures/enums';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { match } from 'ts-pattern';
|
||||
import { type Result, Err, Ok } from 'ts-results-es';
|
||||
import { Result } from 'ts-results-es';
|
||||
import { ApplicationCommandType, ComponentType } from 'discord.js';
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import type { DefinedCommandModule, DefinedEventModule } from '../../types/handler';
|
||||
import type { ModuleManager } from '../contracts';
|
||||
import type { ModuleStore } from '../structures/moduleStore';
|
||||
import { _const, err, nameOrFilename, ok } from '../utilities/functions';
|
||||
|
||||
export default class ReadyHandler extends EventsHandler<{
|
||||
mod: DefinedCommandModule;
|
||||
@@ -21,12 +21,12 @@ export default class ReadyHandler extends EventsHandler<{
|
||||
protected discordEvent!: Observable<{ mod: CommandModule; absPath: string }>;
|
||||
constructor(wrapper: Wrapper) {
|
||||
super(wrapper);
|
||||
const ready$ = fromEvent(this.wrapper.client, 'ready').pipe(take(1));
|
||||
const ready$ = fromEvent(this.client, 'ready').pipe(take(1));
|
||||
this.discordEvent = ready$.pipe(
|
||||
concatMap(() =>
|
||||
Files.buildData<CommandModule>(this.wrapper.commands).pipe(
|
||||
Files.buildData<CommandModule>(wrapper.commands).pipe(
|
||||
errTap(reason =>
|
||||
wrapper.sernEmitter?.emit('module.register', {
|
||||
this.emitter.emit('module.register', {
|
||||
type: PayloadType.Failure,
|
||||
module: undefined,
|
||||
reason,
|
||||
@@ -38,22 +38,21 @@ export default class ReadyHandler extends EventsHandler<{
|
||||
this.init();
|
||||
this.payloadSubject
|
||||
.pipe(
|
||||
concatMap(payload => this.processPlugins(payload)),
|
||||
concatMap(payload => this.resolvePlugins(payload)),
|
||||
)
|
||||
.subscribe(payload => {
|
||||
concatMap(processPlugins),
|
||||
concatMap(resolvePlugins),
|
||||
).subscribe(payload => {
|
||||
const allPluginsSuccessful = payload.pluginRes.every(({ execute }) => execute.ok);
|
||||
if (allPluginsSuccessful) {
|
||||
const res = registerModule(payload.mod);
|
||||
const res = registerModule(this.modules, payload.mod);
|
||||
if (res.err) {
|
||||
throw Error(SernError.InvalidModuleType);
|
||||
this.crashHandler.crash(Error(SernError.InvalidModuleType));
|
||||
}
|
||||
wrapper.sernEmitter?.emit('module.register', {
|
||||
this.emitter.emit('module.register', {
|
||||
type: PayloadType.Success,
|
||||
module: payload.mod,
|
||||
});
|
||||
} else {
|
||||
wrapper.sernEmitter?.emit('module.register', {
|
||||
this.emitter.emit('module.register', {
|
||||
type: PayloadType.Failure,
|
||||
module: payload.mod,
|
||||
reason: SernError.PluginFailure,
|
||||
@@ -68,45 +67,13 @@ export default class ReadyHandler extends EventsHandler<{
|
||||
return {
|
||||
absPath,
|
||||
mod: {
|
||||
name: mod?.name ?? Files.fmtFileName(basename(absPath)),
|
||||
name: nameOrFilename(mod.name, absPath),
|
||||
description: mod?.description ?? '...',
|
||||
...mod,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
private resolvePlugins({
|
||||
mod,
|
||||
cmdPluginRes,
|
||||
}: {
|
||||
mod: DefinedCommandModule;
|
||||
cmdPluginRes: {
|
||||
name: string;
|
||||
description: string;
|
||||
execute: Awaitable<Result<void, void>>;
|
||||
type: PluginType.Command;
|
||||
}[];
|
||||
}) {
|
||||
if (mod.plugins.length === 0) {
|
||||
return of({ mod, pluginRes: [] });
|
||||
}
|
||||
// modules with no event plugins are ignored in the previous
|
||||
return from(cmdPluginRes).pipe(
|
||||
switchMap(pl =>
|
||||
from(pl.execute).pipe(
|
||||
map(execute => ({ ...pl, execute })),
|
||||
toArray(),
|
||||
),
|
||||
),
|
||||
map(pluginRes => ({ mod, pluginRes })),
|
||||
);
|
||||
}
|
||||
|
||||
private processPlugins(payload: { mod: DefinedCommandModule; absPath: string }) {
|
||||
const cmdPluginRes = processCommandPlugins(this.wrapper, payload);
|
||||
return of({ mod: payload.mod, cmdPluginRes });
|
||||
}
|
||||
|
||||
protected init() {
|
||||
this.discordEvent.pipe(map(ReadyHandler.intoDefinedModule)).subscribe({
|
||||
next: value => this.setState(value),
|
||||
@@ -118,42 +85,50 @@ export default class ReadyHandler extends EventsHandler<{
|
||||
}
|
||||
}
|
||||
|
||||
function registerModule(mod: DefinedCommandModule): Result<void, void> {
|
||||
function registerModule(manager: ModuleManager, mod: DefinedCommandModule | DefinedEventModule): Result<void, void> {
|
||||
const name = mod.name;
|
||||
return match<DefinedCommandModule>(mod)
|
||||
const insert = (cb: (ms: ModuleStore) => void) => {
|
||||
const set = Result.wrap(_const(manager.set(cb)));
|
||||
return set.ok ? ok() : err();
|
||||
};
|
||||
return match<DefinedCommandModule | DefinedEventModule>(mod)
|
||||
.with({ type: CommandType.Text }, mod => {
|
||||
mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
|
||||
Files.TextCommands.text.set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.with({ type: CommandType.Slash }, mod => {
|
||||
Files.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
|
||||
return insert(ms => ms.TextCommands.set(name, mod));
|
||||
})
|
||||
.with({ type: CommandType.Slash }, mod =>
|
||||
insert(ms => ms.ApplicationCommands[ApplicationCommandType.ChatInput].set(name, mod))
|
||||
)
|
||||
.with({ type: CommandType.Both }, mod => {
|
||||
Files.BothCommands.set(name, mod);
|
||||
mod.alias?.forEach(a => Files.TextCommands.aliases.set(a, mod));
|
||||
return Ok.EMPTY;
|
||||
mod.alias?.forEach(a => insert(ms => ms.TextCommands.set(a, mod)));
|
||||
return insert( ms => ms.BothCommands.set(name, mod));
|
||||
})
|
||||
.with({ type: CommandType.MenuUser }, mod => {
|
||||
Files.ApplicationCommands[ApplicationCommandType.User].set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.with({ type: CommandType.MenuMsg }, mod => {
|
||||
Files.ApplicationCommands[ApplicationCommandType.Message].set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.with({ type: CommandType.Button }, mod => {
|
||||
Files.MessageCompCommands[ComponentType.Button].set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.with({ type: CommandType.MenuSelect }, mod => {
|
||||
Files.MessageCompCommands[ComponentType.SelectMenu].set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.with({ type: CommandType.Modal }, mod => {
|
||||
Files.ModalSubmitCommands.set(name, mod);
|
||||
return Ok.EMPTY;
|
||||
})
|
||||
.otherwise(() => Err.EMPTY);
|
||||
.with({ type: CommandType.CtxUser }, mod =>
|
||||
insert(ms => ms.ApplicationCommands[ApplicationCommandType.User].set(name, mod))
|
||||
)
|
||||
.with({ type: CommandType.CtxMsg }, mod =>
|
||||
insert(ms => ms.ApplicationCommands[ApplicationCommandType.Message].set(name, mod))
|
||||
)
|
||||
.with({ type: CommandType.Button }, mod =>
|
||||
insert(ms => ms.InteractionHandlers[ComponentType.Button].set(name, mod))
|
||||
)
|
||||
.with({ type: CommandType.StringSelect }, mod =>
|
||||
insert(ms => ms.InteractionHandlers[ComponentType.StringSelect].set(name, mod))
|
||||
)
|
||||
.with( { type: CommandType.MentionableSelect }, mod =>
|
||||
insert (ms => ms.InteractionHandlers[ComponentType.MentionableSelect].set(name, mod))
|
||||
)
|
||||
.with( { type: CommandType.ChannelSelect }, mod =>
|
||||
insert ( ms => ms.InteractionHandlers[ComponentType.ChannelSelect].set(name, mod))
|
||||
)
|
||||
.with( { type: CommandType.UserSelect }, mod =>
|
||||
insert ( ms => ms.InteractionHandlers[ComponentType.UserSelect].set(name, mod))
|
||||
)
|
||||
.with( { type: CommandType.RoleSelect}, mod =>
|
||||
insert ( ms => ms.InteractionHandlers[ComponentType.RoleSelect].set(name, mod))
|
||||
)
|
||||
.with({ type: CommandType.Modal }, mod =>
|
||||
insert(ms => ms.ModalSubmit.set(name, mod))
|
||||
)
|
||||
.otherwise(err);
|
||||
}
|
||||
|
||||
@@ -1,87 +1,108 @@
|
||||
import { from, fromEvent, map } from 'rxjs';
|
||||
import * as Files from '../utilities/readFile';
|
||||
import { buildData, ExternalEventEmitters } from '../utilities/readFile';
|
||||
import { catchError, concatMap, filter, from, iif, map, of, tap, toArray } from 'rxjs';
|
||||
import { buildData } from '../utilities/readFile';
|
||||
import { controller } from '../sern';
|
||||
import type {
|
||||
DefinedCommandModule,
|
||||
DefinedEventModule,
|
||||
EventInput,
|
||||
SpreadParams,
|
||||
} from '../../types/handler';
|
||||
import type { EventModule } from '../structures/module';
|
||||
import { PayloadType } from '../structures/enums';
|
||||
import type { DefinedCommandModule, DefinedEventModule, Dependencies } from '../../types/handler';
|
||||
import { PayloadType, PluginType } from '../structures/enums';
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
import { basename } from 'path';
|
||||
import { isDiscordEvent, isExternalEvent, isSernEvent } from '../utilities/predicates';
|
||||
import { errTap, processPlugins, resolvePlugins } from './observableHandling';
|
||||
import type { AnyModule, EventModule } from '../../types/module';
|
||||
import type { EventEmitter } from 'events';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import { nameOrFilename, reducePlugins } from '../utilities/functions';
|
||||
import { match } from 'ts-pattern';
|
||||
import { isDiscordEvent, isSernEvent } from '../utilities/predicates';
|
||||
import { errTap } from './observableHandling';
|
||||
import { discordEventDispatcher, externalEventDispatcher, sernEmitterDispatcher } from './dispatchers';
|
||||
import type { ErrorHandling, Logging } from '../contracts';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { handleError } from '../contracts/errorHandling';
|
||||
import type { Awaitable } from 'discord.js';
|
||||
import type { Result } from 'ts-results-es';
|
||||
|
||||
/**
|
||||
* Utility function to process command plugins for all Modules
|
||||
* @param wrapper
|
||||
* @param payload
|
||||
*/
|
||||
export function processCommandPlugins<T extends DefinedCommandModule>(
|
||||
wrapper: Wrapper,
|
||||
export function processCommandPlugins<T extends DefinedCommandModule | DefinedEventModule>(
|
||||
payload: { mod: T; absPath: string },
|
||||
) {
|
||||
): {type: PluginType.Command, execute: Awaitable<Result<void,void>>}[] {
|
||||
return payload.mod.plugins.map(plug => ({
|
||||
...plug,
|
||||
name: plug?.name ?? 'Unnamed Plugin',
|
||||
description: plug?.description ?? '...',
|
||||
execute: plug.execute(wrapper, payload, controller),
|
||||
type: plug.type,
|
||||
execute: plug.execute(payload as any, controller),
|
||||
}));
|
||||
}
|
||||
|
||||
export function processEvents(wrapper: Wrapper, events: EventInput) {
|
||||
const eventStream$ = eventObservable$(wrapper, events);
|
||||
const normalize$ = eventStream$.pipe(
|
||||
map(({ mod, absPath }) => {
|
||||
return <DefinedEventModule>{
|
||||
name: mod?.name ?? Files.fmtFileName(basename(absPath)),
|
||||
description: mod?.description ?? '...',
|
||||
export function processEvents({ containerConfig, events }: Wrapper) {
|
||||
const [
|
||||
client,
|
||||
error,
|
||||
sernEmitter,
|
||||
logging
|
||||
] = containerConfig.get('@sern/client', '@sern/errors', '@sern/emitter', '@sern/logger') as [EventEmitter, ErrorHandling, SernEmitter, Logging?];
|
||||
const lazy = (k: string) => containerConfig.get(k as keyof Dependencies)[0];
|
||||
const eventStream$ = eventObservable$(events!, sernEmitter);
|
||||
const emitSuccess$ = (mod: AnyModule) =>
|
||||
of({ type: PayloadType.Failure, module: mod, reason: SernError.PluginFailure })
|
||||
.pipe(tap( it => sernEmitter.emit('module.register', it)));
|
||||
const emitFailure$ = (mod: AnyModule) =>
|
||||
of({ type: PayloadType.Success, module: mod, } as const)
|
||||
.pipe(tap(it => sernEmitter.emit('module.register', it)));
|
||||
const eventCreation$ = eventStream$.pipe(
|
||||
map(({ mod, absPath }) => ({
|
||||
mod : {
|
||||
name: nameOrFilename(mod.name, absPath),
|
||||
...mod,
|
||||
};
|
||||
}),
|
||||
} as DefinedEventModule,
|
||||
absPath
|
||||
})),
|
||||
concatMap(processPlugins),
|
||||
concatMap(resolvePlugins),
|
||||
//Reduces pluginRes (generated from above) into a single boolean
|
||||
concatMap(({pluginRes, mod}) => from(pluginRes)
|
||||
.pipe(
|
||||
map(pl => pl.execute),
|
||||
toArray(),
|
||||
reducePlugins,
|
||||
map(success => ({ success, mod }))
|
||||
)),
|
||||
concatMap(({ success, mod }) =>
|
||||
iif(() => success,
|
||||
emitFailure$(mod),
|
||||
emitSuccess$(mod)
|
||||
).pipe(
|
||||
filter(res => res.type === PayloadType.Success),
|
||||
map(() => mod)
|
||||
)
|
||||
),
|
||||
);
|
||||
normalize$.subscribe(e => {
|
||||
const emitter = isSernEvent(e)
|
||||
? wrapper?.sernEmitter
|
||||
: isDiscordEvent(e)
|
||||
? wrapper.client
|
||||
: ExternalEventEmitters.get(e.emitter);
|
||||
if (emitter === undefined) {
|
||||
throw new Error(`Cannot find event emitter as it is undefined`);
|
||||
}
|
||||
//Would add sern event emitter for events loaded, attached onto sern emitter, but could lead to unwanted behavior!
|
||||
fromEvent(emitter, e.name, e.execute as SpreadParams<typeof e.execute>).subscribe();
|
||||
eventCreation$.subscribe(e => {
|
||||
const payload = match(e)
|
||||
.when(isSernEvent, sernEmitterDispatcher(sernEmitter))
|
||||
.when(isDiscordEvent, discordEventDispatcher(client))
|
||||
.when(isExternalEvent, externalEventDispatcher(e => lazy(e.emitter)))
|
||||
.otherwise(() => error.crash(Error(SernError.InvalidModuleType)));
|
||||
payload
|
||||
.execute
|
||||
.pipe(
|
||||
concatMap(({event, executeEvent}) =>
|
||||
executeEvent
|
||||
.pipe( tap(success => {
|
||||
if(success)
|
||||
payload.cmd.execute(event as never);
|
||||
}), catchError(handleError(error, logging)))
|
||||
),
|
||||
).subscribe();
|
||||
});
|
||||
}
|
||||
|
||||
function eventObservable$({ sernEmitter }: Wrapper, events: EventInput) {
|
||||
return match(events)
|
||||
.when(Array.isArray, (arr: { mod: EventModule; absPath: string }[]) => {
|
||||
return from(arr);
|
||||
})
|
||||
.when(
|
||||
e => typeof e === 'string',
|
||||
(eventsDir: string) => {
|
||||
return buildData<EventModule>(eventsDir).pipe(
|
||||
errTap(reason =>
|
||||
sernEmitter?.emit('module.register', {
|
||||
type: PayloadType.Failure,
|
||||
module: undefined,
|
||||
reason,
|
||||
}),
|
||||
),
|
||||
);
|
||||
},
|
||||
)
|
||||
.when(
|
||||
e => typeof e === 'function',
|
||||
(evs: () => { mod: EventModule; absPath: string }[]) => {
|
||||
return from(evs());
|
||||
},
|
||||
)
|
||||
.run();
|
||||
function eventObservable$(events: string, emitter: SernEmitter) {
|
||||
return buildData<EventModule>(events)
|
||||
.pipe(
|
||||
errTap(reason =>
|
||||
emitter.emit('module.register', {
|
||||
type: PayloadType.Failure,
|
||||
module: undefined,
|
||||
reason,
|
||||
}),
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
@@ -11,136 +11,99 @@
|
||||
* Plugins are reminiscent of middleware in express.
|
||||
*/
|
||||
|
||||
import type { AutocompleteInteraction, Awaitable, Client, ClientEvents } from 'discord.js';
|
||||
import type { AutocompleteInteraction, Awaitable, ClientEvents } from 'discord.js';
|
||||
import type { Result, Ok, Err } from 'ts-results-es';
|
||||
import type { CommandType, DefinitelyDefined, Override, SernEventsMapping } from '../../index';
|
||||
import type { CommandType, SernEventsMapping } from '../../index';
|
||||
import { EventType, PluginType } from '../../index';
|
||||
import type { BaseModule, CommandModuleDefs, EventModuleDefs } from '../structures/module';
|
||||
import type { EventEmitter } from 'events';
|
||||
import type { CommandModuleDefs, EventModuleDefs } from '../../types/module';
|
||||
import type {
|
||||
DiscordEventCommand,
|
||||
ExternalEventCommand,
|
||||
SernEventCommand,
|
||||
} from '../structures/events';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import type Wrapper from '../structures/wrapper';
|
||||
|
||||
export interface Controller {
|
||||
next: () => Ok<void>;
|
||||
stop: () => Err<void>;
|
||||
}
|
||||
export interface Plugin {
|
||||
/** @deprecated will be removed in the next update */
|
||||
name?: string;
|
||||
/** @deprecated will be removed in the next update */
|
||||
description?: string;
|
||||
type: PluginType
|
||||
}
|
||||
|
||||
type BasePlugin = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: PluginType;
|
||||
}
|
||||
>;
|
||||
|
||||
export type CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
|
||||
[K in T]: Override<
|
||||
BasePlugin,
|
||||
{
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
wrapper: Wrapper,
|
||||
payload: {
|
||||
mod: DefinitelyDefined<CommandModuleDefs[T], 'name' | 'description'>;
|
||||
absPath: string;
|
||||
},
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
}[T];
|
||||
|
||||
export type DiscordEmitterPlugin = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
export interface CommandPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> extends Plugin {
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
payload: {
|
||||
mod: CommandModuleDefs[T] & { name : string; description : string };
|
||||
absPath: string;
|
||||
},
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
export interface DiscordEmitterPlugin extends Plugin {
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
wrapper: Client,
|
||||
module: DefinitelyDefined<DiscordEventCommand, 'name' | 'description'>,
|
||||
payload: { mod: DiscordEventCommand & { name: string }; absPath: string },
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
export type ExternalEmitterPlugin<T extends EventEmitter = EventEmitter> = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
wrapper: T,
|
||||
module: DefinitelyDefined<ExternalEventCommand, 'name' | 'description'>,
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
}
|
||||
|
||||
export type SernEmitterPlugin = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
wrapper: SernEmitter,
|
||||
module: DefinitelyDefined<SernEventCommand, 'name' | 'description'>,
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
export interface ExternalEmitterPlugin extends Plugin {
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
payload: { mod: ExternalEventCommand & { name : string }; absPath: string } ,
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export type AutocompletePlugin = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
autocmp: AutocompleteInteraction,
|
||||
controlller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
export interface SernEmitterPlugin extends Plugin {
|
||||
type: PluginType.Command;
|
||||
execute: (
|
||||
payload: { mod : SernEventCommand & { name : string }; absPath: string },
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export type EventPlugin<T extends keyof CommandModuleDefs = keyof CommandModuleDefs> = {
|
||||
[K in T]: Override<
|
||||
BasePlugin,
|
||||
{
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
event: Parameters<CommandModuleDefs[K]['execute']>,
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
}[T];
|
||||
export interface AutocompletePlugin extends Plugin {
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
autocmp: AutocompleteInteraction,
|
||||
controlller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export type SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
name?: T;
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
args: SernEventsMapping[T],
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type ExternalEventPlugin = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
type: PluginType.Event;
|
||||
execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
export interface EventPlugin<K extends keyof CommandModuleDefs = keyof CommandModuleDefs> extends Plugin {
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
event: Parameters<CommandModuleDefs[K]['execute']>,
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export type DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> = Override<
|
||||
BasePlugin,
|
||||
{
|
||||
name?: T;
|
||||
type: PluginType.Event;
|
||||
execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
>;
|
||||
export interface SernEventPlugin<T extends keyof SernEventsMapping = keyof SernEventsMapping> extends Plugin {
|
||||
name?: T;
|
||||
type: PluginType.Event;
|
||||
execute: (
|
||||
args: SernEventsMapping[T],
|
||||
controller: Controller,
|
||||
) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export interface ExternalEventPlugin extends Plugin {
|
||||
type: PluginType.Event;
|
||||
execute: (args: unknown[], controller: Controller) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export interface DiscordEventPlugin<T extends keyof ClientEvents = keyof ClientEvents> extends Plugin {
|
||||
name?: T;
|
||||
type: PluginType.Event;
|
||||
execute: (args: ClientEvents[T], controller: Controller) => Awaitable<Result<void, void>>;
|
||||
}
|
||||
|
||||
export type CommandModuleNoPlugins = {
|
||||
[T in CommandType]: Omit<CommandModuleDefs[T], 'plugins' | 'onEvent'>;
|
||||
|
||||
@@ -1,16 +1,8 @@
|
||||
import type Wrapper from './structures/wrapper';
|
||||
import { Err, Ok } from 'ts-results-es';
|
||||
import { ExternalEventEmitters } from './utilities/readFile';
|
||||
import type { EventEmitter } from 'events';
|
||||
import { processEvents } from './events/userDefinedEventsHandling';
|
||||
import type {
|
||||
CommandModule,
|
||||
CommandModuleDefs,
|
||||
EventModule,
|
||||
EventModuleDefs,
|
||||
} from './structures/module';
|
||||
import { CommandType, EventType, PluginType } from './structures/enums';
|
||||
import type {
|
||||
Plugin,
|
||||
CommandPlugin,
|
||||
EventModuleCommandPluginDefs,
|
||||
EventModuleEventPluginDefs,
|
||||
@@ -18,11 +10,15 @@ import type {
|
||||
InputCommandModule,
|
||||
InputEventModule,
|
||||
} from './plugins/plugin';
|
||||
import { SernError } from './structures/errors';
|
||||
import InteractionHandler from './events/interactionHandler';
|
||||
import ReadyHandler from './events/readyHandler';
|
||||
import MessageHandler from './events/messageHandler';
|
||||
|
||||
import type { CommandModule, CommandModuleDefs, EventModule, EventModuleDefs } from '../types/module';
|
||||
import { Container, createContainer } from 'iti';
|
||||
import type { Dependencies, OptionalDependencies } from '../types/handler';
|
||||
import { composeRoot, containerSubject, useContainer } from './dependencies/provider';
|
||||
import type { Logging } from './contracts';
|
||||
import { err, ok, partition } from './utilities/functions';
|
||||
/**
|
||||
*
|
||||
* @param wrapper Options to pass into sern.
|
||||
@@ -30,58 +26,35 @@ import MessageHandler from './events/messageHandler';
|
||||
* @example
|
||||
* ```ts title="src/index.ts"
|
||||
* Sern.init({
|
||||
* client,
|
||||
* 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 startTime = performance.now();
|
||||
const { events } = wrapper;
|
||||
if (events !== undefined) {
|
||||
processEvents(wrapper, events);
|
||||
processEvents(wrapper);
|
||||
}
|
||||
new ReadyHandler(wrapper);
|
||||
new MessageHandler(wrapper);
|
||||
new InteractionHandler(wrapper);
|
||||
}
|
||||
|
||||
/**
|
||||
* @deprecated - use Sern#makeDependencies instead
|
||||
* @param emitter Any external event emitter.
|
||||
* The object will be stored in a map, and then fetched by the name of the instance's class.
|
||||
* As there are infinite possibilities to adding external event emitters,
|
||||
* Most types aren't provided and are as narrow as possibly can.
|
||||
* @example
|
||||
* ```ts title="src/index.ts"
|
||||
* //Add this before initiating Sern!
|
||||
* Sern.addExternal(new Level())
|
||||
* ```
|
||||
* @example
|
||||
* ```ts title="events/level.ts"
|
||||
* export default eventModule({
|
||||
* emitter: 'Level',
|
||||
* type : EventType.External,
|
||||
* name: 'error',
|
||||
* execute(args) {
|
||||
* console.log(args)
|
||||
* }
|
||||
* })
|
||||
* ```
|
||||
*/
|
||||
export function addExternal<T extends EventEmitter>(emitter: T) {
|
||||
if (ExternalEventEmitters.has(emitter.constructor.name)) {
|
||||
throw Error(`${emitter.constructor.name} already exists!`);
|
||||
}
|
||||
ExternalEventEmitters.set(emitter.constructor.name, emitter);
|
||||
const endTime = performance.now();
|
||||
logger?.info({ message: `sern : ${(endTime-startTime).toFixed(2)} ms` });
|
||||
}
|
||||
|
||||
/**
|
||||
* The object passed into every plugin to control a command's behavior
|
||||
*/
|
||||
export const controller = {
|
||||
next: () => Ok.EMPTY,
|
||||
stop: () => Err.EMPTY,
|
||||
next: ok,
|
||||
stop: err,
|
||||
};
|
||||
|
||||
/**
|
||||
@@ -89,16 +62,7 @@ export const controller = {
|
||||
* @param mod
|
||||
*/
|
||||
export function commandModule(mod: InputCommandModule): CommandModule {
|
||||
const onEvent: EventPlugin[] = [];
|
||||
const plugins: CommandPlugin[] = [];
|
||||
for (const pl of mod.plugins ?? []) {
|
||||
if (pl.type === PluginType.Event) {
|
||||
onEvent.push(pl);
|
||||
} else {
|
||||
plugins.push(pl as CommandPlugin);
|
||||
}
|
||||
}
|
||||
|
||||
const [onEvent, plugins] = partition(mod.plugins ?? [], el => (el as Plugin).type === PluginType.Event);
|
||||
return {
|
||||
...mod,
|
||||
onEvent,
|
||||
@@ -110,20 +74,25 @@ export function commandModule(mod: InputCommandModule): CommandModule {
|
||||
* @param mod
|
||||
*/
|
||||
export function eventModule(mod: InputEventModule): EventModule {
|
||||
const onEvent: EventModuleEventPluginDefs[EventType][] = [];
|
||||
const plugins: EventModuleCommandPluginDefs[EventType][] = [];
|
||||
const hasPlugins = mod.plugins && mod.plugins.length > 0;
|
||||
if (hasPlugins) {
|
||||
throw Error(
|
||||
SernError.NotSupportedYet + `: Plugins on event listeners are not supported yet`,
|
||||
);
|
||||
}
|
||||
return {
|
||||
const [onEvent, plugins] = partition(mod.plugins ?? [], el => (el as Plugin).type === PluginType.Event);
|
||||
return {
|
||||
...mod,
|
||||
onEvent,
|
||||
plugins,
|
||||
} as EventModule;
|
||||
}
|
||||
/**
|
||||
* @param conf a configuration for creating your project dependencies
|
||||
*/
|
||||
export function makeDependencies<T extends Dependencies>(conf: {
|
||||
exclude?: Set<OptionalDependencies>,
|
||||
build: (root: Container<Record<string,any>, {}>) => Container<Partial<T>, T>,
|
||||
}) {
|
||||
const container = conf.build(createContainer());
|
||||
composeRoot(container, conf.exclude ?? new Set());
|
||||
containerSubject.next(container as unknown as Container<Dependencies, {}>);
|
||||
return useContainer<T>();
|
||||
}
|
||||
|
||||
export abstract class CommandExecutable<Type extends CommandType> {
|
||||
abstract type: Type;
|
||||
|
||||
@@ -27,7 +27,7 @@ class SernEmitter extends EventEmitter {
|
||||
/**
|
||||
* Listening to sern events with on. This event stays on until a crash or a normal exit
|
||||
* @param eventName
|
||||
* @param args the arguments for emitting the { eventName }
|
||||
* @param args the arguments for emitting the eventName
|
||||
*/
|
||||
public override emit<T extends keyof SernEventsMapping>(
|
||||
eventName: T,
|
||||
|
||||
@@ -1,48 +1,36 @@
|
||||
import type { APIGuildMember } from 'discord-api-types/v10';
|
||||
import type {
|
||||
ChatInputCommandInteraction,
|
||||
Client,
|
||||
Guild,
|
||||
GuildMember,
|
||||
InteractionReplyOptions,
|
||||
Message,
|
||||
Snowflake,
|
||||
TextBasedChannel,
|
||||
MessageReplyOptions,
|
||||
User,
|
||||
} from 'discord.js';
|
||||
import { type Option, None, Some } from 'ts-results-es';
|
||||
import type { Nullish, ReplyOptions } from '../../types/handler';
|
||||
import { Result as Either, Ok as Left, Err as Right } from 'ts-results-es';
|
||||
import type { ReplyOptions } from '../../types/handler';
|
||||
import { SernError } from './errors';
|
||||
|
||||
function firstSome<T>(...args: Option<T>[]): Nullish<T> {
|
||||
for (const op of args) {
|
||||
if (op.some) return op.val;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
//Could I refactor with Either monad?
|
||||
function safeUnwrap<T>(res: Either<T, T>) {
|
||||
return res.val;
|
||||
}
|
||||
/**
|
||||
* Provides values shared between
|
||||
* Message and ChatInputCommandInteraction
|
||||
*/
|
||||
export default class Context {
|
||||
private constructor(
|
||||
private oMsg: Option<Message> = None,
|
||||
private oInterac: Option<ChatInputCommandInteraction> = None,
|
||||
) {
|
||||
this.oMsg = oMsg;
|
||||
this.oInterac = oInterac;
|
||||
}
|
||||
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
|
||||
*/
|
||||
public get message() {
|
||||
return this.oMsg.expect(SernError.MismatchEvent);
|
||||
public get message() {
|
||||
return this.ctx.expect(SernError.MismatchEvent);
|
||||
}
|
||||
/**
|
||||
* Getting the ChatInputCommandInteraction object. Crashes if module type is
|
||||
@@ -50,96 +38,95 @@ export default class Context {
|
||||
* Message
|
||||
*/
|
||||
public get interaction() {
|
||||
return this.oInterac.expect(SernError.MismatchEvent);
|
||||
return this.ctx.expectErr(SernError.MismatchEvent);
|
||||
}
|
||||
|
||||
public get id(): Snowflake {
|
||||
return firstSome(
|
||||
this.oInterac.map(i => i.id),
|
||||
this.oMsg.map(m => m.id),
|
||||
)!;
|
||||
return safeUnwrap(
|
||||
this.ctx
|
||||
.map(m => m.id)
|
||||
.mapErr(i => i.id));
|
||||
}
|
||||
|
||||
public get channel(): Nullish<TextBasedChannel> {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.channel),
|
||||
this.oInterac.map(i => i.channel),
|
||||
public get channel() {
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.channel)
|
||||
.mapErr(i => i.channel));
|
||||
}
|
||||
/**
|
||||
* If context is holding a message, message.author
|
||||
* else, interaction.user
|
||||
*/
|
||||
public get user(): User {
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.author)
|
||||
.mapErr(i => i.user)
|
||||
);
|
||||
}
|
||||
|
||||
public get user(): User {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.author),
|
||||
this.oInterac.map(i => i.user),
|
||||
)!;
|
||||
}
|
||||
|
||||
public get createdTimestamp(): number {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.createdTimestamp),
|
||||
this.oInterac.map(i => i.createdTimestamp),
|
||||
)!;
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.createdTimestamp)
|
||||
.mapErr(i => i.createdTimestamp)
|
||||
);
|
||||
}
|
||||
|
||||
public get guild(): Guild {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.guild),
|
||||
this.oInterac.map(i => i.guild),
|
||||
)!;
|
||||
public get guild() {
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.guild)
|
||||
.mapErr(i => i.guild)
|
||||
);
|
||||
}
|
||||
|
||||
public get guildId(): Snowflake {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.guildId),
|
||||
this.oInterac.map(i => i.guildId),
|
||||
)!;
|
||||
public get guildId() {
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.guildId)
|
||||
.mapErr(i => i.guildId)
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* interactions can return APIGuildMember if the guild it is emitted from is not cached
|
||||
*/
|
||||
public get member(): Nullish<GuildMember | APIGuildMember> {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.member),
|
||||
this.oInterac.map(i => i.member),
|
||||
public get member() {
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.member)
|
||||
.mapErr(i => i.member)
|
||||
);
|
||||
}
|
||||
|
||||
public get client(): Client {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.client),
|
||||
this.oInterac.map(i => i.client),
|
||||
)!;
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m => m.client)
|
||||
.mapErr(i => i.client)
|
||||
);
|
||||
}
|
||||
|
||||
public get inGuild(): boolean {
|
||||
return firstSome(
|
||||
this.oMsg.map(m => m.inGuild()),
|
||||
this.oInterac.map(i => i.inGuild()),
|
||||
)!;
|
||||
return safeUnwrap(this.ctx
|
||||
.map(m=>m.inGuild())
|
||||
.mapErr(i => i.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(None, Some(wrappable));
|
||||
return new Context(Right(wrappable));
|
||||
}
|
||||
return new Context(Some(wrappable), None);
|
||||
return new Context(Left(wrappable));
|
||||
}
|
||||
|
||||
public isEmpty() {
|
||||
return this.oMsg.none && this.oInterac.none;
|
||||
}
|
||||
//Make queueable
|
||||
public reply(content: ReplyOptions) {
|
||||
return firstSome(
|
||||
this.oInterac.map(i => {
|
||||
return i
|
||||
.reply(content as string | InteractionReplyOptions)
|
||||
.then(() => i.fetchReply());
|
||||
}),
|
||||
this.oMsg.map(m => {
|
||||
return m.reply(content as string | MessageReplyOptions);
|
||||
}),
|
||||
)!;
|
||||
return safeUnwrap(this.ctx
|
||||
.map( m => m.reply(content as string | MessageReplyOptions))
|
||||
.mapErr(i => i.reply(content as string | InteractionReplyOptions).then(() => i.fetchReply()))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
/**
|
||||
* A bitfield that discriminates command modules
|
||||
* @enum { number }
|
||||
* @example
|
||||
* ```ts
|
||||
@@ -16,38 +17,46 @@ export enum CommandType {
|
||||
/**
|
||||
* The CommandType for text commands
|
||||
*/
|
||||
Text = 0b00000000001,
|
||||
Text = 1,
|
||||
/**
|
||||
* The CommandType for slash commands
|
||||
*/
|
||||
Slash = 0b00000000010,
|
||||
Slash = 2,
|
||||
/**
|
||||
* The CommandType for hybrid commands, text and slash
|
||||
*/
|
||||
Both = 0b0000011,
|
||||
Both = 3,
|
||||
/**
|
||||
* The CommandType for UserContextMenuInteraction commands
|
||||
*/
|
||||
MenuUser = 0b00000000100,
|
||||
CtxUser = 4,
|
||||
/**
|
||||
* The CommandType for MessageContextMenuInteraction commands
|
||||
*/
|
||||
MenuMsg = 0b0000001000,
|
||||
CtxMsg = 8,
|
||||
/**
|
||||
* The CommandType for ButtonInteraction commands
|
||||
*/
|
||||
Button = 0b00000010000,
|
||||
Button = 16,
|
||||
/**
|
||||
* The CommandType for SelectMenuInteraction commands
|
||||
* The CommandType for StringSelectMenuInteraction commands
|
||||
*/
|
||||
MenuSelect = 0b00000100000,
|
||||
StringSelect = 32,
|
||||
/**
|
||||
* The CommandType for ModalSubmitInteraction commands
|
||||
*/
|
||||
Modal = 0b00001000000,
|
||||
Modal = 64,
|
||||
/**
|
||||
* The CommandType for the other SelectMenuInteractions
|
||||
*/
|
||||
ChannelSelect = 256,
|
||||
MentionableSelect = 512,
|
||||
RoleSelect= 1024,
|
||||
UserSelect= 2048
|
||||
}
|
||||
|
||||
/**
|
||||
* A bitfield that discriminates event modules
|
||||
* @enum { number }
|
||||
* @example
|
||||
* ```ts
|
||||
@@ -65,19 +74,20 @@ export enum EventType {
|
||||
/**
|
||||
* The EventType for handling discord events
|
||||
*/
|
||||
Discord = 0b01,
|
||||
Discord = 1,
|
||||
/**
|
||||
* The EventType for handling sern events
|
||||
*/
|
||||
Sern = 0b10,
|
||||
Sern = 2,
|
||||
/**
|
||||
* The EventType for handling external events.
|
||||
* Could be for example, `process` events, database events
|
||||
*/
|
||||
External = 0b11,
|
||||
External = 3,
|
||||
}
|
||||
|
||||
/**
|
||||
* A bitfield that discriminates plugins
|
||||
* @enum { number }
|
||||
* @example
|
||||
* ```ts
|
||||
@@ -94,11 +104,11 @@ export enum PluginType {
|
||||
/**
|
||||
* The PluginType for CommandPlugins
|
||||
*/
|
||||
Command = 0b01,
|
||||
Command = 1,
|
||||
/**
|
||||
* The PluginType for EventPlugins
|
||||
*/
|
||||
Event = 0b10,
|
||||
Event = 2,
|
||||
}
|
||||
/**
|
||||
* @enum { string }
|
||||
|
||||
@@ -31,4 +31,8 @@ export enum SernError {
|
||||
* 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,5 +1,4 @@
|
||||
import type { Override, SernEventsMapping } from '../../types/handler';
|
||||
import type { BaseModule } from './module';
|
||||
import type { SernEventsMapping } from '../../types/handler';
|
||||
import type {
|
||||
DiscordEmitterPlugin,
|
||||
DiscordEventPlugin,
|
||||
@@ -10,44 +9,30 @@ import type {
|
||||
} from '../plugins/plugin';
|
||||
import type { Awaitable, ClientEvents } from 'discord.js';
|
||||
import type { EventType } from './enums';
|
||||
import type { Module } from '../../types/module';
|
||||
|
||||
/*
|
||||
* Mapped type to generate all sern event modules
|
||||
*/
|
||||
export type SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> =
|
||||
Override<
|
||||
BaseModule,
|
||||
{
|
||||
name?: T;
|
||||
type: EventType.Sern;
|
||||
onEvent: SernEventPlugin[];
|
||||
plugins: SernEmitterPlugin[];
|
||||
execute(...args: SernEventsMapping[T]): Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
/*
|
||||
* Mapped type to generate all discord event modules
|
||||
*/
|
||||
export type DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> = Override<
|
||||
BaseModule,
|
||||
{
|
||||
name?: T;
|
||||
type: EventType.Discord;
|
||||
onEvent: DiscordEventPlugin[];
|
||||
plugins: DiscordEmitterPlugin[];
|
||||
execute(...args: ClientEvents[T]): Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
/*
|
||||
* Type for any event emitter that can be handled by sern
|
||||
*/
|
||||
export type ExternalEventCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
emitter: string;
|
||||
type: EventType.External;
|
||||
onEvent: ExternalEventPlugin[];
|
||||
plugins: ExternalEmitterPlugin[];
|
||||
execute(...args: unknown[]): Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export interface SernEventCommand<T extends keyof SernEventsMapping = keyof SernEventsMapping> extends Module {
|
||||
name?: T;
|
||||
type: EventType.Sern;
|
||||
onEvent: SernEventPlugin[];
|
||||
plugins: SernEmitterPlugin[];
|
||||
execute(...args: SernEventsMapping[T]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface DiscordEventCommand<T extends keyof ClientEvents = keyof ClientEvents> extends Module {
|
||||
name?: T;
|
||||
type: EventType.Discord;
|
||||
onEvent: DiscordEventPlugin[];
|
||||
plugins: DiscordEmitterPlugin[];
|
||||
execute(...args: ClientEvents[T]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ExternalEventCommand extends Module {
|
||||
name?: string
|
||||
emitter: string;
|
||||
type: EventType.External;
|
||||
onEvent: ExternalEventPlugin[];
|
||||
plugins: ExternalEmitterPlugin[];
|
||||
execute(...args: unknown[]): Awaitable<unknown>;
|
||||
}
|
||||
|
||||
@@ -1,210 +0,0 @@
|
||||
import type {
|
||||
ApplicationCommandAttachmentOption,
|
||||
ApplicationCommandChannelOptionData,
|
||||
ApplicationCommandChoicesData,
|
||||
ApplicationCommandNonOptionsData,
|
||||
ApplicationCommandNumericOptionData,
|
||||
ApplicationCommandOptionData,
|
||||
ApplicationCommandOptionType,
|
||||
ApplicationCommandSubCommandData,
|
||||
ApplicationCommandSubGroupData,
|
||||
AutocompleteInteraction,
|
||||
Awaitable,
|
||||
BaseApplicationCommandOptionsData,
|
||||
ButtonInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
ModalSubmitInteraction,
|
||||
SelectMenuInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
} from 'discord.js';
|
||||
import type { Args, Override, SlashOptions } from '../../types/handler';
|
||||
import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../plugins/plugin';
|
||||
import type Context from './context';
|
||||
import { CommandType, EventType, PluginType } from './enums';
|
||||
import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from './events';
|
||||
|
||||
export interface BaseModule {
|
||||
type: CommandType | PluginType;
|
||||
name?: string;
|
||||
description?: string;
|
||||
execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
|
||||
}
|
||||
|
||||
export type TextCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.Text;
|
||||
onEvent: EventPlugin<CommandType.Text>[]; //maybe allow BothPlugins for this also?
|
||||
plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
|
||||
alias?: string[];
|
||||
execute: (ctx: Context, args: ['text', string[]]) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type SlashCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.Slash;
|
||||
onEvent: EventPlugin<CommandType.Slash>[]; //maybe allow BothPlugins for this also?
|
||||
plugins: CommandPlugin[]; //maybe allow BothPlugins for this also?
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type BothCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.Both;
|
||||
onEvent: EventPlugin<CommandType.Both>[];
|
||||
plugins: CommandPlugin[];
|
||||
alias?: string[];
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: Args) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type ContextMenuUser = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.MenuUser;
|
||||
onEvent: EventPlugin<CommandType.MenuUser>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type ContextMenuMsg = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.MenuMsg;
|
||||
onEvent: EventPlugin<CommandType.MenuMsg>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type ButtonCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.Button;
|
||||
onEvent: EventPlugin<CommandType.Button>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: ButtonInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type SelectMenuCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.MenuSelect;
|
||||
onEvent: EventPlugin<CommandType.MenuSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: SelectMenuInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
export type ModalSubmitCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
type: CommandType.Modal;
|
||||
onEvent: EventPlugin<CommandType.Modal>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: ModalSubmitInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
|
||||
// Autocomplete commands are a little different
|
||||
// They can't have command plugins as they are
|
||||
// in conjunction with chat input commands
|
||||
export type AutocompleteCommand = Override<
|
||||
BaseModule,
|
||||
{
|
||||
name?: never;
|
||||
description?: never;
|
||||
type?: never;
|
||||
onEvent: AutocompletePlugin[];
|
||||
execute: (ctx: AutocompleteInteraction) => Awaitable<void | unknown>;
|
||||
}
|
||||
>;
|
||||
export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
|
||||
export type CommandModule =
|
||||
| TextCommand
|
||||
| SlashCommand
|
||||
| BothCommand
|
||||
| ContextMenuUser
|
||||
| ContextMenuMsg
|
||||
| ButtonCommand
|
||||
| SelectMenuCommand
|
||||
| ModalSubmitCommand;
|
||||
|
||||
export type Module = CommandModule | EventModule;
|
||||
|
||||
//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
|
||||
// Explicit Module Definitions for mapping
|
||||
export type CommandModuleDefs = {
|
||||
[CommandType.Text]: TextCommand;
|
||||
[CommandType.Slash]: SlashCommand;
|
||||
[CommandType.Both]: BothCommand;
|
||||
[CommandType.MenuMsg]: ContextMenuMsg;
|
||||
[CommandType.MenuUser]: ContextMenuUser;
|
||||
[CommandType.Button]: ButtonCommand;
|
||||
[CommandType.MenuSelect]: SelectMenuCommand;
|
||||
[CommandType.Modal]: ModalSubmitCommand;
|
||||
};
|
||||
|
||||
export type EventModuleDefs = {
|
||||
[EventType.Sern]: SernEventCommand;
|
||||
[EventType.Discord]: DiscordEventCommand;
|
||||
[EventType.External]: ExternalEventCommand;
|
||||
};
|
||||
|
||||
//TODO: support deeply nested Autocomplete
|
||||
// objective: construct union of ApplicationCommandOptionData change any Autocomplete data
|
||||
// into Sern autocomplete data.
|
||||
|
||||
export type SernAutocompleteData = Override<
|
||||
BaseApplicationCommandOptionsData,
|
||||
{
|
||||
autocomplete: true;
|
||||
type:
|
||||
| ApplicationCommandOptionType.String
|
||||
| ApplicationCommandOptionType.Number
|
||||
| ApplicationCommandOptionType.Integer;
|
||||
command: AutocompleteCommand;
|
||||
}
|
||||
>;
|
||||
|
||||
/**
|
||||
* Type that replaces autocomplete with {@link SernAutocompleteData}
|
||||
*/
|
||||
export type BaseOptions =
|
||||
| ApplicationCommandChoicesData
|
||||
| ApplicationCommandNonOptionsData
|
||||
| ApplicationCommandChannelOptionData
|
||||
| ApplicationCommandNumericOptionData
|
||||
| ApplicationCommandAttachmentOption
|
||||
| SernAutocompleteData;
|
||||
|
||||
export type SernSubCommandData = Override<
|
||||
Omit<BaseApplicationCommandOptionsData, 'required'>,
|
||||
{
|
||||
type: ApplicationCommandOptionType.Subcommand;
|
||||
options?: BaseOptions[];
|
||||
}
|
||||
>;
|
||||
|
||||
export type SernSubCommandGroupData = Override<
|
||||
Omit<BaseApplicationCommandOptionsData, 'required'>,
|
||||
{
|
||||
type: ApplicationCommandOptionType.SubcommandGroup;
|
||||
options?: SernSubCommandData[];
|
||||
}
|
||||
>;
|
||||
|
||||
export type SernOptionsData<U extends ApplicationCommandOptionData = ApplicationCommandOptionData> =
|
||||
U extends ApplicationCommandSubCommandData
|
||||
? SernSubCommandData
|
||||
: U extends ApplicationCommandSubGroupData
|
||||
? SernSubCommandGroupData
|
||||
: BaseOptions;
|
||||
26
src/handler/structures/moduleStore.ts
Normal file
26
src/handler/structures/moduleStore.ts
Normal file
@@ -0,0 +1,26 @@
|
||||
import type { CommandModule } from '../../types/module';
|
||||
import { ApplicationCommandType, ComponentType } from 'discord.js';
|
||||
|
||||
/**
|
||||
* Storing all command modules
|
||||
* This dependency is usually injected into ModuleManager
|
||||
*/
|
||||
export class ModuleStore {
|
||||
readonly BothCommands = new Map<string, CommandModule>();
|
||||
readonly ApplicationCommands = {
|
||||
[ApplicationCommandType.User]: new Map<string, CommandModule>(),
|
||||
[ApplicationCommandType.Message]: new Map<string, CommandModule>(),
|
||||
[ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
|
||||
};
|
||||
readonly ModalSubmit = new Map<string, CommandModule>();
|
||||
readonly TextCommands = new Map<string, CommandModule>();
|
||||
readonly InteractionHandlers = {
|
||||
[ComponentType.Button]: new Map<string, CommandModule>(),
|
||||
[ComponentType.StringSelect]: new Map<string, CommandModule>(),
|
||||
[ComponentType.ChannelSelect] : new Map<string, CommandModule>(),
|
||||
[ComponentType.MentionableSelect] : new Map<string, CommandModule>(),
|
||||
[ComponentType.RoleSelect] : new Map<string, CommandModule>(),
|
||||
[ComponentType.UserSelect] : new Map<string, CommandModule>(),
|
||||
};
|
||||
}
|
||||
|
||||
@@ -1,28 +1,10 @@
|
||||
import Context from './context';
|
||||
import type {
|
||||
BothCommand,
|
||||
Module,
|
||||
SlashCommand,
|
||||
TextCommand,
|
||||
SernOptionsData,
|
||||
BaseOptions,
|
||||
SernAutocompleteData,
|
||||
SernSubCommandData,
|
||||
SernSubCommandGroupData,
|
||||
} from './module';
|
||||
import type Wrapper from './wrapper';
|
||||
import { ModuleStore } from './moduleStore';
|
||||
|
||||
export * from './enums';
|
||||
export {
|
||||
Context,
|
||||
SlashCommand,
|
||||
TextCommand,
|
||||
BothCommand,
|
||||
Module,
|
||||
Wrapper,
|
||||
SernOptionsData,
|
||||
BaseOptions,
|
||||
SernAutocompleteData,
|
||||
SernSubCommandData,
|
||||
SernSubCommandGroupData,
|
||||
ModuleStore
|
||||
};
|
||||
|
||||
@@ -1,24 +1,15 @@
|
||||
import type { Client } from 'discord.js';
|
||||
import type SernEmitter from '../sernEmitter';
|
||||
import type { EventModule } from './module';
|
||||
import type { Dependencies } from '../../types/handler';
|
||||
|
||||
/**
|
||||
* An object to be passed into Sern#init() function.
|
||||
* @typedef {object} Wrapper
|
||||
*/
|
||||
interface Wrapper {
|
||||
//@deprecated - Use Sern#makeDependencies instead
|
||||
readonly client: Client;
|
||||
//@deprecated - Use Sern#makeDependencies instead
|
||||
readonly sernEmitter?: SernEmitter;
|
||||
readonly defaultPrefix?: string;
|
||||
readonly commands: string;
|
||||
readonly events?:
|
||||
| string
|
||||
//@deprecated - array and function options will be removed
|
||||
| { mod: EventModule; absPath: string }[]
|
||||
//@deprecated - array and function options will be removed
|
||||
| (() => { mod: EventModule; absPath: string }[]);
|
||||
readonly events?: string;
|
||||
readonly containerConfig : {
|
||||
get: (...keys: (keyof Dependencies)[]) => unknown[];
|
||||
}
|
||||
}
|
||||
|
||||
export default Wrapper;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import type { Awaitable } from 'discord.js';
|
||||
|
||||
export async function asyncResolveArray<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
|
||||
export async function arrAsync<T>(promiseLike: Awaitable<T>[]): Promise<T[]> {
|
||||
const arr: T[] = [];
|
||||
for await (const el of promiseLike) {
|
||||
arr.push(el);
|
||||
42
src/handler/utilities/functions.ts
Normal file
42
src/handler/utilities/functions.ts
Normal file
@@ -0,0 +1,42 @@
|
||||
import * as Files from './readFile';
|
||||
import { basename } from 'path';
|
||||
import { Err, Ok, Result } from 'ts-results-es';
|
||||
import { Observable, of, switchMap } from 'rxjs';
|
||||
/**
|
||||
* A function that returns whatever value is provided.
|
||||
* Used for singleton in iti
|
||||
* @param value
|
||||
*/
|
||||
export const _const = <T>(value: T) => () => value;
|
||||
/**
|
||||
* A function that returns another function
|
||||
* Used for transient in iti
|
||||
* @param value
|
||||
*/
|
||||
export const transient = <T>( value : T) => () => _const(value);
|
||||
|
||||
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 ];
|
||||
}
|
||||
|
||||
export function reducePlugins(src: Observable<Result<void, void>[]>) : Observable<boolean> {
|
||||
return src.pipe(switchMap(s => of(s.every((a) => a.ok))));
|
||||
}
|
||||
@@ -1,24 +1,9 @@
|
||||
import type { CommandModuleDefs, EventModule, Module } from '../structures/module';
|
||||
import {
|
||||
AutocompleteInteraction,
|
||||
Interaction,
|
||||
InteractionType,
|
||||
type ModalSubmitInteraction,
|
||||
type ButtonInteraction,
|
||||
type SelectMenuInteraction,
|
||||
type ChatInputCommandInteraction,
|
||||
type UserContextMenuCommandInteraction,
|
||||
type MessageContextMenuCommandInteraction,
|
||||
} from 'discord.js';
|
||||
import type {
|
||||
DiscordEventCommand,
|
||||
ExternalEventCommand,
|
||||
SernEventCommand,
|
||||
} from '../structures/events';
|
||||
import { EventType } from '../..';
|
||||
import type { DiscordEventCommand, ExternalEventCommand, SernEventCommand } from '../structures/events';
|
||||
import { CommandModule, EventType } from '../..';
|
||||
import type { AnyModule, CommandModuleDefs, EventModule } from '../../types/module';
|
||||
|
||||
export function correctModuleType<T extends keyof CommandModuleDefs>(
|
||||
plug: Module | undefined,
|
||||
plug: AnyModule | undefined,
|
||||
type: T,
|
||||
): plug is CommandModuleDefs[T] {
|
||||
// Another way to check if type is equivalent,
|
||||
@@ -26,45 +11,13 @@ export function correctModuleType<T extends keyof CommandModuleDefs>(
|
||||
return plug !== undefined && (plug.type & type) !== 0;
|
||||
}
|
||||
|
||||
export function isApplicationCommand(
|
||||
interaction: Interaction,
|
||||
): interaction is
|
||||
| ChatInputCommandInteraction
|
||||
| UserContextMenuCommandInteraction
|
||||
| MessageContextMenuCommandInteraction {
|
||||
return interaction.type === InteractionType.ApplicationCommand;
|
||||
}
|
||||
|
||||
export function isModalSubmit(interaction: Interaction): interaction is ModalSubmitInteraction {
|
||||
return interaction.type === InteractionType.ModalSubmit;
|
||||
}
|
||||
export function isAutocomplete(interaction: Interaction): interaction is AutocompleteInteraction {
|
||||
return interaction.type === InteractionType.ApplicationCommandAutocomplete;
|
||||
}
|
||||
export function isMessageComponent(
|
||||
interaction: Interaction,
|
||||
): interaction is ButtonInteraction | SelectMenuInteraction {
|
||||
return interaction.type === InteractionType.MessageComponent;
|
||||
}
|
||||
|
||||
export function isDiscordEvent(el: EventModule): el is DiscordEventCommand {
|
||||
export function isDiscordEvent(el: EventModule | CommandModule): el is DiscordEventCommand {
|
||||
return el.type === EventType.Discord;
|
||||
}
|
||||
export function isSernEvent(el: EventModule): el is SernEventCommand {
|
||||
export function isSernEvent(el: EventModule | CommandModule): el is SernEventCommand {
|
||||
return el.type === EventType.Sern;
|
||||
}
|
||||
|
||||
export function isExternalEvent(el: EventModule): el is ExternalEventCommand {
|
||||
export function isExternalEvent(el: EventModule | CommandModule): el is ExternalEventCommand {
|
||||
return el.type === EventType.External && 'emitter' in el;
|
||||
}
|
||||
|
||||
// export function isEventPlugin<T extends CommandType>(
|
||||
// e: CommandModulePlugin<T>,
|
||||
// ): e is EventPlugin<T> {
|
||||
// return e.type === PluginType.Event;
|
||||
// }
|
||||
// export function isCommandPlugin<T extends CommandType>(
|
||||
// e: CommandModulePlugin<T>,
|
||||
// ): e is CommandPlugin<T> {
|
||||
// return !isEventPlugin(e);
|
||||
// }
|
||||
|
||||
@@ -1,34 +1,9 @@
|
||||
import { ApplicationCommandType, ComponentType } from 'discord.js';
|
||||
import { readdirSync, statSync } from 'fs';
|
||||
import { join } from 'path';
|
||||
import { type Observable, from, concatAll } from 'rxjs';
|
||||
import type { CommandModule } from '../structures/module';
|
||||
import { SernError } from '../structures/errors';
|
||||
import { type Result, Err, Ok } from 'ts-results-es';
|
||||
import type { EventEmitter } from 'events';
|
||||
|
||||
//Maybe move this? this probably doesnt belong in utlities/
|
||||
export const BothCommands = new Map<string, CommandModule>();
|
||||
export const ApplicationCommands = {
|
||||
[ApplicationCommandType.User]: new Map<string, CommandModule>(),
|
||||
[ApplicationCommandType.Message]: new Map<string, CommandModule>(),
|
||||
[ApplicationCommandType.ChatInput]: new Map<string, CommandModule>(),
|
||||
} as { [K in ApplicationCommandType]: Map<string, CommandModule> };
|
||||
|
||||
export const MessageCompCommands = {
|
||||
[ComponentType.Button]: new Map<string, CommandModule>(),
|
||||
[ComponentType.SelectMenu]: new Map<string, CommandModule>(),
|
||||
[ComponentType.TextInput]: new Map<string, CommandModule>(),
|
||||
};
|
||||
export const TextCommands = {
|
||||
text: new Map<string, CommandModule>(),
|
||||
aliases: new Map<string, CommandModule>(),
|
||||
};
|
||||
export const ModalSubmitCommands = new Map<string, CommandModule>();
|
||||
/**
|
||||
* keeps all external emitters stored here
|
||||
*/
|
||||
export const ExternalEventEmitters = new Map<string, EventEmitter>();
|
||||
|
||||
// Courtesy @Townsy45
|
||||
function readPath(dir: string, arrayOfFiles: string[] = []): string[] {
|
||||
|
||||
@@ -1,42 +1,42 @@
|
||||
import type { SernAutocompleteData, SernOptionsData } from '../structures/module';
|
||||
import { ApplicationCommandOptionType, AutocompleteInteraction } from 'discord.js';
|
||||
import type { SernAutocompleteData, SernOptionsData } from '../../types/module';
|
||||
|
||||
export default function treeSearch(
|
||||
iAutocomplete: AutocompleteInteraction,
|
||||
options: SernOptionsData[] | undefined,
|
||||
): SernAutocompleteData {
|
||||
): SernAutocompleteData | undefined {
|
||||
if (options === undefined) return undefined;
|
||||
const _options = options.slice(); // required to prevent direct mutation of options
|
||||
let autocompleteData: SernAutocompleteData;
|
||||
let autocompleteData: SernAutocompleteData | undefined;
|
||||
|
||||
while (_options.length > 0) {
|
||||
const cur = _options.pop()!;
|
||||
switch (cur.type) {
|
||||
case ApplicationCommandOptionType.Subcommand:
|
||||
{
|
||||
for (const option of cur.options ?? []) {
|
||||
_options.push(option);
|
||||
}
|
||||
{
|
||||
for (const option of cur.options ?? []) {
|
||||
_options.push(option);
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ApplicationCommandOptionType.SubcommandGroup:
|
||||
{
|
||||
for (const command of cur.options ?? []) {
|
||||
_options.push(command);
|
||||
}
|
||||
{
|
||||
for (const command of cur.options ?? []) {
|
||||
_options.push(command);
|
||||
}
|
||||
}
|
||||
break;
|
||||
default:
|
||||
{
|
||||
if (cur.autocomplete) {
|
||||
const choice = iAutocomplete.options.getFocused(true);
|
||||
if (cur.name === choice.name && cur.autocomplete) {
|
||||
autocompleteData = cur;
|
||||
}
|
||||
{
|
||||
if (cur.autocomplete) {
|
||||
const choice = iAutocomplete.options.getFocused(true);
|
||||
if (cur.name === choice.name && cur.autocomplete) {
|
||||
autocompleteData = cur;
|
||||
}
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
return autocompleteData;
|
||||
}
|
||||
}
|
||||
@@ -2,6 +2,10 @@ import SernEmitter from './handler/sernEmitter';
|
||||
export { eventModule, commandModule, EventExecutable, CommandExecutable } from './handler/sern';
|
||||
export * as Sern from './handler/sern';
|
||||
export * from './types/handler';
|
||||
export * from './types/module';
|
||||
export * from './handler/structures/structxports';
|
||||
export * from './handler/plugins/plugin';
|
||||
export * from './handler/contracts/index';
|
||||
export { SernEmitter };
|
||||
export { _const as single, transient as many } from './handler/utilities/functions';
|
||||
export { useContainerRaw } from './handler/dependencies/provider';
|
||||
@@ -1,9 +1,12 @@
|
||||
import type { CommandInteractionOptionResolver } from 'discord.js';
|
||||
import type { CommandModule, EventModule, Module } from '../handler/structures/module';
|
||||
import type { PayloadType } from '../handler/structures/enums';
|
||||
import type { InteractionReplyOptions, MessageReplyOptions } from 'discord.js';
|
||||
export type Nullish<T> = T | undefined | null;
|
||||
|
||||
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';
|
||||
// Thanks to @kelsny
|
||||
export type ParseType<T> = {
|
||||
[K in keyof T]: T[K] extends unknown ? [k: K, args: T[K]] : never;
|
||||
@@ -13,46 +16,42 @@ export type Args = ParseType<{ text: string[]; slash: SlashOptions }>;
|
||||
|
||||
export type SlashOptions = Omit<CommandInteractionOptionResolver, 'getMessage' | 'getFocused'>;
|
||||
|
||||
// Source: https://dev.to/vborodulin/ts-how-to-override-properties-with-type-intersection-554l
|
||||
export type Override<T1, T2> = Omit<T1, keyof T2> & T2;
|
||||
|
||||
export type DefinitelyDefined<T, K extends keyof T = keyof T> = {
|
||||
[L in K]-?: T[L] extends Record<string, unknown>
|
||||
? DefinitelyDefined<T[L], keyof T[L]>
|
||||
: Required<T>[L];
|
||||
} & T;
|
||||
|
||||
export type EventInput =
|
||||
| string
|
||||
| { mod: EventModule; absPath: string }[]
|
||||
| (() => { mod: EventModule; absPath: string }[]);
|
||||
|
||||
/**
|
||||
* Turns a function with a union of array of args into a single union
|
||||
* [ T , V , B ] | [ A ] => T | V | B | A
|
||||
*/
|
||||
export type SpreadParams<T extends (...args: never) => unknown> = (
|
||||
args: Parameters<T>[number],
|
||||
) => unknown;
|
||||
|
||||
/**
|
||||
* After modules are transformed, name and description are given default values if none
|
||||
* are provided to Module. This type represents that transformation
|
||||
*/
|
||||
export type DefinedModule = DefinitelyDefined<Module, 'name' | 'description'>;
|
||||
export type DefinedCommandModule = DefinitelyDefined<CommandModule, 'name' | 'description'>;
|
||||
export type DefinedEventModule = DefinitelyDefined<EventModule, 'name' | 'description'>;
|
||||
export type DefinedCommandModule = CommandModule & { name: string; description: string };
|
||||
export type DefinedEventModule = EventModule & { name: string };
|
||||
export type AnyDefinedModule = DefinedCommandModule | DefinedEventModule
|
||||
export type Payload =
|
||||
| { type: PayloadType.Success; module: Module }
|
||||
| { type: PayloadType.Failure; module?: Module; reason: string | Error };
|
||||
| { 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']: [string];
|
||||
'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 type ReplyOptions =
|
||||
| string
|
||||
| Omit<InteractionReplyOptions, 'fetchReply'>
|
||||
| MessageReplyOptions;
|
||||
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;
|
||||
|
||||
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';
|
||||
215
src/types/module.ts
Normal file
215
src/types/module.ts
Normal file
@@ -0,0 +1,215 @@
|
||||
import type {
|
||||
ApplicationCommandAttachmentOption,
|
||||
ApplicationCommandChannelOptionData,
|
||||
ApplicationCommandChoicesData,
|
||||
ApplicationCommandNonOptionsData,
|
||||
ApplicationCommandNumericOptionData,
|
||||
ApplicationCommandOptionData,
|
||||
ApplicationCommandOptionType,
|
||||
ApplicationCommandSubCommandData,
|
||||
ApplicationCommandSubGroupData,
|
||||
AutocompleteInteraction,
|
||||
Awaitable,
|
||||
BaseApplicationCommandOptionsData,
|
||||
ButtonInteraction,
|
||||
MessageContextMenuCommandInteraction,
|
||||
ModalSubmitInteraction,
|
||||
UserContextMenuCommandInteraction,
|
||||
ChannelSelectMenuInteraction,
|
||||
MentionableSelectMenuInteraction,
|
||||
RoleSelectMenuInteraction,
|
||||
StringSelectMenuInteraction
|
||||
} from 'discord.js';
|
||||
import type {
|
||||
DiscordEventCommand,
|
||||
ExternalEventCommand,
|
||||
SernEventCommand,
|
||||
} from '../handler/structures/events';
|
||||
import { CommandType } from '../handler/structures/enums';
|
||||
import type { Args, SlashOptions } from './handler';
|
||||
import type Context from '../handler/structures/context';
|
||||
import type { AutocompletePlugin, CommandPlugin, EventPlugin } from '../handler/plugins/plugin';
|
||||
import { EventType } from '../handler/structures/enums';
|
||||
import type { UserSelectMenuInteraction } from 'discord.js';
|
||||
|
||||
export interface Module {
|
||||
type?: CommandType | EventType;
|
||||
name?: string;
|
||||
description?: string;
|
||||
execute: (...args: any[]) => any
|
||||
}
|
||||
|
||||
export interface TextCommand extends Module {
|
||||
type: CommandType.Text;
|
||||
onEvent: EventPlugin<CommandType.Text>[];
|
||||
plugins: CommandPlugin[];
|
||||
alias?: string[];
|
||||
execute: (ctx: Context, args: ['text', string[]]) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface SlashCommand extends Module {
|
||||
type: CommandType.Slash;
|
||||
onEvent: EventPlugin<CommandType.Slash>[];
|
||||
plugins: CommandPlugin[];
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: ['slash', SlashOptions]) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface BothCommand extends Module {
|
||||
type: CommandType.Both;
|
||||
onEvent: EventPlugin<CommandType.Both>[];
|
||||
plugins: CommandPlugin[];
|
||||
alias?: string[];
|
||||
options?: SernOptionsData[];
|
||||
execute: (ctx: Context, args: Args) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ContextMenuUser extends Module {
|
||||
type: CommandType.CtxUser;
|
||||
onEvent: EventPlugin<CommandType.CtxUser>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: UserContextMenuCommandInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ContextMenuMsg extends Module {
|
||||
type: CommandType.CtxMsg;
|
||||
onEvent: EventPlugin<CommandType.CtxMsg>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: MessageContextMenuCommandInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ButtonCommand extends Module {
|
||||
type: CommandType.Button;
|
||||
onEvent: EventPlugin<CommandType.Button>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: ButtonInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface StringSelectCommand extends Module {
|
||||
type: CommandType.StringSelect;
|
||||
onEvent: EventPlugin<CommandType.StringSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: StringSelectMenuInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ChannelSelectCommand extends Module {
|
||||
type: CommandType.ChannelSelect;
|
||||
onEvent: EventPlugin<CommandType.ChannelSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: ChannelSelectMenuInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface RoleSelectCommand extends Module {
|
||||
type: CommandType.RoleSelect;
|
||||
onEvent: EventPlugin<CommandType.RoleSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: RoleSelectMenuInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface MentionableSelectCommand extends Module {
|
||||
type: CommandType.MentionableSelect;
|
||||
onEvent: EventPlugin<CommandType.MentionableSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: MentionableSelectMenuInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface UserSelectCommand extends Module {
|
||||
type: CommandType.UserSelect;
|
||||
onEvent: EventPlugin<CommandType.UserSelect>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: UserSelectMenuInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface ModalSubmitCommand extends Module {
|
||||
type: CommandType.Modal;
|
||||
onEvent: EventPlugin<CommandType.Modal>[];
|
||||
plugins: CommandPlugin[];
|
||||
execute: (ctx: ModalSubmitInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export interface AutocompleteCommand extends Module {
|
||||
name?: never;
|
||||
description?: never;
|
||||
type?: never;
|
||||
onEvent: AutocompletePlugin[];
|
||||
execute: (ctx: AutocompleteInteraction) => Awaitable<unknown>;
|
||||
}
|
||||
|
||||
export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
|
||||
export type CommandModule =
|
||||
| TextCommand
|
||||
| SlashCommand
|
||||
| BothCommand
|
||||
| ContextMenuUser
|
||||
| ContextMenuMsg
|
||||
| ButtonCommand
|
||||
| StringSelectCommand
|
||||
| MentionableSelectCommand
|
||||
| UserSelectCommand
|
||||
| ChannelSelectCommand
|
||||
| RoleSelectCommand
|
||||
| ModalSubmitCommand;
|
||||
|
||||
export type AnyModule = CommandModule | EventModule;
|
||||
|
||||
//https://stackoverflow.com/questions/64092736/alternative-to-switch-statement-for-typescript-discriminated-union
|
||||
// Explicit Module Definitions for mapping
|
||||
export type CommandModuleDefs = {
|
||||
[CommandType.Text]: TextCommand;
|
||||
[CommandType.Slash]: SlashCommand;
|
||||
[CommandType.Both]: BothCommand;
|
||||
[CommandType.CtxMsg]: ContextMenuMsg;
|
||||
[CommandType.CtxUser]: ContextMenuUser;
|
||||
[CommandType.Button]: ButtonCommand;
|
||||
[CommandType.StringSelect]: StringSelectCommand;
|
||||
[CommandType.RoleSelect] : RoleSelectCommand;
|
||||
[CommandType.ChannelSelect] : ChannelSelectCommand;
|
||||
[CommandType.MentionableSelect] : MentionableSelectCommand;
|
||||
[CommandType.UserSelect] : UserSelectCommand;
|
||||
[CommandType.Modal]: ModalSubmitCommand;
|
||||
};
|
||||
|
||||
export type EventModuleDefs = {
|
||||
[EventType.Sern]: SernEventCommand;
|
||||
[EventType.Discord]: DiscordEventCommand;
|
||||
[EventType.External]: ExternalEventCommand;
|
||||
};
|
||||
|
||||
export interface SernAutocompleteData extends Omit<BaseApplicationCommandOptionsData, 'autocomplete'> {
|
||||
autocomplete: true;
|
||||
type:
|
||||
| ApplicationCommandOptionType.String
|
||||
| ApplicationCommandOptionType.Number
|
||||
| ApplicationCommandOptionType.Integer;
|
||||
command: AutocompleteCommand;
|
||||
}
|
||||
|
||||
/**
|
||||
* Type that replaces autocomplete with {@link SernAutocompleteData}
|
||||
*/
|
||||
export type BaseOptions =
|
||||
| ApplicationCommandChoicesData
|
||||
| ApplicationCommandNonOptionsData
|
||||
| ApplicationCommandChannelOptionData
|
||||
| ApplicationCommandNumericOptionData
|
||||
| ApplicationCommandAttachmentOption
|
||||
| SernAutocompleteData;
|
||||
|
||||
export interface SernSubCommandData extends BaseApplicationCommandOptionsData {
|
||||
type: ApplicationCommandOptionType.Subcommand;
|
||||
required?: never;
|
||||
options?: BaseOptions[];
|
||||
}
|
||||
|
||||
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;
|
||||
0
test/cjs/src/index.ts
Normal file
0
test/cjs/src/index.ts
Normal file
20
test/cjs/tsconfig.json
Normal file
20
test/cjs/tsconfig.json
Normal file
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "esnext",
|
||||
"module": "commonjs",
|
||||
"outDir": "dist",
|
||||
"rootDir": "src",
|
||||
"strict": true,
|
||||
"esModuleInterop": true,
|
||||
"noImplicitAny": true,
|
||||
"strictNullChecks": true,
|
||||
"importsNotUsedAsValues": "error",
|
||||
"baseUrl": ".",
|
||||
"resolveJsonModule": true,
|
||||
"moduleResolution": "node",
|
||||
"skipLibCheck": true,
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"forceConsistentCasingInFileNames": true
|
||||
},
|
||||
"include": ["src/secrets.json", "src"]
|
||||
}
|
||||
0
test/esm/src/index.ts
Normal file
0
test/esm/src/index.ts
Normal file
20
test/esm/tsconfig.json
Normal file
20
test/esm/tsconfig.json
Normal file
@@ -0,0 +1,20 @@
|
||||
{
|
||||
"compilerOptions": {
|
||||
"target": "esnext",
|
||||
"module": "esnext",
|
||||
"outDir": "dist",
|
||||
"rootDir": "src",
|
||||
"strict": true,
|
||||
"esModuleInterop": true,
|
||||
"noImplicitAny": true,
|
||||
"strictNullChecks": true,
|
||||
"importsNotUsedAsValues": "error",
|
||||
"baseUrl": ".",
|
||||
"resolveJsonModule": true,
|
||||
"moduleResolution": "node",
|
||||
"skipLibCheck": true,
|
||||
"allowSyntheticDefaultImports": true,
|
||||
"forceConsistentCasingInFileNames": true
|
||||
},
|
||||
"include": ["src/secrets.json", "src"]
|
||||
}
|
||||
@@ -4,6 +4,7 @@
|
||||
"strict": true,
|
||||
"esModuleInterop": true,
|
||||
"noImplicitAny": true,
|
||||
"experimentalDecorators": true,
|
||||
"strictNullChecks": true,
|
||||
"importsNotUsedAsValues": "error",
|
||||
"moduleResolution": "node",
|
||||
|
||||
@@ -1,38 +1,38 @@
|
||||
import { defineConfig } from 'tsup';
|
||||
|
||||
const shared = {
|
||||
entry: ['src/index.ts'],
|
||||
external: ['discord.js'],
|
||||
platform: 'node',
|
||||
clean: true,
|
||||
sourcemap: false
|
||||
};
|
||||
export default defineConfig([
|
||||
{
|
||||
entry: ['src/index.ts'],
|
||||
format: 'esm',
|
||||
sourcemap: false,
|
||||
target: 'node16',
|
||||
tsconfig: './tsconfig-esm.json',
|
||||
outDir: './dist/esm',
|
||||
platform: 'node',
|
||||
external: ['discord.js'],
|
||||
clean: true,
|
||||
treeshake: true,
|
||||
outExtension() {
|
||||
return {
|
||||
js: '.mjs',
|
||||
};
|
||||
},
|
||||
...shared
|
||||
},
|
||||
{
|
||||
entry: ['src/index.ts'],
|
||||
format: 'cjs',
|
||||
splitting: false,
|
||||
sourcemap: false,
|
||||
external: ['discord.js'],
|
||||
clean: true,
|
||||
target: 'node16',
|
||||
tsconfig: './tsconfig-cjs.json',
|
||||
outDir: './dist/cjs',
|
||||
platform: 'node',
|
||||
outExtension() {
|
||||
return {
|
||||
js: '.cjs',
|
||||
};
|
||||
},
|
||||
...shared
|
||||
},
|
||||
]);
|
||||
|
||||
Reference in New Issue
Block a user