sern/handler
1
0
Fork 0
mirror of https://github.com/sern-handler/handler synced 2026-06-06 01:16:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix: rm deprecated class modules, clean up, rm indirection (#355)

Browse Source 
* refactor: rm deprecations, clean up, rm indirection

* fix: singleton init not being fired when inserting function

* refactor and generic internal add

* deprecate a few things that i impusively added lol
This commit is contained in:
Jacob Nguyen
2024-02-17 11:35:53 -06:00
committed by GitHub
parent 45cbda7b42
commit 48f9f6ec16
17 changed files with 137 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/_internal.ts
View File

@@ -5,6 +5,6 @@ export * from './functions';
export type { VoidResult } from '../types/core-plugin';
export { SernError } from './structures/enums';
export { ModuleStore } from './structures/module-store';
export * as DefaultServices from './structures/services';
export { useContainerRaw } from './ioc/base'
export * as __Services from './structures/services';
export { useContainerRaw } from './ioc/base';

15
src/core/contracts/module-manager.ts
View File

@@ -16,12 +16,19 @@ interface MetadataAccess {
* @internal - direct access to the module manager will be removed in version 4
*/
export interface ModuleManager extends MetadataAccess {
get(id: string): string | undefined;
get(id: string): Module | undefined;
set(id: string, path: string): void;
getPublishableCommands(): Promise<CommandModule[]>;
set(id: string, path: Module): void;
/**
* @deprecated
*/
getPublishableCommands(): CommandModule[];
/*
* @deprecated
*/
getByNameCommandType<T extends CommandType>(
name: string,
commandType: T,
): Promise<CommandModuleDefs[T]> | undefined;
): CommandModuleDefs[T] | undefined;
}

2
src/core/contracts/module-store.ts
View File

@@ -4,6 +4,6 @@ import type { CommandMeta, Module } from '../../types/core-modules';
* Represents a core module store that stores IDs mapped to file paths.
*/
export interface CoreModuleStore {
commands: Map<string, string>;
commands: Map<string, Module>;
metadata: WeakMap<Module, CommandMeta>;
}

6
src/core/functions.ts
View File

@@ -10,10 +10,10 @@ import type {
UserContextMenuCommandInteraction,
AutocompleteInteraction
} from 'discord.js';
import { ApplicationCommandOptionType, InteractionType } from 'discord.js'
import { ApplicationCommandOptionType, InteractionType } from 'discord.js';
import { PayloadType, PluginType } from './structures';
import assert from 'assert';
import { Payload } from '../types/utility';
import type { Payload } from '../types/utility';
//function wrappers for empty ok / err
export const ok = /* @__PURE__*/ () => Ok.EMPTY;
@@ -50,7 +50,7 @@ export function treeSearch(
if (options === undefined) return undefined;
//clone to prevent mutation of original command module
const _options = options.map(a => ({ ...a }));
let subcommands = new Set();
const subcommands = new Set();
while (_options.length > 0) {
const cur = _options.pop()!;
switch (cur.type) {

13
src/core/id.ts
View File

@@ -42,19 +42,10 @@ const TypeMap = new Map<number, number>([
[CommandType.RoleSelect, ComponentType.RoleSelect],
[CommandType.ChannelSelect, ComponentType.ChannelSelect]]);
/*
* Generates a number based on CommandType.
* This corresponds to an ApplicationCommandType or ComponentType
* TextCommands are 0 as they aren't either or.
*/
function apiType(t: CommandType | EventType) {
return TypeMap.get(t)!;
}
/*
* Generates an id based on name and CommandType.
* A is for any ApplicationCommand. C is for any ComponentCommand
* Then, another number generated by apiType function is appended
* Then, another number fetched from TypeMap
*/
export function create(name: string, type: CommandType | EventType) {
if(type == CommandType.Text) {
@@ -67,7 +58,7 @@ export function create(name: string, type: CommandType | EventType) {
return `${name}_M`;
}
const am = (appBitField & type) !== 0 ? 'A' : 'C';
return `${name}_${am}${apiType(type)}`
return `${name}_${am}${TypeMap.get(type)!}`
}

62
src/core/ioc/base.ts
View File

@@ -11,7 +11,27 @@ import type { Logging } from '../contracts/logging';
let containerSubject: CoreContainer<Partial<Dependencies>>;
/**
* @deprecated
* @internal
* Don't use this unless you know what you're doing. Destroys old containerSubject if it exists and disposes everything
* then it will swap
*/
export async function __swap_container(c: CoreContainer<Partial<Dependencies>>) {
if(containerSubject) {
await containerSubject.disposeAll()
}
containerSubject = c;
}
/**
* @internal
* Don't use this unless you know what you're doing. Destroys old containerSubject if it exists and disposes everything
* then it will swap
*/
export function __add_container(key: string,v : Insertable) {
containerSubject.add({ [key]: v });
}
/**
* Returns the underlying data structure holding all dependencies.
* Exposes methods from iti
* Use the Service API. The container should be readonly
@@ -29,19 +49,24 @@ export function disposeAll(logger: Logging|undefined) {
?.disposeAll()
.then(() => logger?.info({ message: 'Cleaning container and crashing' }));
}
const dependencyBuilder = (container: any, excluded: string[] ) => {
type Insertable =
| ((container: CoreContainer<Dependencies>) => unknown )
type Insertable =
| ((container: CoreContainer<Dependencies>) => unknown)
| object
const dependencyBuilder = (container: any, excluded: string[] ) => {
return {
/**
* Insert a dependency into your container.
* Supply the correct key and dependency
*/
add(key: keyof Dependencies, v: Insertable) {
Result.wrap(() => container.add({ [key]: v}))
.expect("Failed to add " + key);
if(typeof v !== 'function') {
Result.wrap(() => container.add({ [key]: v}))
.expect("Failed to add " + key);
} else {
Result.wrap(() =>
container.add((cntr: CoreContainer<Dependencies>) => ({ [key]: v(cntr)} )))
.expect("Failed to add " + key);
}
},
/**
* Exclude any dependencies from being added.
@@ -57,8 +82,14 @@ const dependencyBuilder = (container: any, excluded: string[] ) => {
* Swap out a preexisting dependency.
*/
swap(key: keyof Dependencies, v: Insertable) {
Result.wrap(() => container.upsert({ [key]: v }))
.expect("Failed to update " + key);
if(typeof v !== 'function') {
Result.wrap(() => container.upsert({ [key]: v}))
.expect("Failed to update " + key);
} else {
Result.wrap(() =>
container.upsert((cntr: CoreContainer<Dependencies>) => ({ [key]: v(cntr)})))
.expect("Failed to update " + key);
}
},
/**
* @param key the key of the dependency
@@ -82,11 +113,6 @@ type ValidDependencyConfig =
| CallbackBuilder
| DependencyConfiguration;
export const insertLogger = (containerSubject: CoreContainer<any>) => {
containerSubject
.upsert({'@sern/logger': () => new DefaultServices.DefaultLogging});
}
/**
* Given the user's conf, check for any excluded/included dependency keys.
@@ -101,7 +127,7 @@ function composeRoot(
//container should have no client or logger yet.
const hasLogger = conf.exclude?.has('@sern/logger');
if (!hasLogger) {
insertLogger(container);
__add_container('@sern/logger', new DefaultServices.DefaultLogging);
}
//Build the container based on the callback provided by the user
conf.build(container as CoreContainer<Omit<CoreDependencies, '@sern/client'>>);
@@ -119,13 +145,13 @@ export async function makeDependencies<const T extends Dependencies>
if(typeof conf === 'function') {
const excluded: string[] = [];
conf(dependencyBuilder(containerSubject, excluded));
//We only include logger if it does not exist
const includeLogger =
!excluded.includes('@sern/logger')
&& !containerSubject.getTokens()['@sern/logger'];
&& !containerSubject.hasKey('@sern/logger');
if(includeLogger) {
insertLogger(containerSubject);
__add_container('@sern/logger', new DefaultServices.DefaultLogging);
}
containerSubject.ready();

9
src/core/ioc/container.ts
View File

@@ -2,7 +2,7 @@ import { Container } from 'iti';
import { Disposable } from '../';
import * as assert from 'node:assert';
import { Subject } from 'rxjs';
import { DefaultServices, ModuleStore } from '../_internal';
import { __Services, ModuleStore } from '../_internal';
import * as Hooks from './hooks';
import { EventEmitter } from 'node:events';
@@ -23,12 +23,11 @@ export class CoreContainer<T extends Partial<Dependencies>> extends Container<T,
.subscribe({ complete: unsubscribe });
(this as Container<{}, {}>)
.add({ '@sern/errors': () => new DefaultServices.DefaultErrorHandling,
.add({ '@sern/errors': () => new __Services.DefaultErrorHandling,
'@sern/emitter': () => new EventEmitter({ captureRejections: true }),
'@sern/store': () => new ModuleStore })
.add(ctx => {
return { '@sern/modules': () =>
new DefaultServices.DefaultModuleManager(ctx['@sern/store']) };
return { '@sern/modules': new __Services.DefaultModuleManager(ctx['@sern/store'])};
});
}
@@ -52,8 +51,6 @@ export class CoreContainer<T extends Partial<Dependencies>> extends Container<T,
await super.disposeAll();
}
ready() {
this.ready$.complete();
this.ready$.unsubscribe();

58
src/core/modules.ts
View File

@@ -1,19 +1,13 @@
import { ClientEvents } from 'discord.js';
import { CommandType, EventType, PluginType } from '../core/structures';
import { EventType } from '../core/structures';
import type {
AnyCommandPlugin,
AnyEventPlugin,
CommandArgs,
ControlPlugin,
EventArgs,
InitPlugin,
} from '../types/core-plugin';
import type {
CommandModule,
EventModule,
InputCommand,
InputEvent,
Module,
} from '../types/core-modules';
import { partitionPlugins } from './_internal';
import type { Awaitable } from '../types/utility';
@@ -61,53 +55,3 @@ export function discordEvent<T extends keyof ClientEvents>(mod: {
});
}
/**
* @deprecated
*/
function prepareClassPlugins(c: Module) {
const [onEvent, initPlugins] = partitionPlugins(c.plugins);
c.plugins = initPlugins as InitPlugin[];
c.onEvent = onEvent as ControlPlugin[];
}
/**
* @deprecated
* Will be removed in future
*/
export abstract class CommandExecutable<const Type extends CommandType = CommandType> {
abstract type: Type;
plugins: AnyCommandPlugin[] = [];
private static _instance: CommandModule;
static getInstance() {
if (!CommandExecutable._instance) {
//@ts-ignore
CommandExecutable._instance = new this();
prepareClassPlugins(CommandExecutable._instance);
}
return CommandExecutable._instance;
}
abstract execute(...args: CommandArgs<Type, PluginType.Control>): Awaitable<unknown>;
}
/**
* @deprecated
* Will be removed in future
*/
export abstract class EventExecutable<Type extends EventType> {
abstract type: Type;
plugins: AnyEventPlugin[] = [];
private static _instance: EventModule;
static getInstance() {
if (!EventExecutable._instance) {
//@ts-ignore
EventExecutable._instance = new this();
prepareClassPlugins(EventExecutable._instance);
}
return EventExecutable._instance;
}
abstract execute(...args: EventArgs<Type, PluginType.Control>): Awaitable<unknown>;
}

2
src/core/structures/module-store.ts
View File

@@ -7,5 +7,5 @@ import { CommandMeta, Module } from '../../types/core-modules';
*/
export class ModuleStore {
metadata = new WeakMap<Module, CommandMeta>();
commands = new Map<string, string>();
commands = new Map<string, Module>();
}

17
src/core/structures/services/module-manager.ts
View File

@@ -1,6 +1,5 @@
import * as Id from '../../../core/id';
import { CoreModuleStore, ModuleManager } from '../../contracts';
import { Files } from '../../_internal';
import { CommandMeta, CommandModule, CommandModuleDefs, Module } from '../../../types/core-modules';
import { CommandType } from '../enums';
/**
@@ -13,11 +12,11 @@ export class DefaultModuleManager implements ModuleManager {
getByNameCommandType<T extends CommandType>(name: string, commandType: T) {
const id = this.get(Id.create(name, commandType));
if (!id) {
const module = this.get(Id.create(name, commandType));
if (!module) {
return undefined;
}
return Files.importModule<CommandModuleDefs[T]>(id);
return module as CommandModuleDefs[T];
}
setMetadata(m: Module, c: CommandMeta): void {
@@ -35,20 +34,18 @@ export class DefaultModuleManager implements ModuleManager {
get(id: string) {
return this.moduleStore.commands.get(id);
}
set(id: string, path: string): void {
set(id: string, path: CommandModule): void {
this.moduleStore.commands.set(id, path);
}
//not tested
getPublishableCommands(): Promise<CommandModule[]> {
getPublishableCommands(): CommandModule[] {
const entries = this.moduleStore.commands.entries();
const publishable = 0b000000110;
return Promise.all(
Array.from(entries)
return Array.from(entries)
.filter(([id]) => {
const last_entry = id.at(-1);
return last_entry == 'B' || !(publishable & Number.parseInt(last_entry!));
})
.map(([, path]) => Files.importModule<CommandModule>(path)),
);
.map(([, path]) => path as CommandModule);
}
}

10
src/handlers/dispatchers.ts
View File

@@ -17,10 +17,7 @@ import type { CommandModule, Module, Processed } from '../types/core-modules';
//TODO: refactor dispatchers so that it implements a strategy for each different type of payload?
export function dispatchMessage(module: Processed<CommandModule>, args: [Context, Args]) {
return {
module,
args,
};
return { module, args };
}
export function contextArgs(wrappable: Message | BaseInteraction, messageArgs?: string[]) {
@@ -87,9 +84,6 @@ export function createDispatcher(payload: {
}
return { module: payload.module, args: contextArgs(payload.event) };
}
default: return {
module: payload.module,
args: [payload.event],
};
default: return { module: payload.module, args: [payload.event] };
}
}

58
src/handlers/event-utils.ts
View File

@@ -8,9 +8,9 @@ import {
of,
throwError,
tap,
MonoTypeOperatorFunction,
catchError,
finalize,
map,
} from 'rxjs';
import {
Files,
@@ -29,8 +29,7 @@ import { ObservableInput, pipe } from 'rxjs';
import { Err, Ok, Result } from 'ts-results-es';
import type { Awaitable } from '../types/utility';
import type { ControlPlugin } from '../types/core-plugin';
import type { AnyModule, CommandModule, Module, Processed } from '../types/core-modules';
import type { ImportPayload } from '../types/core';
import type { AnyModule, CommandMeta, CommandModule, Module, Processed } from '../types/core-modules';
import { disposeAll } from '../core/ioc/base';
function createGenericHandler<Source, Narrowed extends Source, Output>(
@@ -74,18 +73,13 @@ export function createInteractionHandler<T extends Interaction>(
const possibleIds = Id.reconstruct(event);
let fullPaths= possibleIds
.map(id => mg.get(id))
.filter((id): id is string => id !== undefined);
.filter((id): id is Module => id !== undefined);
if(fullPaths.length == 0) {
return Err.EMPTY;
}
const [ path ] = fullPaths;
return Files
.defaultModuleLoader<Processed<CommandModule>>(path)
.then(payload => Ok(createDispatcher({
module: payload.module,
event,
})));
return Ok(createDispatcher({ module: path as Processed<CommandModule>, event }));
});
}
@@ -103,39 +97,37 @@ export function createMessageHandler(
return Err('Possibly undefined behavior: could not find a static id to resolve');
}
}
return Files
.defaultModuleLoader<Processed<CommandModule>>(fullPath)
.then(payload => {
const args = contextArgs(event, rest);
return Ok({ args, ...payload });
});
return Ok({ args: contextArgs(event, rest), module: fullPath as Processed<CommandModule> })
});
}
/**
* IMPURE SIDE EFFECT
* This function assigns remaining, incomplete data to each imported module.
*/
function assignDefaults<T extends Module>(
moduleManager: ModuleManager,
): MonoTypeOperatorFunction<ImportPayload<T>> {
return tap(({ module, absPath }) => {
module.name ??= Files.filename(absPath);
module.description ??= '...';
moduleManager.setMetadata(module, {
isClass: module.constructor.name === 'Function',
fullPath: absPath,
id: Id.create(module.name, module.type),
});
function assignDefaults() {
return map(({ module, absPath }) => {
const processed = {
name: module.name ?? Files.filename(absPath),
description: module.description ?? '...',
...module
}
return {
module: processed,
absPath,
metadata: {
isClass: module.constructor.name === 'Function',
fullPath: absPath,
id: Id.create(processed.name, module.type),
}
}
});
}
export function buildModules<T extends AnyModule>(
input: ObservableInput<string>,
moduleManager: ModuleManager,
) {
return Files
.buildModuleStream<Processed<T>>(input)
.pipe(assignDefaults(moduleManager));
.pipe(assignDefaults());
}
@@ -219,9 +211,9 @@ export function callInitPlugins<T extends Processed<AnyModule>>(sernEmitter: Emi
onStop: (module: T) => {
sernEmitter.emit('module.register', resultPayload(PayloadType.Failure, module, SernError.PluginFailure));
},
onNext: ({ module }) => {
sernEmitter.emit('module.register', resultPayload(PayloadType.Success, module));
return { module };
onNext: (payload) => {
sernEmitter.emit('module.register', resultPayload(PayloadType.Success, payload.module));
return payload as { module: T; metadata: CommandMeta };
},
}),
);

34
src/handlers/ready-event.ts
View File

@@ -1,29 +1,31 @@
import { ObservableInput, concat, first, fromEvent, ignoreElements, pipe } from 'rxjs';
import { ObservableInput, concat, first, fromEvent, ignoreElements, pipe, tap } from 'rxjs';
import { CommandType } from '../core/structures';
import { SernError } from '../core/_internal';
import { Result } from 'ts-results-es';
import { ModuleManager } from '../core/contracts';
import { Logging, ModuleManager } from '../core/contracts';
import { buildModules, callInitPlugins } from './_internal';
import * as assert from 'node:assert';
import * as util from 'node:util';
import type { DependencyList } from '../types/ioc';
import type { AnyModule, Processed } from '../types/core-modules';
import type { AnyModule, CommandMeta, Processed } from '../types/core-modules';
export function readyHandler(
[sEmitter, , , moduleManager, client]: DependencyList,
[sEmitter, , log , moduleManager, client]: DependencyList,
allPaths: ObservableInput<string>,
) {
const ready$ = fromEvent(client!, 'ready').pipe(once());
return concat(ready$, buildModules<AnyModule>(allPaths, moduleManager))
//Todo: add module manager on on ready
const ready$ = fromEvent(client!, 'ready').pipe(once(log));
return concat(ready$, buildModules<AnyModule>(allPaths))
.pipe(callInitPlugins(sEmitter))
.subscribe(({ module }) => {
register(moduleManager, module)
.subscribe(({ module, metadata }) => {
register(moduleManager, module, metadata)
.expect(SernError.InvalidModuleType + ' ' + util.inspect(module));
});
}
const once = () => pipe(
const once = (log: Logging | undefined) => pipe(
tap(() => { log?.info({ message: "Waiting on discord client to be ready..." }) }),
first(),
ignoreElements())
@@ -31,20 +33,22 @@ const once = () => pipe(
function register<T extends Processed<AnyModule>>(
manager: ModuleManager,
module: T,
metadata:CommandMeta
): Result<void, void> {
const { id, fullPath } = manager.getMetadata(module)!;
manager.setMetadata(module, metadata)!;
const validModuleType = module.type >= 0 && module.type <= 1 << 10;
assert.ok(
validModuleType,
`Found ${module.name} at ${fullPath}, which does not have a valid type`,
//@ts-ignore
`Found ${module.name} at ${metadata.fullPath}, which does not have a valid type`,
);
if (module.type === CommandType.Both) {
module.alias?.forEach(a => manager.set(`${a}_B`, fullPath));
module.alias?.forEach(a => manager.set(`${a}_B`, module));
} else {
if(module.type === CommandType.Text){
module.alias?.forEach(a => manager.set(`${a}_T`, fullPath));
module.alias?.forEach(a => manager.set(`${a}_T`, module));
}
}
return Result.wrap(() => manager.set(id, fullPath));
return Result.wrap(() => manager.set(metadata.id, module));
}

2
src/handlers/user-defined-events.ts
View File

@@ -23,7 +23,7 @@ export function eventsHandler(
throw Error(SernError.InvalidModuleType + ' while creating event handler');
}
};
buildModules<EventModule>(allPaths, moduleManager)
buildModules<EventModule>(allPaths)
.pipe(
callInitPlugins(emitter),
map(intoDispatcher),

6
src/index.ts
View File

@@ -46,12 +46,8 @@ export {
commandModule,
eventModule,
discordEvent,
EventExecutable,
CommandExecutable,
} from './core/modules';
export * as Presence from './core/presences'
export {
useContainerRaw
} from './core/_internal'

3
src/sern.ts
View File

@@ -43,9 +43,10 @@ export function init(maybeWrapper: Wrapper | 'file') {
//Ready event: load all modules and when finished, time should be taken and logged
readyHandler(dependencies, Files.getFullPathTree(wrapper.commands))
.add(() => {
logger?.info({ message: "Client signaled ready, registering modules" });
const time = ((performance.now() - startTime) / 1000).toFixed(2);
dependencies[0].emit('modulesLoaded');
logger?.info({ message: `sern: registered all modules in ${time} s`, });
logger?.info({ message: `sern: registered in ${time} s`, });
if(presencePath.exists) {
const setPresence = async (p: any) => {
return (dependencies[4] as Client).user?.setPresence(p);

12
test/core/ioc.test.ts
View File

@@ -98,4 +98,16 @@ describe('ioc container', () => {
container.ready();
expect(dependency.init).toHaveBeenCalledTimes(1);
})
it('should detect a key already exists', () => {
container.add({ '@sern/client': dependency2 });
expect(container.hasKey('@sern/client')).toBeTruthy()
})
it('should detect a key already exists', () => {
container.add({ '@sern/client': () => dependency2 });
expect(container.hasKey('@sern/client')).toBeTruthy()
})
});