Make reusable polling scheduler API

Author: TheKodeToad

backend/src/common/pollingScheduler.ts

@@ -0,0 +1,73 @@
+import { moduleLogger } from "#common/logger/index.ts";
+import { dateToHMSString } from "#common/time.ts";
+
+const logger = moduleLogger();
+
+export interface PollingSchedulerOptions<T> {
+	discriminator: string;
+	pollRate: number;
+
+	poll: (startInclusive: Date, endExclusive: Date) => Promise<T[]>;
+	run: (task: T) => Promise<void>;
+
+	getTimestamp: (task: T) => Date;
+	debugFormat: (task: T) => string;
+}
+
+export interface PollingSchedulerHandle<T> {
+	track: (task: T) => void;
+}
+
+interface State<T> {
+	options: PollingSchedulerOptions<T>;
+	nextStartTimestamp: Date;
+}
+
+/**
+ * Start polling for tasks.
+ * @return A handle to the scheduler, after the first poll is done
+ */
+export async function startPollingScheduler<T>(options: PollingSchedulerOptions<T>): Promise<PollingSchedulerHandle<T>> {
+	const state: State<T> = {
+		options,
+		nextStartTimestamp: new Date(0),
+	};
+
+	await poll(state);
+	setInterval(() => poll(state), state.options.pollRate).unref();
+
+	return {
+		track: task => {
+			if (state.options.getTimestamp(task) >= state.nextStartTimestamp)
+				return;
+
+			setRunTimeout(state, task);
+		}
+	};
+}
+
+async function poll<E>(state: State<E>): Promise<void> {
+	const end = new Date(Date.now() + state.options.pollRate);
+
+	logger.debug?.(
+		end.getTime()
+			? `Setting initial timeouts for #${state.options.discriminator} tasks`
+			: `Setting timeouts for #${state.options.discriminator} tasks `
+				+ ` from ${dateToHMSString(state.nextStartTimestamp)}`
+				+ ` to ${dateToHMSString(end)}`
+	);
+
+	const tasks = await state.options.poll(state.nextStartTimestamp, end);
+	state.nextStartTimestamp = end;
+
+	for (const task of tasks) {
+		setRunTimeout(state, task);
+	}
+}
+
+async function setRunTimeout<T>(state: State<T>, task: T) {
+	const delay = Math.max(0, state.options.getTimestamp(task).getTime() - Date.now());
+	setTimeout(() => state.options.run(task), delay).unref();
+
+	logger.debug?.(`Setting up timeout for #${state.options.discriminator} task ${state.options.debugFormat(task)} with delay ${delay}`);
+}

backend/src/plugin/reminders/scheduler.ts

@@ -3,7 +3,8 @@ import { debugFormatChannel } from "#common/discord/debugFormat.ts";
 import { isTextableChannel, isThreadChannelType } from "#common/discord/general.ts";
 import { canWriteInChannel } from "#common/discord/permissions.ts";
 import { moduleLogger } from "#common/logger/index.ts";
-import { dateToHMSString, dateToUnixSecs } from "#common/time.ts";
+import { startPollingScheduler, type PollingSchedulerHandle } from "#common/pollingScheduler.ts";
+import { dateToHMSString, dateToUnixSecs, SECOND } from "#common/time.ts";
 import { onBotInit } from "#discord/extensionPoints.ts";
 import { bot } from "#discord/index.ts";
 import { icons } from "#plugin/core/public/icons.ts";
@@ -13,45 +14,25 @@ import { DiscordRESTError, MessageFlags, Permissions, type AnyTextableChannel }
 
 const logger = moduleLogger();
 
-const TIMEOUT_POLL_RATE = 60 * 1000;
-
-let nextExpiryStartTime = new Date(0);
+let scheduler: PollingSchedulerHandle<Reminder> | null = null;
 
 export default [onBotInit(beginPollingReminders)];
 
 async function beginPollingReminders(): Promise<void> {
-	await poll();
-	setInterval(poll, TIMEOUT_POLL_RATE).unref();
-}
-
-export function trackNewReminder(reminder: Reminder): void {
-	if (reminder.firesAt.getTime() >= nextExpiryStartTime.getTime())
-		return;
-
-	setTimeout(() => fire(reminder), Math.max(0, reminder.firesAt.getTime() - Date.now())).unref();
-}
-
-async function poll(): Promise<void> {
-	const end = new Date(Date.now() + TIMEOUT_POLL_RATE);
-
-	logger.debug?.(
-		nextExpiryStartTime.getTime() === 0
-			? "Setting initial timeouts for missed and upcoming reminders until " + dateToHMSString(end)
-			: "Setting timeouts for reminders from " + dateToHMSString(nextExpiryStartTime) + " to " + dateToHMSString(end)
-	);
+	scheduler = await startPollingScheduler({
+		discriminator: "reminders",
+		pollRate: 60 * SECOND,
 
-	const reminders = await getRemindersByFiresAt(nextExpiryStartTime, end);
-	nextExpiryStartTime = end;
+		poll: (start, end) => getRemindersByFiresAt(start, end),
+		run: fire,
 
-	for (const reminder of reminders)
-		setFireTimeout(reminder);
+		getTimestamp: task => task.firesAt,
+		debugFormat: debugFormatReminder
+	});
 }
 
-function setFireTimeout(reminder: Reminder): void {
-	const delay = Math.max(0, reminder.firesAt.getTime() - Date.now());
-	setTimeout(() => fire(reminder), delay);
-
-	logger.debug?.(`Setting up timeout for reminder ${debugFormatReminder(reminder)} with delay ${delay}`);
+export function trackNewReminder(reminder: Reminder): void {
+	scheduler?.track(reminder);
 }
 
 async function fire(reminder: Reminder): Promise<void> {