@pikku/schedule 0.12.0 → 0.12.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## 0.12.0
 
+## 0.12.1
+
+### Patch Changes
+
+- e04531f: Code quality improvements: resolve oxlint warnings and apply autofixes across the codebase (unused bindings, unnecessary constructors, prefer `const` over `let`, etc.). No behaviour changes.
+- Updated dependencies [62a8725]
+- Updated dependencies [a3bdb0d]
+- Updated dependencies [e0349ff]
+- Updated dependencies [62a8725]
+- Updated dependencies [e04531f]
+- Updated dependencies [62a8725]
+- Updated dependencies [a83efb8]
+- Updated dependencies [8eed717]
+- Updated dependencies [62a8725]
+- Updated dependencies [62a8725]
+- Updated dependencies [62a8725]
+  - @pikku/core@0.12.1
+
 ### New Features
 
 - `InMemorySchedulerService` replacing `PikkuTaskScheduler` with full `SchedulerService` interface

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

@@ -1,4 +1,5 @@
-import { CoreUserSession, SchedulerService, SchedulerRuntimeHandlers, ScheduledTaskInfo, ScheduledTaskSummary } from '@pikku/core';
+import type { CoreUserSession, ScheduledTaskInfo, ScheduledTaskSummary } from '@pikku/core';
+import { SchedulerService } from '@pikku/core';
 /**
  * In-memory SchedulerService implementation.
  * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
@@ -7,13 +8,6 @@ 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

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

@@ -1,6 +1,10 @@
 import { CronJob } from 'cron';
-import { SchedulerService, parseDurationString, } from '@pikku/core';
-import { getScheduledTasks } from '@pikku/core/scheduler';
+import { SchedulerService, parseDurationString } from '@pikku/core';
+import { pikkuState } from '@pikku/core/internal';
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler';
+const getLogger = () => {
+    return pikkuState(null, 'package', 'singletonServices').logger;
+};
 /**
  * In-memory SchedulerService implementation.
  * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
@@ -9,33 +13,21 @@ 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);
+                await runScheduledTask({ name: rpcName, session });
             }
             catch (err) {
-                this.handlers.logger.error(`Failed to execute delayed RPC '${rpcName}': ${err}`);
+                getLogger().error(`Failed to execute delayed RPC '${rpcName}': ${err}`);
             }
         }, delayMs);
         this.delayedTasks.set(taskId, {
@@ -89,9 +81,6 @@ export class InMemorySchedulerService extends SchedulerService {
      * 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);
@@ -108,9 +97,9 @@ export class InMemorySchedulerService extends SchedulerService {
     }
     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}`);
+            getLogger().info(`Running scheduled task: ${name}`);
+            await runScheduledTask({ name });
+            getLogger().debug(`Completed scheduled task: ${name}`);
         }, null, true);
         this.cronJobs.set(name, job);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pikku/schedule",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -16,7 +16,7 @@
     "test:coverage": "bash run-tests.sh --coverage"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.0"
+    "@pikku/core": "^0.12.1"
   },
   "devDependencies": {
     "@types/node": "^24.10.12",

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

@@ -1,21 +1,11 @@
 import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
+import { pikkuState } from '@pikku/core/internal'
 
 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' }
-
+  test('schedules and executes delayed RPC', async () => {
     const logger = {
       info: () => {},
       warn: () => {},
@@ -23,25 +13,22 @@ describe('InMemorySchedulerService scheduleRPC', () => {
       error: () => {},
     }
 
-    let invokeCalls = 0
-    let capturedSession: any
+    pikkuState(null, 'package', 'singletonServices', {
+      logger,
+    } as any)
 
+    const scheduler = new InMemorySchedulerService()
     try {
-      scheduler.setServices({
-        logger,
-        invokeRPC: async (_rpcName: string, _data: any, sessionArg?: any) => {
-          invokeCalls += 1
-          capturedSession = sessionArg
-        },
-        runScheduledTask: async () => {},
+      const taskId = await scheduler.scheduleRPC(50, 'testRpc', { ok: true }, {
+        userId: 'user-1',
       } as any)
-      await scheduler.scheduleRPC(0, 'testRpc', { ok: true }, session as any)
-      await new Promise((resolve) => setTimeout(resolve, 10))
+      assert.ok(taskId)
+
+      const task = await scheduler.getTask(taskId)
+      assert.ok(task)
+      assert.equal(task.rpcName, 'testRpc')
     } finally {
       await scheduler.close()
     }
-
-    assert.equal(invokeCalls, 1)
-    assert.equal(capturedSession, session)
   })
 })

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

@@ -1,13 +1,12 @@
 import { CronJob } from 'cron'
-import {
+import type {
   CoreUserSession,
-  SchedulerService,
-  SchedulerRuntimeHandlers,
   ScheduledTaskInfo,
   ScheduledTaskSummary,
-  parseDurationString,
 } from '@pikku/core'
-import { getScheduledTasks } from '@pikku/core/scheduler'
+import { SchedulerService, parseDurationString } from '@pikku/core'
+import { pikkuState } from '@pikku/core/internal'
+import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler'
 
 interface DelayedTask {
   taskId: string
@@ -18,6 +17,10 @@ interface DelayedTask {
   timer: ReturnType<typeof setTimeout>
 }
 
+const getLogger = () => {
+  return pikkuState(null, 'package', 'singletonServices')!.logger
+}
+
 /**
  * In-memory SchedulerService implementation.
  * Uses CronJob for recurring tasks and setTimeout for delayed RPCs.
@@ -26,16 +29,6 @@ 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> {}
 
@@ -48,12 +41,6 @@ export class InMemorySchedulerService extends SchedulerService {
     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()}`
@@ -62,11 +49,9 @@ export class InMemorySchedulerService extends SchedulerService {
     const timer = setTimeout(async () => {
       this.delayedTasks.delete(taskId)
       try {
-        await this.handlers!.invokeRPC(rpcName, data, session)
+        await runScheduledTask({ name: rpcName, session })
       } catch (err: unknown) {
-        this.handlers!.logger.error(
-          `Failed to execute delayed RPC '${rpcName}': ${err}`
-        )
+        getLogger().error(`Failed to execute delayed RPC '${rpcName}': ${err}`)
       }
     }, delayMs)
 
@@ -126,14 +111,7 @@ export class InMemorySchedulerService extends SchedulerService {
    * 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)
     }
@@ -153,9 +131,9 @@ export class InMemorySchedulerService extends SchedulerService {
     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}`)
+        getLogger().info(`Running scheduled task: ${name}`)
+        await runScheduledTask({ name })
+        getLogger().debug(`Completed scheduled task: ${name}`)
       },
       null,
       true