@pikku/schedule 0.11.1 → 0.12.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.12.0
+
+### New Features
+
+- `InMemorySchedulerService` replacing `PikkuTaskScheduler` with full `SchedulerService` interface
+- Recurring cron task support via `node-cron`
+- `setServices()`, `start()`, `stop()` lifecycle methods
+
 ## 0.11.0
 
 ## 0.11.1

package/dist/in-memory-scheduler-service.d.ts

@@ -0,0 +1,35 @@
+import { CoreUserSession, SchedulerService, SchedulerRuntimeHandlers, ScheduledTaskInfo, ScheduledTaskSummary } from '@pikku/core';
+/**
+ * In-memory SchedulerService implementation.
+ * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
+ */
+export declare class InMemorySchedulerService extends SchedulerService {
+    private cronJobs;
+    private delayedTasks;
+    private idCounter;
+    private handlers?;
+    /**
+     * Set services needed for processing recurring tasks.
+     * Must be called before start() since the scheduler is typically
+     * created before singletonServices are available.
+     */
+    setServices(handlers: SchedulerRuntimeHandlers): void;
+    init(): Promise<void>;
+    /**
+     * Schedule a one-off delayed RPC call via setTimeout
+     */
+    scheduleRPC(delay: number | string, rpcName: string, data?: any, session?: CoreUserSession): Promise<string>;
+    unschedule(taskId: string): Promise<boolean>;
+    getTask(taskId: string): Promise<ScheduledTaskInfo | null>;
+    getAllTasks(): Promise<ScheduledTaskSummary[]>;
+    close(): Promise<void>;
+    /**
+     * Start recurring scheduled tasks.
+     */
+    start(): Promise<void>;
+    /**
+     * Stop all recurring CronJobs.
+     */
+    stop(): Promise<void>;
+    private startCronJob;
+}

package/dist/in-memory-scheduler-service.js

@@ -0,0 +1,117 @@
+import { CronJob } from 'cron';
+import { SchedulerService, parseDurationString, } from '@pikku/core';
+import { getScheduledTasks } from '@pikku/core/scheduler';
+/**
+ * In-memory SchedulerService implementation.
+ * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
+ */
+export class InMemorySchedulerService extends SchedulerService {
+    cronJobs = new Map();
+    delayedTasks = new Map();
+    idCounter = 0;
+    handlers;
+    /**
+     * Set services needed for processing recurring tasks.
+     * Must be called before start() since the scheduler is typically
+     * created before singletonServices are available.
+     */
+    setServices(handlers) {
+        this.handlers = handlers;
+    }
+    async init() { }
+    /**
+     * Schedule a one-off delayed RPC call via setTimeout
+     */
+    async scheduleRPC(delay, rpcName, data, session) {
+        if (!this.handlers) {
+            throw new Error('InMemorySchedulerService requires setServices() before scheduling RPCs');
+        }
+        const delayMs = typeof delay === 'string' ? parseDurationString(delay) : delay;
+        const taskId = `inmem-${++this.idCounter}-${Date.now()}`;
+        const scheduledFor = new Date(Date.now() + delayMs);
+        const timer = setTimeout(async () => {
+            this.delayedTasks.delete(taskId);
+            try {
+                await this.handlers.invokeRPC(rpcName, data, session);
+            }
+            catch (err) {
+                this.handlers.logger.error(`Failed to execute delayed RPC '${rpcName}': ${err}`);
+            }
+        }, delayMs);
+        this.delayedTasks.set(taskId, {
+            taskId,
+            rpcName,
+            data,
+            session,
+            scheduledFor,
+            timer,
+        });
+        return taskId;
+    }
+    async unschedule(taskId) {
+        const task = this.delayedTasks.get(taskId);
+        if (task) {
+            clearTimeout(task.timer);
+            this.delayedTasks.delete(taskId);
+            return true;
+        }
+        return false;
+    }
+    async getTask(taskId) {
+        const task = this.delayedTasks.get(taskId);
+        if (!task)
+            return null;
+        return {
+            taskId: task.taskId,
+            rpcName: task.rpcName,
+            scheduledFor: task.scheduledFor,
+            data: task.data,
+            session: task.session,
+            status: 'scheduled',
+        };
+    }
+    async getAllTasks() {
+        return Array.from(this.delayedTasks.values()).map((t) => ({
+            taskId: t.taskId,
+            rpcName: t.rpcName,
+            scheduledFor: t.scheduledFor,
+        }));
+    }
+    async close() {
+        await this.stop();
+        // Clear delayed tasks
+        for (const [, task] of this.delayedTasks) {
+            clearTimeout(task.timer);
+        }
+        this.delayedTasks.clear();
+    }
+    /**
+     * Start recurring scheduled tasks.
+     */
+    async start() {
+        if (!this.handlers) {
+            throw new Error('InMemorySchedulerService requires setServices() before start()');
+        }
+        const scheduledTasks = getScheduledTasks();
+        for (const [, task] of scheduledTasks) {
+            this.startCronJob(task.name, task.schedule);
+        }
+    }
+    /**
+     * Stop all recurring CronJobs.
+     */
+    async stop() {
+        for (const [, job] of this.cronJobs) {
+            job.stop();
+        }
+        this.cronJobs.clear();
+    }
+    startCronJob(name, schedule) {
+        const job = new CronJob(schedule, async () => {
+            this.handlers.logger.info(`Running scheduled task: ${name}`);
+            await this.handlers.runScheduledTask(name);
+            this.handlers.logger.debug(`Completed scheduled task: ${name}`);
+        }, null, true);
+        this.cronJobs.set(name, job);
+    }
+}

package/dist/index.d.ts

@@ -1 +1,5 @@
-export { PikkuTaskScheduler } from './pikku-task-scheduler.js';
+export { InMemorySchedulerService } from './in-memory-scheduler-service.js';
+/**
+ * @deprecated Use InMemorySchedulerService instead
+ */
+export { InMemorySchedulerService as PikkuTaskScheduler } from './in-memory-scheduler-service.js';

package/dist/index.js

@@ -1 +1,5 @@
-export { PikkuTaskScheduler } from './pikku-task-scheduler.js';
+export { InMemorySchedulerService } from './in-memory-scheduler-service.js';
+/**
+ * @deprecated Use InMemorySchedulerService instead
+ */
+export { InMemorySchedulerService as PikkuTaskScheduler } from './in-memory-scheduler-service.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/schedule",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -16,17 +16,17 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.11.1"
+    "@pikku/core": "^0.12.0"
   },
   "devDependencies": {
-    "@types/node": "^24.10.1",
+    "@types/node": "^24.10.12",
     "typescript": "^5.9"
   },
   "engines": {
     "node": ">=18"
   },
   "dependencies": {
-    "cron": "^4.3.4",
+    "cron": "^4.4.0",
     "cron-schedule": "^5.0.4"
   }
 }

package/src/in-memory-scheduler-service.test.ts

@@ -0,0 +1,47 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { InMemorySchedulerService } from './in-memory-scheduler-service.js'
+
+describe('InMemorySchedulerService scheduleRPC', () => {
+  test('throws when setServices has not been called', async () => {
+    const scheduler = new InMemorySchedulerService()
+    await assert.rejects(() => scheduler.scheduleRPC(0, 'testRpc', {}), {
+      message:
+        'InMemorySchedulerService requires setServices() before scheduling RPCs',
+    })
+  })
+
+  test('uses empty wire context and does not create wire services', async () => {
+    const scheduler = new InMemorySchedulerService()
+    const session = { userId: 'user-1' }
+
+    const logger = {
+      info: () => {},
+      warn: () => {},
+      debug: () => {},
+      error: () => {},
+    }
+
+    let invokeCalls = 0
+    let capturedSession: any
+
+    try {
+      scheduler.setServices({
+        logger,
+        invokeRPC: async (_rpcName: string, _data: any, sessionArg?: any) => {
+          invokeCalls += 1
+          capturedSession = sessionArg
+        },
+        runScheduledTask: async () => {},
+      } as any)
+      await scheduler.scheduleRPC(0, 'testRpc', { ok: true }, session as any)
+      await new Promise((resolve) => setTimeout(resolve, 10))
+    } finally {
+      await scheduler.close()
+    }
+
+    assert.equal(invokeCalls, 1)
+    assert.equal(capturedSession, session)
+  })
+})

package/src/in-memory-scheduler-service.ts

@@ -0,0 +1,165 @@
+import { CronJob } from 'cron'
+import {
+  CoreUserSession,
+  SchedulerService,
+  SchedulerRuntimeHandlers,
+  ScheduledTaskInfo,
+  ScheduledTaskSummary,
+  parseDurationString,
+} from '@pikku/core'
+import { getScheduledTasks } from '@pikku/core/scheduler'
+
+interface DelayedTask {
+  taskId: string
+  rpcName: string
+  data?: any
+  session?: CoreUserSession
+  scheduledFor: Date
+  timer: ReturnType<typeof setTimeout>
+}
+
+/**
+ * In-memory SchedulerService implementation.
+ * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
+ */
+export class InMemorySchedulerService extends SchedulerService {
+  private cronJobs = new Map<string, CronJob>()
+  private delayedTasks = new Map<string, DelayedTask>()
+  private idCounter = 0
+  private handlers?: SchedulerRuntimeHandlers
+
+  /**
+   * Set services needed for processing recurring tasks.
+   * Must be called before start() since the scheduler is typically
+   * created before singletonServices are available.
+   */
+  setServices(handlers: SchedulerRuntimeHandlers): void {
+    this.handlers = handlers
+  }
+
+  async init(): Promise<void> {}
+
+  /**
+   * Schedule a one-off delayed RPC call via setTimeout
+   */
+  async scheduleRPC(
+    delay: number | string,
+    rpcName: string,
+    data?: any,
+    session?: CoreUserSession
+  ): Promise<string> {
+    if (!this.handlers) {
+      throw new Error(
+        'InMemorySchedulerService requires setServices() before scheduling RPCs'
+      )
+    }
+
+    const delayMs =
+      typeof delay === 'string' ? parseDurationString(delay) : delay
+    const taskId = `inmem-${++this.idCounter}-${Date.now()}`
+    const scheduledFor = new Date(Date.now() + delayMs)
+
+    const timer = setTimeout(async () => {
+      this.delayedTasks.delete(taskId)
+      try {
+        await this.handlers!.invokeRPC(rpcName, data, session)
+      } catch (err: unknown) {
+        this.handlers!.logger.error(
+          `Failed to execute delayed RPC '${rpcName}': ${err}`
+        )
+      }
+    }, delayMs)
+
+    this.delayedTasks.set(taskId, {
+      taskId,
+      rpcName,
+      data,
+      session,
+      scheduledFor,
+      timer,
+    })
+
+    return taskId
+  }
+
+  async unschedule(taskId: string): Promise<boolean> {
+    const task = this.delayedTasks.get(taskId)
+    if (task) {
+      clearTimeout(task.timer)
+      this.delayedTasks.delete(taskId)
+      return true
+    }
+    return false
+  }
+
+  async getTask(taskId: string): Promise<ScheduledTaskInfo | null> {
+    const task = this.delayedTasks.get(taskId)
+    if (!task) return null
+    return {
+      taskId: task.taskId,
+      rpcName: task.rpcName,
+      scheduledFor: task.scheduledFor,
+      data: task.data,
+      session: task.session,
+      status: 'scheduled',
+    }
+  }
+
+  async getAllTasks(): Promise<ScheduledTaskSummary[]> {
+    return Array.from(this.delayedTasks.values()).map((t) => ({
+      taskId: t.taskId,
+      rpcName: t.rpcName,
+      scheduledFor: t.scheduledFor,
+    }))
+  }
+
+  async close(): Promise<void> {
+    await this.stop()
+    // Clear delayed tasks
+    for (const [, task] of this.delayedTasks) {
+      clearTimeout(task.timer)
+    }
+    this.delayedTasks.clear()
+  }
+
+  /**
+   * Start recurring scheduled tasks.
+   */
+  async start(): Promise<void> {
+    if (!this.handlers) {
+      throw new Error(
+        'InMemorySchedulerService requires setServices() before start()'
+      )
+    }
+
+    const scheduledTasks = getScheduledTasks()
+
+    for (const [, task] of scheduledTasks) {
+      this.startCronJob(task.name, task.schedule)
+    }
+  }
+
+  /**
+   * Stop all recurring CronJobs.
+   */
+  async stop(): Promise<void> {
+    for (const [, job] of this.cronJobs) {
+      job.stop()
+    }
+    this.cronJobs.clear()
+  }
+
+  private startCronJob(name: string, schedule: string) {
+    const job = new CronJob(
+      schedule,
+      async () => {
+        this.handlers!.logger.info(`Running scheduled task: ${name}`)
+        await this.handlers!.runScheduledTask(name)
+        this.handlers!.logger.debug(`Completed scheduled task: ${name}`)
+      },
+      null,
+      true
+    )
+    this.cronJobs.set(name, job)
+  }
+}

package/src/index.ts

@@ -1 +1,6 @@
-export { PikkuTaskScheduler } from './pikku-task-scheduler.js'
+export { InMemorySchedulerService } from './in-memory-scheduler-service.js'
+
+/**
+ * @deprecated Use InMemorySchedulerService instead
+ */
+export { InMemorySchedulerService as PikkuTaskScheduler } from './in-memory-scheduler-service.js'

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/pikku-task-scheduler.ts"],"version":"5.9.3"}
+{"root":["./src/in-memory-scheduler-service.ts","./src/index.ts"],"version":"5.9.3"}

package/dist/pikku-task-scheduler.d.ts

@@ -1,12 +0,0 @@
-import { CoreServices, CoreSingletonServices, CoreUserSession, CreateWireServices } from '@pikku/core';
-export declare class PikkuTaskScheduler<TaskName extends string> {
-    private singletonServices;
-    private createWireServices?;
-    private jobs;
-    constructor(singletonServices: CoreSingletonServices, createWireServices?: CreateWireServices<CoreSingletonServices, CoreServices, CoreUserSession> | undefined);
-    startAll(): void;
-    stopAll(): void;
-    start(names: TaskName[]): void;
-    stop(names: TaskName[]): void;
-    private startJobSchedule;
-}

package/dist/pikku-task-scheduler.js

@@ -1,49 +0,0 @@
-import { CronJob } from 'cron';
-import { runScheduledTask, getScheduledTasks, } from '@pikku/core/scheduler';
-export class PikkuTaskScheduler {
-    singletonServices;
-    createWireServices;
-    jobs = new Map();
-    constructor(singletonServices, createWireServices) {
-        this.singletonServices = singletonServices;
-        this.createWireServices = createWireServices;
-    }
-    startAll() {
-        const scheduledTasks = getScheduledTasks();
-        scheduledTasks.forEach((task) => this.startJobSchedule(task));
-    }
-    stopAll() {
-        this.jobs.forEach((job) => job.stop());
-        this.jobs.clear();
-    }
-    start(names) {
-        const scheduledTasks = getScheduledTasks();
-        for (const name of names) {
-            const task = scheduledTasks.get(name);
-            if (task) {
-                this.startJobSchedule(task);
-            }
-        }
-    }
-    stop(names) {
-        for (const name of names) {
-            const job = this.jobs.get(name);
-            if (job) {
-                job.stop();
-                this.jobs.delete(name);
-            }
-        }
-    }
-    startJobSchedule(task) {
-        const job = new CronJob(task.schedule, async () => {
-            this.singletonServices.logger.info(`Running scheduled task: ${task.name}`);
-            await runScheduledTask({
-                singletonServices: this.singletonServices,
-                createWireServices: this.createWireServices,
-                name: task.name,
-            });
-            this.singletonServices.logger.debug(`Completed scheduled task: ${task.name}`);
-        }, null, true);
-        this.jobs.set(task.name, job);
-    }
-}

package/src/pikku-task-scheduler.ts

@@ -1,77 +0,0 @@
-import { CronJob } from 'cron'
-import {
-  CoreServices,
-  CoreSingletonServices,
-  CoreUserSession,
-  CreateWireServices,
-} from '@pikku/core'
-import {
-  runScheduledTask,
-  CoreScheduledTask,
-  getScheduledTasks,
-} from '@pikku/core/scheduler'
-
-export class PikkuTaskScheduler<TaskName extends string> {
-  private jobs = new Map<string, CronJob>()
-
-  constructor(
-    private singletonServices: CoreSingletonServices,
-    private createWireServices?: CreateWireServices<
-      CoreSingletonServices,
-      CoreServices,
-      CoreUserSession
-    >
-  ) {}
-
-  public startAll() {
-    const scheduledTasks = getScheduledTasks()
-    scheduledTasks.forEach((task) => this.startJobSchedule(task))
-  }
-
-  public stopAll() {
-    this.jobs.forEach((job) => job.stop())
-    this.jobs.clear()
-  }
-
-  public start(names: TaskName[]) {
-    const scheduledTasks = getScheduledTasks()
-    for (const name of names) {
-      const task = scheduledTasks.get(name)
-      if (task) {
-        this.startJobSchedule(task)
-      }
-    }
-  }
-
-  public stop(names: TaskName[]) {
-    for (const name of names) {
-      const job = this.jobs.get(name)
-      if (job) {
-        job.stop()
-        this.jobs.delete(name)
-      }
-    }
-  }
-
-  private startJobSchedule(task: CoreScheduledTask) {
-    const job = new CronJob(
-      task.schedule,
-      async () => {
-        this.singletonServices.logger.info(
-          `Running scheduled task: ${task.name}`
-        )
-        await runScheduledTask({
-          singletonServices: this.singletonServices,
-          createWireServices: this.createWireServices as any,
-          name: task.name,
-        })
-        this.singletonServices.logger.debug(
-          `Completed scheduled task: ${task.name}`
-        )
-      },
-      null,
-      true
-    )
-    this.jobs.set(task.name, job)
-  }
-}