@pikku/schedule 0.12.4 → 0.12.5

package/CHANGELOG.md

@@ -1,3 +1,32 @@
+## 0.12.5
+
+### Patch Changes
+
+- dbff6ae: **A delayed RPC now actually runs.** `InMemorySchedulerService.scheduleRPC`
+  dispatched through `runScheduledTask`, which resolves names against the wired
+  _cron task_ registry — a registry no internally scheduled RPC is ever in. Every
+  such call died as `ScheduledTaskNotFoundError` and was swallowed into a log
+  line, and the payload captured alongside it was never forwarded. The one that
+  mattered was `pikkuWorkflowSleeper`: it is what wakes a run from
+  `workflow.sleep`, so an async workflow containing a sleep stopped at the first
+  one and stayed `running` forever. It now invokes the RPC with its data, matching
+  what the BullMQ and pg-boss schedulers already do.
+- Updated dependencies [41c1a95]
+- Updated dependencies [ce96383]
+- Updated dependencies [7e60867]
+- Updated dependencies [f8f1244]
+- Updated dependencies [dcf20cb]
+- Updated dependencies [6512384]
+- Updated dependencies [e3b4c14]
+- Updated dependencies [efd0ed1]
+- Updated dependencies [cba98fb]
+- Updated dependencies [ce96383]
+- Updated dependencies [f8f1244]
+- Updated dependencies [f8f1244]
+- Updated dependencies [6e93a35]
+- Updated dependencies [6dada45]
+  - @pikku/core@0.12.80
+
 ## 0.12.4
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 - present Yasser Fadl and Pikku contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,28 @@
-# @pikku/scheduler
+# @pikku/schedule
 
-This package is part of @pikku/mono and is responsible for scheduling tasks in pikku.
+In-memory scheduler service for Pikku cron wirings, built on `cron`.
+
+Runs jobs in the current process, so it suits single-instance deployments and
+local development. For multi-instance setups use a queue-backed scheduler such
+as `@pikku/queue-bullmq` or `@pikku/queue-pg-boss`.
+
+## Install
+
+```bash
+npm install @pikku/schedule
+```
+
+## Usage
+
+```typescript
+import { InMemorySchedulerService } from '@pikku/schedule'
+
+const scheduler = new InMemorySchedulerService(logger)
+
+await scheduler.init()
+scheduler.startAll()
+```
+
+## Docs
+
+https://pikku.dev/docs

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

@@ -1,7 +1,8 @@
 import { CronJob } from 'cron';
 import { SchedulerService, parseDurationString } from '@pikku/core';
-import { pikkuState } from '@pikku/core/internal';
+import { pikkuState, getSingletonServices } from '@pikku/core/ecosystem';
 import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler';
+import { rpcService } from '@pikku/core/rpc';
 const getLogger = () => {
     return pikkuState(null, 'package', 'singletonServices').logger;
 };
@@ -24,7 +25,23 @@ export class InMemorySchedulerService extends SchedulerService {
         const timer = setTimeout(async () => {
             this.delayedTasks.delete(taskId);
             try {
-                await runScheduledTask({ name: rpcName, session });
+                // An RPC, not a cron task. `runScheduledTask` looks the name up in the
+                // scheduler's task registry, which only ever holds wired cron tasks —
+                // so every internally-scheduled RPC died here as
+                // ScheduledTaskNotFoundError. The one that matters most is
+                // `pikkuWorkflowSleeper`: it is registered by the workflow service as a
+                // function, and it is what wakes a run from `workflow.sleep`. With the
+                // wake-up lost to a swallowed log line, an async workflow run stopped
+                // at its first sleep and stayed `running` forever.
+                //
+                // `data` has to be forwarded for the same reason. The sleeper is called
+                // with `{ runId, stepId }` and cannot identify the sleeping step
+                // without it — it was captured in `delayedTasks` but never passed on.
+                // This matches what the BullMQ and pg-boss schedulers already do:
+                // enqueue `{ rpcName, data, session }` and invoke the RPC with it.
+                const services = getSingletonServices();
+                const rpc = rpcService.getContextRPCService(services, {}, false);
+                await rpc.invoke(rpcName, data);
             }
             catch (err) {
                 getLogger().error(`Failed to execute delayed RPC '${rpcName}': ${err}`);

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@pikku/schedule",
-  "version": "0.12.4",
+  "version": "0.12.5",
+  "description": "In-memory scheduler service for Pikku cron wirings",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
   "module": "dist/index.js",
@@ -18,7 +19,7 @@
     "prepublishOnly": "yarn build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.58"
+    "@pikku/core": "^0.12.80"
   },
   "devDependencies": {
     "@types/node": "^24.11.0",

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

@@ -1,9 +1,19 @@
 import { describe, test } from 'node:test'
 import assert from 'node:assert/strict'
-import { pikkuState } from '@pikku/core/internal'
+import { pikkuState } from '@pikku/core/ecosystem'
+import { addFunction } from '@pikku/core/function'
 
 import { InMemorySchedulerService } from './in-memory-scheduler-service.js'
 
+const waitFor = async (predicate: () => boolean, withinMs = 2000) => {
+  const deadline = Date.now() + withinMs
+  while (Date.now() < deadline) {
+    if (predicate()) return true
+    await new Promise((resolve) => setTimeout(resolve, 10))
+  }
+  return false
+}
+
 describe('InMemorySchedulerService scheduleRPC', () => {
   test('schedules and executes delayed RPC', async () => {
     const logger = {
@@ -31,4 +41,54 @@ describe('InMemorySchedulerService scheduleRPC', () => {
       await scheduler.close()
     }
   })
+
+  /**
+   * The delay actually has to invoke the RPC, with its data.
+   *
+   * The test above only proved the task was registered, which is why the
+   * scheduler could dispatch through `runScheduledTask` — a lookup against the
+   * *cron task* registry that no scheduled RPC is ever in — and still pass.
+   * Every internally scheduled RPC failed with ScheduledTaskNotFoundError,
+   * `pikkuWorkflowSleeper` among them, so an async workflow never woke from
+   * `workflow.sleep`.
+   */
+  test('invokes the named RPC with its data once the delay elapses', async () => {
+    const errors: string[] = []
+    const logger = {
+      info: () => {},
+      warn: () => {},
+      debug: () => {},
+      error: (message: string) => errors.push(message),
+    }
+    pikkuState(null, 'package', 'singletonServices', { logger } as any)
+
+    const calls: unknown[] = []
+    addFunction(
+      'delayedTestRpc',
+      {
+        func: async (_services: any, data: unknown) => calls.push(data),
+      } as any,
+      null
+    )
+    pikkuState(null, 'function', 'meta')['delayedTestRpc'] = {
+      name: 'delayedTestRpc',
+      sessionless: true,
+      permissions: [],
+    } as any
+
+    const scheduler = new InMemorySchedulerService()
+    try {
+      await scheduler.scheduleRPC(20, 'delayedTestRpc', {
+        runId: 'run-1',
+        stepId: 'step-1',
+      })
+      assert.ok(
+        await waitFor(() => calls.length > 0),
+        `RPC was never invoked; scheduler errors: ${JSON.stringify(errors)}`
+      )
+      assert.deepEqual(calls[0], { runId: 'run-1', stepId: 'step-1' })
+    } finally {
+      await scheduler.close()
+    }
+  })
 })

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

@@ -5,8 +5,9 @@ import type {
   ScheduledTaskSummary,
 } from '@pikku/core'
 import { SchedulerService, parseDurationString } from '@pikku/core'
-import { pikkuState } from '@pikku/core/internal'
+import { pikkuState, getSingletonServices } from '@pikku/core/ecosystem'
 import { runScheduledTask, getScheduledTasks } from '@pikku/core/scheduler'
+import { rpcService } from '@pikku/core/rpc'
 
 interface DelayedTask {
   taskId: string
@@ -49,7 +50,27 @@ export class InMemorySchedulerService extends SchedulerService {
     const timer = setTimeout(async () => {
       this.delayedTasks.delete(taskId)
       try {
-        await runScheduledTask({ name: rpcName, session })
+        // An RPC, not a cron task. `runScheduledTask` looks the name up in the
+        // scheduler's task registry, which only ever holds wired cron tasks —
+        // so every internally-scheduled RPC died here as
+        // ScheduledTaskNotFoundError. The one that matters most is
+        // `pikkuWorkflowSleeper`: it is registered by the workflow service as a
+        // function, and it is what wakes a run from `workflow.sleep`. With the
+        // wake-up lost to a swallowed log line, an async workflow run stopped
+        // at its first sleep and stayed `running` forever.
+        //
+        // `data` has to be forwarded for the same reason. The sleeper is called
+        // with `{ runId, stepId }` and cannot identify the sleeping step
+        // without it — it was captured in `delayedTasks` but never passed on.
+        // This matches what the BullMQ and pg-boss schedulers already do:
+        // enqueue `{ rpcName, data, session }` and invoke the RPC with it.
+        const services = getSingletonServices()
+        const rpc = rpcService.getContextRPCService(
+          services as any,
+          {},
+          false
+        ) as { invoke: (name: string, data: unknown) => Promise<unknown> }
+        await rpc.invoke(rpcName, data)
       } catch (err: unknown) {
         getLogger().error(`Failed to execute delayed RPC '${rpcName}': ${err}`)
       }