Remove transitive dependency on moment-timezone (-5MB install size)

Switch `node-cron` to `cron-schedule`

Author: mrbbot

package-lock.json

@@ -72,8 +72,8 @@
   },
   "peerDependencies": {
     "@miniflare/storage-redis": "2.0.0-next.3",
-    "ioredis": "^4.27.9",
-    "node-cron": "^3.0.0"
+    "cron-schedule": "^3.0.4",
+    "ioredis": "^4.27.9"
   },
   "peerDependenciesMeta": {
     "@miniflare/storage-redis": {

packages/miniflare/package.json

@@ -154,14 +154,14 @@ test.serial("Miniflare: startScheduler: starts CRON scheduler", async (t) => {
   // Wait for plugins to load, this includes CRON validation
   await mf.getPlugins();
 
-  const cron = await import("node-cron");
-  const originalSchedule = cron.default.schedule;
-  t.teardown(() => (cron.default.schedule = originalSchedule));
-  cron.default.schedule = (expression, func) => {
-    t.is(expression, "* * * * *");
+  const { TimerBasedCronScheduler } = await import("cron-schedule");
+  const originalSetInterval = TimerBasedCronScheduler.setInterval;
+  t.teardown(() => (TimerBasedCronScheduler.setInterval = originalSetInterval));
+  TimerBasedCronScheduler.setInterval = (expression, func) => {
+    t.is(expression.toString(), "* * * * *");
     // Immediately invoke the task because we're impatient
     func();
-    return { destroy: () => t.fail() } as any;
+    return 0 as any;
   };
   await mf.startScheduler();
 });

packages/miniflare/test/api.spec.ts

@@ -38,10 +38,9 @@
   "dependencies": {
     "@miniflare/core": "2.0.0-next.3",
     "@miniflare/shared": "2.0.0-next.3",
-    "node-cron": "^3.0.0"
+    "cron-schedule": "^3.0.4"
   },
   "devDependencies": {
-    "@miniflare/shared-test": "2.0.0-next.3",
-    "@types/node-cron": "^2.0.4"
+    "@miniflare/shared-test": "2.0.0-next.3"
   }
 }

packages/scheduler/package.json

@@ -4,11 +4,16 @@ import {
   ReloadEvent,
   logResponse,
 } from "@miniflare/core";
-import type { ScheduledTask } from "node-cron";
+import type { Cron, ITimerHandle } from "cron-schedule";
 import { SchedulerPlugin } from "./plugin";
 
 export * from "./plugin";
 
+export interface CronScheduler {
+  setInterval(cron: Cron, task: () => any): ITimerHandle;
+  clearTimeoutOrInterval(handle: ITimerHandle): void;
+}
+
 export type SchedulerPluginSignatures = CorePluginSignatures & {
   SchedulerPlugin: typeof SchedulerPlugin;
 };
@@ -17,56 +22,63 @@ const kReload = Symbol("kReload");
 
 export class Scheduler<Plugins extends SchedulerPluginSignatures> {
   // noinspection JSMismatchedCollectionQueryUpdate
-  private previousValidatedCrons?: string[];
-  private scheduledTasks?: ScheduledTask[];
+  private previousValidatedCrons?: Cron[];
+  private scheduledHandles?: ITimerHandle[];
 
   constructor(
     private readonly mf: MiniflareCore<Plugins>,
-    private readonly cron: Promise<{
-      default: typeof import("node-cron");
-    }> = import("node-cron")
+    private readonly cronScheduler: Promise<CronScheduler> = import(
+      "cron-schedule"
+    ).then((module) => module.TimerBasedCronScheduler)
   ) {
-    this[kReload] = this[kReload].bind(this);
     mf.addEventListener("reload", this[kReload]);
   }
 
-  async [kReload](event: ReloadEvent<Plugins>): Promise<void> {
+  [kReload] = async (event: ReloadEvent<Plugins>): Promise<void> => {
     const validatedCrons = event.plugins.SchedulerPlugin.validatedCrons;
     // Checking references here, if different, SchedulerPlugin setup must've
     // been called meaning crons changed so reload scheduled tasks
     if (this.previousValidatedCrons === validatedCrons) return;
     this.previousValidatedCrons = validatedCrons;
 
+    const cronScheduler = await this.cronScheduler;
+
     // Schedule tasks, stopping all current ones first
-    this.scheduledTasks?.forEach((task) => task.destroy());
+    this.scheduledHandles?.forEach((handle) =>
+      cronScheduler.clearTimeoutOrInterval(handle)
+    );
     if (!validatedCrons.length) return;
-    const cron = await this.cron;
-    this.scheduledTasks = validatedCrons?.map((expression) =>
-      cron.default.schedule(expression, async () => {
+
+    this.scheduledHandles = validatedCrons?.map((cron) => {
+      const spec = cron.toString();
+      return cronScheduler.setInterval(cron, async () => {
         const start = process.hrtime();
         // scheduledTime will default to Date.now()
-        const waitUntil = this.mf.dispatchScheduled(undefined, expression);
+        const waitUntil = this.mf.dispatchScheduled(undefined, spec);
         await logResponse(this.mf.log, {
           start,
           method: "SCHD",
-          url: expression,
+          url: spec,
           waitUntil,
         });
-      })
-    );
-  }
+      });
+    });
+  };
 
-  dispose(): void {
+  async dispose(): Promise<void> {
     this.mf.removeEventListener("reload", this[kReload]);
-    this.scheduledTasks?.forEach((task) => task.destroy());
+    const cronScheduler = await this.cronScheduler;
+    this.scheduledHandles?.forEach((handle) =>
+      cronScheduler.clearTimeoutOrInterval(handle)
+    );
   }
 }
 
 export async function startScheduler<Plugins extends SchedulerPluginSignatures>(
   mf: MiniflareCore<Plugins>,
-  cron?: Promise<{ default: typeof import("node-cron") }>
+  cronScheduler?: Promise<CronScheduler>
 ): Promise<Scheduler<Plugins>> {
-  const scheduler = new Scheduler(mf, cron);
+  const scheduler = new Scheduler(mf, cronScheduler);
   await scheduler[kReload](new ReloadEvent(await mf.getPlugins()));
   return scheduler;
 }