sern/handler
1
0
Fork 0
mirror of https://github.com/sern-handler/handler synced 2026-06-27 18:22:14 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

revising cron modules and better error messages

Browse Source
This commit is contained in:
Jacob Nguyen
2024-07-04 19:18:52 -05:00
parent 92ca9eb859
commit c252854954
15 changed files with 148 additions and 105 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/core/ioc.ts
View File

@@ -67,8 +67,8 @@ export async function makeDependencies (conf: ValidDependencyConfig) {
container.addSingleton('@sern/errors', new __Services.DefaultErrorHandling);
container.addSingleton('@sern/modules', new Map);
container.addSingleton('@sern/emitter', new EventEmitter)
container.addWiredSingleton('@sern/cron',
(deps) => new __Services.Cron(deps as unknown as Dependencies))
container.addWiredSingleton('@sern/scheduler',
(deps) => new __Services.CronScheduler(deps as unknown as Dependencies))
conf(dependencyBuilder(container));
await container.ready();
}

8
src/core/presences.ts
View File

@@ -39,10 +39,8 @@ export const Presence = {
* @example
* ```ts
* Presence.of({
* activities: [
* { name: "Chilling out" }
* ]
* }).once() // Sets the presence once, with what's provided in '.of()'
* activities: [{ name: "Chilling out" }]
* }).once() // Sets the presence once, with what's provided in '.of()'
* ```
*/
once: () => root
@@ -50,7 +48,7 @@ export const Presence = {
}
}
export declare namespace Presence {
type Config<T extends (keyof Dependencies)[]> = {
export type Config<T extends (keyof Dependencies)[]> = {
inject?: [...T]
execute: (...v: IntoDependencies<T>) => Presence.Result;

43
src/core/schedule.ts Normal file
View File

@@ -0,0 +1,43 @@
import { CronJob } from 'cron';
export class TaskScheduler {
private __tasks: Map<string, CronJob> = new Map();
scheduleTask(taskName: string, cronExpression: string, task: () => void): boolean {
if (this.__tasks.has(taskName)) {
return false;
}
try {
const job = new CronJob(cronExpression, task);
job.start();
this.__tasks.set(taskName, job);
return true;
} catch (error) {
return false;
}
}
private stopTask(taskName: string): boolean {
const job = this.__tasks.get(taskName);
if (job) {
job.stop();
this.__tasks.delete(taskName);
return true;
}
return false;
}
private restartTask(taskName: string): boolean {
const job = this.__tasks.get(taskName);
if (job) {
job.start();
return true;
}
return false;
}
tasks(): string[] {
return Array.from(this.__tasks.keys());
}
}

70
src/core/structures/default-services.ts
View File

@@ -1,8 +1,6 @@
import type { LogPayload, Logging, ErrorHandling, Emitter } from '../interfaces';
import { AnyFunction, UnpackedDependencies } from '../../types/utility';
import cron from 'node-cron'
import type { CronEventCommand, Module } from '../../types/core-modules'
import { EventType } from './enums';
/**
* @internal
* @since 2.0.0
@@ -42,48 +40,30 @@ export class DefaultLogging implements Logging {
}
}
export class Cron implements Emitter {
export class CronScheduler {
tasks: string[] = [];
modules: Map<string, CronEventCommand> = new Map();
constructor(private deps: UnpackedDependencies) {}
private sanityCheck(eventName: string | symbol) : asserts eventName is string {
if(typeof eventName === 'symbol') throw Error("Cron cannot add symbol based listener")
}
addCronModule(module: Module) {
if(module.type !== EventType.Cron) {
throw Error("Can only add cron modules");
}
//@ts-ignore
if(!cron.validate(module.pattern)) {
throw Error("Invalid cron expression while adding " + module.name)
}
(module as CronEventCommand)
this.modules.set(module.name!, module as CronEventCommand);
}
addListener(eventName: string | symbol, listener: AnyFunction): this {
this.sanityCheck(eventName);
const retrievedModule = this.modules.get(eventName);
if(!retrievedModule) throw Error("Adding task: module " +eventName +"was not found");
const { pattern, name, runOnInit, timezone } = retrievedModule;
cron.schedule(pattern,
(date) => listener({ date, deps: this.deps }),
{ name, runOnInit, timezone, scheduled: true });
return this;
}
removeListener(eventName: string | symbol, listener: AnyFunction) {
this.sanityCheck(eventName);
const retrievedModule = this.modules.get(eventName);
if(!retrievedModule) throw Error("Removing cron: module " +eventName +"was not found");
const task = cron.getTasks().get(retrievedModule.name!)
if(!task) throw Error("Finding cron task with"+ retrievedModule.name + " not found");
task.stop();
return this;
}
emit(eventName: string | symbol, ...payload: any[]): boolean {
this.sanityCheck(eventName);
const retrievedModule = this.modules.get(eventName);
if(!retrievedModule) throw Error("Removing cron: module " +eventName +"was not found");
const task= cron.getTasks().get(retrievedModule.name!)
return task?.emit(eventName, payload) ?? false;
}
// addListener(eventName: string | symbol, listener: AnyFunction): this {
// const retrievedModule = this.modules.get(eventName);
// if(!retrievedModule) throw Error("Adding task: module " +eventName +"was not found");
// const { pattern, name, runOnInit, timezone } = retrievedModule;
// cron.schedule(pattern,
// (date) => listener({ date, deps: this.deps }),
// { name, runOnInit, timezone, scheduled: true });
// return this;
// }
// removeListener(eventName: string | symbol, listener: AnyFunction) {
// const retrievedModule = this.modules.get(eventName);
// if(!retrievedModule) throw Error("Removing cron: module " +eventName +"was not found");
// const task = cron.getTasks().get(retrievedModule.name!)
// if(!task) throw Error("Finding cron task with"+ retrievedModule.name + " not found");
// task.stop();
// return this;
// }
// emit(eventName: string | symbol, ...payload: any[]): boolean {
// const retrievedModule = this.modules.get(eventName);
// if(!retrievedModule) throw Error("Removing cron: module " +eventName +"was not found");
// const task= cron.getTasks().get(retrievedModule.name!)
// return task?.emit(eventName, payload) ?? false;
// }
}

1
src/core/structures/enums.ts
View File

@@ -58,7 +58,6 @@ export enum EventType {
* Could be for example, `process` events, database events
*/
External,
Cron
}
/**

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

@@ -262,10 +262,9 @@ export function intoTask(onStop: (m: Module) => unknown) {
return createResultResolver({ onStop, onNext });
}
export const handleCrash =
({ "@sern/errors": err, '@sern/emitter': sem, '@sern/logger': log } : UnpackedDependencies) =>
export const handleCrash = ({ "@sern/errors": err, '@sern/emitter': sem, '@sern/logger': log } : UnpackedDependencies, metadata: string) =>
pipe(catchError(handleError(err, sem, log)),
finalize(() => {
log?.info({ message: 'A stream closed or reached end of lifetime' });
log?.info({ message: 'A stream closed: ' + metadata });
disposeAll(log);
}))

5
src/handlers/interaction.ts
View File

@@ -1,6 +1,6 @@
import type { Interaction } from 'discord.js';
import { mergeMap, merge, concatMap, EMPTY } from 'rxjs';
import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap } from './event-utils';
import { createInteractionHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash } from './event-utils';
import { SernError } from '../core/structures/enums'
import { isAutocomplete, isCommand, isMessageComponent, isModal, resultPayload } from '../core/functions'
import { UnpackedDependencies } from '../types/utility';
@@ -25,5 +25,6 @@ export default function interactionHandler(deps: UnpackedDependencies, defaultPr
if(payload)
return executeModule(emitter, payload)
return EMPTY;
}));
}),
handleCrash(deps, "interaction handling"));
}

6
src/handlers/message.ts
View File

@@ -1,6 +1,6 @@
import { EMPTY, mergeMap, concatMap } from 'rxjs';
import type { Message } from 'discord.js';
import { createMessageHandler, executeModule, intoTask, sharedEventStream, filterTap} from './event-utils';
import { createMessageHandler, executeModule, intoTask, sharedEventStream, filterTap, handleCrash} from './event-utils';
import { SernError } from '../core/structures/enums'
import { resultPayload } from '../core/functions'
import { UnpackedDependencies } from '../types/utility';
@@ -44,5 +44,7 @@ function (deps: UnpackedDependencies, defaultPrefix?: string) {
if(payload)
return executeModule(emitter, payload)
return EMPTY;
}));
}),
handleCrash(deps, "message handling")
)
}

23
src/handlers/tasks.ts Normal file
View File

@@ -0,0 +1,23 @@
import { TaskScheduler } from "../core/schedule"
import * as Files from '../core/module-loading'
import { UnpackedDependencies } from "../types/utility";
interface ScheduledTaskModule {
name?: string;
description?: string;
pattern: string;
execute(deps: UnpackedDependencies, tasks: string[]): any
}
export const registerTasks = async (path: string, deps: UnpackedDependencies) => {
const taskManager = new TaskScheduler()
for await (const f of Files.readRecursive(path)) {
let { module } = await Files.importModule<ScheduledTaskModule>(f);
//module.name is assigned by Files.importModule<>
taskManager.scheduleTask(module.name!, module.pattern, () => {
module.execute(deps, taskManager.tasks())
})
}
}

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

@@ -14,12 +14,6 @@ const intoDispatcher = (deps: UnpackedDependencies) =>
return eventDispatcher(deps, module, deps['@sern/client']);
case EventType.External:
return eventDispatcher(deps, module, deps[module.emitter]);
case EventType.Cron: {
//@ts-ignore
const cron = deps['@sern/cron'];
cron.addCronModule(module);
return eventDispatcher(deps, module, cron);
}
default: throw Error(SernError.InvalidModuleType + ' while creating event handler');
}
};
@@ -34,6 +28,6 @@ export default async function(deps: UnpackedDependencies, eventDir: string) {
from(eventModules)
.pipe(map(intoDispatcher(deps)),
mergeAll(), // all eventListeners are turned on
handleCrash(deps))
handleCrash(deps, "event modules"))
.subscribe();
}

7
src/sern.ts
View File

@@ -12,11 +12,13 @@ import { presenceHandler } from './handlers/presence';
import { handleCrash } from './handlers/event-utils';
import { UnpackedDependencies } from './types/utility';
import type { Presence} from './core/presences';
import { registerTasks } from './handlers/tasks';
interface Wrapper {
commands: string;
defaultPrefix?: string;
events?: string;
tasks?: string;
}
/**
* @since 1.0.0
@@ -57,11 +59,14 @@ export function init(maybeWrapper: Wrapper = { commands: "./dist/commands" }) {
}
presenceHandler(presencePath.path, setPresence).subscribe();
}
if(maybeWrapper.tasks) {
registerTasks(maybeWrapper.tasks, deps);
}
})
.catch(err => { throw err });
const messages$ = messageHandler(deps, maybeWrapper.defaultPrefix);
const interactions$ = interactionHandler(deps, maybeWrapper.defaultPrefix);
// listening to the message stream and interaction stream
merge(messages$, interactions$).pipe(handleCrash(deps)).subscribe();
merge(messages$, interactions$).subscribe();
}

12
src/types/core-modules.ts
View File

@@ -58,14 +58,7 @@ export interface ExternalEventCommand extends Module {
type: EventType.External;
execute(...args: unknown[]): Awaitable<unknown>;
}
export interface CronEventCommand extends Module {
type: EventType.Cron;
name?: string;
pattern: string;
runOnInit?: boolean
timezone?: string;
execute(...args: unknown[]): Awaitable<unknown>;
}
export interface ContextMenuUser extends Module {
type: CommandType.CtxUser;
@@ -142,7 +135,7 @@ export interface BothCommand extends Module {
execute: (ctx: Context, tbd: SDT) => Awaitable<unknown>;
}
export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand | CronEventCommand;
export type EventModule = DiscordEventCommand | SernEventCommand | ExternalEventCommand;
export type CommandModule =
| TextCommand
| SlashCommand
@@ -178,7 +171,6 @@ export interface EventModuleDefs {
[EventType.Sern]: SernEventCommand;
[EventType.Discord]: DiscordEventCommand;
[EventType.External]: ExternalEventCommand;
[EventType.Cron]: CronEventCommand;
}
export interface SernAutocompleteData