@pikku/queue-bullmq 0.12.6 → 0.12.8

package/CHANGELOG.md

@@ -1,3 +1,135 @@
+## 0.12.8
+
+### Patch Changes
+
+- 4c7a1b5: Run the monorepo's own scripts through bun instead of yarn. What moves is the
+  package manager each package's `prepublishOnly` and build scripts invoke, plus
+  the two manifest fixes bun needs to resolve the tree: `uWebSockets.js` is
+  declared with an explicit `github:` specifier, and `@pikku/uws-handler` marks
+  its `uWebSockets.js` peer optional so a bun install of a consumer that brings
+  its own uWS app does not try to fetch it from the registry.
+
+  Three published behaviours change, all of them cases where an isolated
+  `node_modules` or bun as the runtime had been papered over by yarn's hoisting:
+
+  - `@pikku/migrator-sql` turns foreign keys on when it opens a sqlite database
+    through bun. `node:sqlite` enforces them by default and `bun:sqlite` does not,
+    which silently turned every `ON DELETE CASCADE` into a no-op under
+    `bunx --bun pikku`.
+  - `@pikku/cli` resolves a deploy provider against the project being deployed
+    rather than against wherever the CLI itself is installed, which is what its
+    own "is not installed" error asks the user to arrange.
+  - `@pikku/cli` treats a specifier a runtime hands straight back — bun does this
+    for the modules it implements itself — as not resolved from the project, so
+    it falls back rather than loading the runtime's own copy.
+
+- Updated dependencies [4c7a1b5]
+  - @pikku/core@0.12.108
+
+## 0.12.7
+
+### Patch Changes
+
+- 266e3bc: One door per name: `@pikku/core/ecosystem/*` and the package root are gone
+
+  `@pikku/core` published every module twice. `ecosystem/http` re-exported
+  `./http`, `ecosystem/services` re-exported `./services`, and a name was
+  reachable through either — so every addition had to be made in two places, and a
+  consumer's import said nothing about what it actually used. The package root was
+  the same problem at a larger scale: a single barrel of 206 names that no bundler
+  could take apart, and the one specifier that revealed nothing at all.
+
+  Both are deleted. Every name now lives on the subpath that owns it, and every
+  import carries that subpath — `@pikku/core/http`, `@pikku/core/services`,
+  `@pikku/core/errors`, `@pikku/core/types`.
+
+  Deleting the facades meant the raw subpaths had to become a superset of them,
+  which they were not: the facade tree had accumulated 25 names with no raw home
+  and about 26 more filed under a different area than the module they came from.
+  Those names moved to the area that owns them, and three areas were published as
+  new entry points rather than left on a root that is going away — `./types` (the
+  shared type surface, the largest single destination), `./state` and
+  `./classification`.
+
+  `./classification` is one door onto one subject: what a value is and how it must
+  be handled. Its three halves would each have been an entry point — the brands
+  and manifest types, the stored-form helpers (`hashToken`, `unsafeAsSealed` and
+  friends), and `SecretValue` — split by whether a name happens to be a type or a
+  value, which is the same defect as the facades. The duration and versioned-id
+  helpers went to `./utils`, which already published, and `PikkuRequest` went to
+  `./function`: it is the transport-agnostic request base, not an HTTP one — HTTP
+  has `PikkuHTTPAbstractRequest`, and the only thing outside core that extends
+  `PikkuRequest` is Azure's timer request.
+
+  `./types` inherited the root barrel's habit before it inherited its contents, so
+  the names with an owner elsewhere were moved off it. The middleware types and the
+  five middleware factories — `pikkuMiddleware`, `pikkuMiddlewareFactory`,
+  `pikkuChannelMiddleware`, `pikkuChannelMiddlewareFactory` and
+  `pikkuAgentMiddleware`, runtime values on a types entry point — are now
+  `@pikku/core/middleware`; the function meta types are `@pikku/core/function`;
+  `SerializedError` is `@pikku/core/errors`; and the generic TypeScript helpers
+  (`MakeRequired`, `PickRequired`, `PickOptional`, `RequireAtLeastOne`,
+  `JSONPrimitive`, `JSONValue`) are `@pikku/core/utils`. What is left on `./types`
+  is the vocabulary the wirings share, which no single module owns.
+
+  `pikku` was itself a root barrel — `export * from '@pikku/core'` — and
+  now exports only the services it bundles.
+
+  One module survives at the old specifier, and only for the bootstrap:
+  `packages/cli` is generated by the _published_ CLI pinned in its `build.sh`, and
+  that CLI still writes a bare `@pikku/core` into the files it generates for the
+  CLI itself. `bootstrap-compat/root.ts` carries the eight types it names, a test
+  in core fails if that list grows, and it goes when the pin moves to a CLI
+  released from this branch. The adapter names the pinned CLI reaches for —
+  `pikkuState` and `CreateWireServices` — are rewritten to `@pikku/core/state` and
+  `@pikku/core/types` by the same `build.sh` patch pass, so no second shim is
+  needed for them.
+
+  A guard test keeps the root shut: it parses imports and rejects a bare
+  `@pikku/core` rather than grepping for it, because several tests hold a user's
+  file as a template literal, where `import … from '@pikku/core'` is fixture text
+  rather than an import this repo makes.
+
+  An agent scaffold a project generated under an older CLI is refreshed rather
+  than left to fail: `pikku all` already deleted one importing an entry point
+  `@pikku/core` no longer publishes, and the `#pikku` hub joins that list.
+  Without it a project that scaffolds the agent endpoint but
+  declares no agents keeps the old file forever — the generator that would rewrite
+  it only runs when agents exist, and the file being present is what stops it
+  being regenerated as missing.
+
+  `pikku new addon` also wrote a tsconfig `paths` map naming only the deleted hub.
+  An addon's `imports` map points into `dist`, so `paths` is what resolves
+  `#pikku/<leaf>` for the addon's own source build — it now names the two leaf
+  patterns, in both the addon and its test harness.
+
+- 786dae5: Bump every dependency whose latest release is a major across the monorepo, and
+  port the code the majors broke: `cookie` 2's `parseCookie`/`stringifySetCookie`
+  API in `@pikku/core` and the three runtime HTTP adapters, and assistant-ui 0.15's
+  store client in `@pikku/assistant-ui`.
+- 6eef0a0: Bump every dependency to its latest compatible minor/patch across the monorepo.
+- Updated dependencies [7722ceb]
+- Updated dependencies [375c1ff]
+- Updated dependencies [02a70cd]
+- Updated dependencies [aeef159]
+- Updated dependencies [a281de6]
+- Updated dependencies [266e3bc]
+- Updated dependencies [02a70cd]
+- Updated dependencies [786dae5]
+- Updated dependencies [6eef0a0]
+- Updated dependencies [3561d67]
+- Updated dependencies [a91c433]
+- Updated dependencies [02a70cd]
+- Updated dependencies [9537f74]
+- Updated dependencies [2b57ca8]
+- Updated dependencies [266e3bc]
+- Updated dependencies [9fce0f1]
+- Updated dependencies [83683a0]
+- Updated dependencies [456c88b]
+- Updated dependencies [456c88b]
+- Updated dependencies [c127273]
+  - @pikku/core@0.12.85
+
 ## 0.12.6
 
 ### Patch Changes

package/dist/bull-queue-service.d.ts

@@ -1,7 +1,8 @@
 import type { ConnectionOptions, JobsOptions } from 'bullmq';
 import type Bull from 'bullmq';
-import type { QueueService, QueueJob } from '@pikku/core/queue';
-import type { JobOptions } from '@pikku/core/ecosystem/queue';
+import { Queue, QueueEvents } from 'bullmq';
+import type { QueueJob, QueueService } from '@pikku/core/queue';
+import type { JobOptions } from '@pikku/core/queue';
 export declare const mapPikkuJobToBull: (options?: JobOptions) => JobsOptions;
 /**
  * Bull/Redis queue service implementation
@@ -11,8 +12,8 @@ export declare class BullQueueService implements QueueService {
     private redisConnectionOptions;
     readonly name = "bull";
     readonly supportsResults = true;
-    protected queues: Map<string, Bull.Queue<any, any, string, any, any, string>>;
-    protected queueEvents: Map<string, Bull.QueueEvents>;
+    protected queues: Map<string, Queue<any, any, string, any, any, string, Bull.RedisQueueBackend>>;
+    protected queueEvents: Map<string, QueueEvents<any>>;
     constructor(redisConnectionOptions?: ConnectionOptions);
     /**
      * Create a Bull queue with translated configuration

package/dist/bull-queue-service.js

@@ -1,4 +1,4 @@
-import { Queue, QueueEvents, RedisConnection } from 'bullmq';
+import { Queue, QueueEvents } from 'bullmq';
 import { mapBullJobToQueueJob } from './utils.js';
 export const mapPikkuJobToBull = (options) => {
     const bullOptions = {};
@@ -30,14 +30,6 @@ export const mapPikkuJobToBull = (options) => {
     }
     return bullOptions;
 };
-class PikkuRedisConnection extends RedisConnection {
-    constructor(options) {
-        super(options);
-        this.on('error', (error) => {
-            console.error('Redis connection error:', error);
-        });
-    }
-}
 /**
  * Bull/Redis queue service implementation
  * Supports job results, retries, and most queue features
@@ -58,7 +50,10 @@ export class BullQueueService {
         if (this.queues.has(queueName)) {
             return this.queues.get(queueName);
         }
-        const queue = new Queue(queueName, config, PikkuRedisConnection);
+        const queue = new Queue(queueName, config);
+        queue.on('error', (error) => {
+            console.error('Redis connection error:', error);
+        });
         await queue.waitUntilReady();
         this.queues.set(queueName, queue);
         if (!this.queueEvents.has(queueName)) {

package/dist/bull-queue-worker.d.ts

@@ -1,6 +1,6 @@
 import type { ConnectionOptions, WorkerOptions } from 'bullmq';
-import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/ecosystem/queue';
-export declare const mapPikkuWorkerToBull: (workerConfig?: PikkuWorkerConfig) => Omit<WorkerOptions, "connection">;
+import type { QueueWorkers, PikkuWorkerConfig, QueueConfigMapping, ConfigValidationResult } from '@pikku/core/queue';
+export declare const mapPikkuWorkerToBull: (workerConfig?: PikkuWorkerConfig) => Omit<WorkerOptions, 'connection'>;
 /**
  * Bull/Redis queue service implementation
  * Supports job results, retries, and most queue features

package/dist/bull-queue-worker.js

@@ -1,7 +1,7 @@
 import { Worker } from 'bullmq';
 import { runQueueJob } from '@pikku/core/queue';
-import { registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/ecosystem/queue';
-import { pikkuState } from '@pikku/core/ecosystem';
+import { registerQueueWorkers, QueueJobFailedError, QueueJobDiscardedError, } from '@pikku/core/queue';
+import { pikkuState } from '@pikku/core/state';
 import { mapBullJobToQueueJob } from './utils.js';
 export const mapPikkuWorkerToBull = (workerConfig) => {
     const workerOptions = {};

package/dist/bull-scheduler-service.d.ts

@@ -1,13 +1,13 @@
 import type { ConnectionOptions } from 'bullmq';
-import type { CoreUserSession } from '@pikku/core';
-import type { ScheduledTaskInfo, ScheduledTaskSummary } from '@pikku/core/ecosystem/services';
-import { SchedulerService } from '@pikku/core';
+import { SchedulerService } from '@pikku/core/services';
+import type { CoreUserSession } from '@pikku/core/types';
+import type { ScheduledTaskInfo, ScheduledTaskSummary } from '@pikku/core/services';
 export declare class BullSchedulerService extends SchedulerService {
     private redisConnectionOptions;
     private queue;
     private recurringQueue;
     private recurringWorker?;
-    private repeatJobKeys;
+    private jobSchedulerIds;
     constructor(redisConnectionOptions: ConnectionOptions);
     /**
      * Initialize - wait for queue to be ready
@@ -40,7 +40,7 @@ export declare class BullSchedulerService extends SchedulerService {
      */
     start(): Promise<void>;
     /**
-     * Stop recurring scheduled tasks by removing repeat jobs.
+     * Stop recurring scheduled tasks by removing their job schedulers.
      */
     stop(): Promise<void>;
 }

package/dist/bull-scheduler-service.js

@@ -1,16 +1,16 @@
 import { Queue, Worker } from 'bullmq';
-import { SchedulerService } from '@pikku/core';
-import { parseDurationString } from '@pikku/core/ecosystem/types';
-import { pikkuState } from '@pikku/core/ecosystem';
 import { runScheduledTask } from '@pikku/core/scheduler';
-import { getScheduledTasks } from '@pikku/core/ecosystem/scheduler';
+import { SchedulerService } from '@pikku/core/services';
+import { parseDurationString } from '@pikku/core/utils';
+import { pikkuState } from '@pikku/core/state';
+import { getScheduledTasks } from '@pikku/core/scheduler';
 const RECURRING_QUEUE_NAME = 'pikku-recurring-scheduled-task';
 export class BullSchedulerService extends SchedulerService {
     redisConnectionOptions;
     queue;
     recurringQueue;
     recurringWorker;
-    repeatJobKeys = [];
+    jobSchedulerIds = [];
     constructor(redisConnectionOptions) {
         super();
         this.redisConnectionOptions = redisConnectionOptions;
@@ -127,23 +127,19 @@ export class BullSchedulerService extends SchedulerService {
             logger.error(`Recurring task worker error: ${err}`);
         });
         for (const [name, task] of scheduledTasks) {
-            const job = await this.recurringQueue.add(name, { rpcName: name }, {
-                repeat: { pattern: task.schedule },
-                jobId: `recurring:${name}`,
-            });
-            if (job.repeatJobKey) {
-                this.repeatJobKeys.push(job.repeatJobKey);
-            }
+            const jobSchedulerId = `recurring:${name}`;
+            await this.recurringQueue.upsertJobScheduler(jobSchedulerId, { pattern: task.schedule }, { name, data: { rpcName: name } });
+            this.jobSchedulerIds.push(jobSchedulerId);
         }
     }
     /**
-     * Stop recurring scheduled tasks by removing repeat jobs.
+     * Stop recurring scheduled tasks by removing their job schedulers.
      */
     async stop() {
-        for (const key of this.repeatJobKeys) {
-            await this.recurringQueue.removeRepeatableByKey(key);
+        for (const id of this.jobSchedulerIds) {
+            await this.recurringQueue.removeJobScheduler(id);
         }
-        this.repeatJobKeys = [];
+        this.jobSchedulerIds = [];
         if (this.recurringWorker) {
             await this.recurringWorker.close();
             this.recurringWorker = undefined;

package/dist/index.d.ts

@@ -8,5 +8,5 @@ export { BullServiceFactory } from './bull-service-factory.js';
 export { BullQueueService } from './bull-queue-service.js';
 export { BullQueueWorkers } from './bull-queue-worker.js';
 export { BullSchedulerService } from './bull-scheduler-service.js';
-export type { QueueService, QueueJob } from '@pikku/core/queue';
-export type { PikkuWorkerConfig, PikkuJobConfig, JobOptions, } from '@pikku/core/ecosystem/queue';
+export type { QueueJob, QueueService } from '@pikku/core/queue';
+export type { PikkuWorkerConfig, PikkuJobConfig, JobOptions, } from '@pikku/core/queue';

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "@pikku/queue-bullmq",
-  "version": "0.12.6",
+  "version": "0.12.8",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pikkujs/pikku.git",
+    "directory": "packages/services/queue-bullmq"
+  },
   "description": "BullMQ queue, worker and scheduler services for Pikku",
   "author": "yasser.fadl@gmail.com",
   "license": "MIT",
@@ -13,17 +18,14 @@
     "ncu": "npx npm-check-updates",
     "build": "tsc -b",
     "release": "npm run build && npm test",
-    "prepublishOnly": "yarn build"
+    "prepublishOnly": "bun run build"
   },
   "peerDependencies": {
-    "@pikku/core": "^0.12.84"
+    "@pikku/core": "^0.12.108"
   },
   "dependencies": {
-    "bullmq": "^5.70.1",
-    "ioredis": "^5.10.0"
-  },
-  "devDependencies": {
-    "typescript": "^6.0.3"
+    "bullmq": "^6.1.1",
+    "ioredis": "^6.0.0"
   },
   "exports": {
     ".": "./dist/index.js"

package/run-tests.sh

@@ -1,8 +1,5 @@
 #!/bin/bash
 
-script_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-cd "$script_dir"
-
 # Enable nullglob to handle cases where no files match the pattern
 shopt -s nullglob
 
@@ -37,20 +34,35 @@ files=($(find src -type f -name "*.test.ts"))
 # Check if any files matched the pattern
 if [ ${#files[@]} -eq 0 ]; then
   echo "No test files found matching pattern: $pattern"
+  if [ "${STRICT_TEST_DISCOVERY}" = "1" ]; then
+    exit 1
+  fi
   exit 0
 fi
 
-# Construct the node command
-node_cmd=(node --import tsx --test)
+# Construct the bun command
+#
+# --parallel gives every test file its own worker process, which is what node's
+# `--test` did. Several suites keep module-level caches (a TypeScript program, a
+# temp fixture directory) that a shared process would leak between files.
+#
+# --timeout because bun caps a test at 5s by default where node had no cap, and
+# the suites that build real TypeScript programs run well past that.
+bun_cmd=(bun test --parallel --timeout 120000)
 
 # Append options based on flags
 if [ "$watch_mode" = true ]; then
-  node_cmd+=(--watch)
+  # --watch reruns in one process; parallel workers have nothing to watch.
+  bun_cmd=(bun test --watch --timeout 120000)
 fi
 
 if [ "$coverage_mode" = true ]; then
-  node_cmd+=(--test-coverage-include="src/**/*.{ts,js}" --test-coverage-exclude="**/dist/**" --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=lcov.info)
+  # --coverage-dir=. keeps lcov.info at the package root: CI merges every
+  # package's report by prefixing its SF paths with the file's own directory,
+  # so a nested coverage/ directory would re-root them one level too deep.
+  bun_cmd+=(--coverage --coverage-reporter=lcov --coverage-reporter=text --coverage-dir=.)
+  export PIKKU_TEST_COVERAGE=1
 fi
 
-# Execute the node command with the expanded list of files
-"${node_cmd[@]}" "${files[@]}"
+# Execute the bun command with the expanded list of files
+"${bun_cmd[@]}" "${files[@]}"

package/src/bull-queue-service.test.ts

@@ -1,36 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { mapPikkuJobToBull } from './bull-queue-service.js'
-
-// Same contract as the pg-boss adapter: the workflow's resolved retry policy
-// (attempts + backoff) must reach BullMQ. backoff mapping in particular was
-// previously dropped, so a step's backoff silently never applied on Redis.
-describe('mapPikkuJobToBull — retry mapping', () => {
-  test('attempts passes through unchanged (BullMQ uses attempts directly)', () => {
-    assert.equal(mapPikkuJobToBull({ attempts: 6 }).attempts, 6)
-    assert.equal(mapPikkuJobToBull({ attempts: 1 }).attempts, 1)
-  })
-
-  test("string backoff 'exponential' → { type: 'exponential' }", () => {
-    assert.deepEqual(mapPikkuJobToBull({ attempts: 6, backoff: 'exponential' }).backoff, {
-      type: 'exponential',
-    })
-  })
-
-  test('object backoff → { type, delay } (delay stays in ms)', () => {
-    assert.deepEqual(
-      mapPikkuJobToBull({ attempts: 4, backoff: { type: 'fixed', delay: 250 } })
-        .backoff,
-      { type: 'fixed', delay: 250 }
-    )
-  })
-
-  test('no backoff → backoff left unset', () => {
-    assert.equal(mapPikkuJobToBull({ attempts: 6 }).backoff, undefined)
-  })
-
-  test('no options → empty job options', () => {
-    assert.deepEqual(mapPikkuJobToBull(undefined), {})
-  })
-})

package/src/bull-queue-service.ts

@@ -1,137 +0,0 @@
-import type { ConnectionOptions, JobsOptions } from 'bullmq'
-import type Bull from 'bullmq'
-import { Queue, QueueEvents, RedisConnection } from 'bullmq'
-import type { QueueService, QueueJob } from '@pikku/core/queue'
-import type { JobOptions } from '@pikku/core/ecosystem/queue'
-import { mapBullJobToQueueJob } from './utils.js'
-
-export const mapPikkuJobToBull = (options?: JobOptions): JobsOptions => {
-  const bullOptions: JobsOptions = {}
-
-  if (options?.priority !== undefined) {
-    bullOptions.priority = options.priority
-  }
-
-  if (options?.delay !== undefined) {
-    bullOptions.delay = options.delay
-  }
-
-  if (options?.attempts !== undefined) {
-    bullOptions.attempts = options.attempts
-  }
-
-  // Map retry backoff. BullMQ accepts `{ type, delay }`; our `delay` is in ms,
-  // which is what BullMQ expects too (unlike pg-boss, which uses seconds).
-  if (options?.backoff !== undefined) {
-    bullOptions.backoff =
-      typeof options.backoff === 'string'
-        ? { type: options.backoff }
-        : { type: options.backoff.type, delay: options.backoff.delay }
-  }
-
-  if (options?.removeOnComplete !== undefined) {
-    bullOptions.removeOnComplete = options.removeOnComplete
-  }
-
-  if (options?.removeOnFail !== undefined) {
-    bullOptions.removeOnFail = options.removeOnFail
-  }
-
-  if (options?.jobId !== undefined) {
-    bullOptions.jobId = options.jobId
-  }
-
-  return bullOptions
-}
-
-class PikkuRedisConnection extends RedisConnection {
-  constructor(options: ConnectionOptions) {
-    super(options)
-    this.on('error', (error) => {
-      console.error('Redis connection error:', error)
-    })
-  }
-}
-
-/**
- * Bull/Redis queue service implementation
- * Supports job results, retries, and most queue features
- */
-export class BullQueueService implements QueueService {
-  readonly name = 'bull'
-  readonly supportsResults = true
-  protected queues = new Map<string, Bull.Queue>()
-  protected queueEvents = new Map<string, Bull.QueueEvents>()
-
-  constructor(private redisConnectionOptions: ConnectionOptions = {}) {}
-
-  /**
-   * Create a Bull queue with translated configuration
-   */
-  protected async createQueue(
-    queueName: string,
-    config?: Bull.QueueOptions
-  ): Promise<Bull.Queue> {
-    if (this.queues.has(queueName)) {
-      return this.queues.get(queueName)!
-    }
-
-    const queue = new Queue(queueName, config, PikkuRedisConnection)
-    await queue.waitUntilReady()
-
-    this.queues.set(queueName, queue)
-
-    if (!this.queueEvents.has(queueName)) {
-      const queueEvents = new QueueEvents(
-        queueName,
-        this.redisConnectionOptions
-          ? { connection: this.redisConnectionOptions }
-          : undefined
-      )
-      await queueEvents.waitUntilReady()
-      this.queueEvents.set(queueName, queueEvents)
-    }
-
-    return queue
-  }
-
-  /**
-   * Add a job to the queue
-   */
-  public async add<In>(
-    queueName: string,
-    data: In,
-    options?: JobOptions
-  ): Promise<string> {
-    const queue = await this.createQueue(queueName)
-    const bullJob = await queue.add(queueName, data, mapPikkuJobToBull(options))
-    if (!bullJob.id) {
-      throw new Error(`Failed to add job to queue '${queueName}'.`)
-    }
-    return bullJob.id
-  }
-
-  /**
-   * Get job by ID
-   */
-  async getJob<T, R>(
-    queueName: string,
-    jobId: string
-  ): Promise<QueueJob<T, R> | null> {
-    const queue = this.queues.get(queueName)
-    if (!queue) {
-      throw new Error(`Queue '${queueName}' not found.`)
-    }
-
-    const bullJob = await queue.getJob(jobId)
-    if (!bullJob) {
-      return null
-    }
-
-    return mapBullJobToQueueJob<T, R>(
-      bullJob,
-      this.redisConnectionOptions,
-      this.queueEvents
-    )
-  }
-}

package/src/bull-queue-worker.test.ts

@@ -1,15 +0,0 @@
-import { describe, test } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { BullQueueWorkers } from './bull-queue-worker.js'
-
-describe('BullQueueWorkers', () => {
-  test('requires a logger (explicit or from singleton services)', async () => {
-    const workers = new BullQueueWorkers({})
-
-    await assert.rejects(() => workers.registerQueues(), {
-      message:
-        'Logger is required for registerQueues — pass it explicitly or ensure singleton services are initialized first',
-    })
-  })
-})

package/src/bull-queue-worker.ts

@@ -1,209 +0,0 @@
-import type { ConnectionOptions, WorkerOptions, QueueEvents } from 'bullmq'
-import type Bull from 'bullmq'
-import { Worker } from 'bullmq'
-import type {
-  QueueWorkers,
-  PikkuWorkerConfig,
-  QueueConfigMapping,
-  ConfigValidationResult,
-} from '@pikku/core/ecosystem/queue'
-import { runQueueJob } from '@pikku/core/queue'
-import {
-  registerQueueWorkers,
-  QueueJobFailedError,
-  QueueJobDiscardedError,
-} from '@pikku/core/ecosystem/queue'
-import { pikkuState } from '@pikku/core/ecosystem'
-import { mapBullJobToQueueJob } from './utils.js'
-
-export const mapPikkuWorkerToBull = (
-  workerConfig?: PikkuWorkerConfig
-): Omit<WorkerOptions, 'connection'> => {
-  const workerOptions: Omit<WorkerOptions, 'connection'> = {}
-
-  // Direct mappings
-  if (workerConfig?.name !== undefined) {
-    workerOptions.name = workerConfig.name
-  }
-
-  if (workerConfig?.batchSize !== undefined) {
-    workerOptions.concurrency = workerConfig.batchSize
-  }
-
-  if (workerConfig?.autorun !== undefined) {
-    workerOptions.autorun = workerConfig.autorun
-  }
-
-  if (workerConfig?.lockDuration !== undefined) {
-    workerOptions.lockDuration = workerConfig.lockDuration
-  }
-
-  if (workerConfig?.drainDelay !== undefined) {
-    workerOptions.drainDelay = workerConfig.drainDelay
-  }
-
-  if (workerConfig?.maxStalledCount !== undefined) {
-    workerOptions.maxStalledCount = workerConfig.maxStalledCount
-  }
-
-  // Job retention
-  if (workerConfig?.removeOnComplete !== undefined) {
-    workerOptions.removeOnComplete = { count: workerConfig.removeOnComplete }
-  }
-
-  if (workerConfig?.removeOnFail !== undefined) {
-    workerOptions.removeOnFail = { count: workerConfig.removeOnFail }
-  }
-
-  return workerOptions
-}
-
-/**
- * Bull/Redis queue service implementation
- * Supports job results, retries, and most queue features
- */
-export class BullQueueWorkers implements QueueWorkers {
-  readonly name = 'bull'
-  readonly supportsResults = true
-
-  /**
-   * Configuration mapping rules for BullMQ
-   * This defines how Pikku worker configs map to BullMQ configurations
-   */
-  readonly configMappings: QueueConfigMapping = {
-    // Configurations that are directly supported
-    supported: {
-      name: {
-        queueProperty: 'name',
-        description: 'Worker name for identification and monitoring',
-      },
-      batchSize: {
-        queueProperty: 'concurrency',
-        description:
-          "Number of jobs to process concurrently, this is Bull's concurrency setting",
-      },
-      autorun: {
-        queueProperty: 'autorun',
-        description: 'Whether to start processing jobs automatically',
-      },
-      lockDuration: {
-        queueProperty: 'lockDuration',
-        description: 'Duration of job lock in milliseconds',
-      },
-      drainDelay: {
-        queueProperty: 'drainDelay',
-        description: 'Delay when queue is empty before polling again',
-      },
-      maxStalledCount: {
-        queueProperty: 'maxStalledCount',
-        description:
-          'Maximum number of times a job can be recovered from stalled state',
-      },
-      removeOnComplete: {
-        queueProperty: 'removeOnComplete',
-        description: 'Number of completed jobs to keep for inspection',
-      },
-      removeOnFail: {
-        queueProperty: 'removeOnFail',
-        description: 'Number of failed jobs to keep for inspection',
-      },
-    },
-
-    // Configurations that are not supported
-    unsupported: {
-      groupConcurrency: {
-        reason: 'Job groups are a BullMQ Pro feature, not available in BullMQ',
-        explanation:
-          'Give each group its own queue instead — BullMQ is push-based, so extra queues cost no polling',
-      },
-      visibilityTimeout: {
-        reason: 'Bull does not use visibility timeout',
-        explanation:
-          'BullMQ locks jobs during processing instead of using visibility timeouts',
-      },
-      pollInterval: {
-        reason: 'Bull is push-based and does not use polling intervals',
-        explanation:
-          'BullMQ uses Redis pub/sub for real-time job notifications',
-      },
-      prefetch: {
-        reason: 'Bull manages job prefetching internally',
-        explanation:
-          'BullMQ optimizes job fetching automatically based on concurrency settings',
-      },
-    },
-
-    // No fallback configurations for BullMQ currently
-    fallbacks: {},
-  }
-
-  private workers = new Map<string, Bull.Worker>()
-  private queueEvents = new Map<string, QueueEvents>()
-
-  constructor(private redisConnectionOptions: ConnectionOptions) {}
-
-  /**
-   * Scan state and register all compatible processors
-   */
-  async registerQueues(): Promise<Record<string, ConfigValidationResult[]>> {
-    const logger = pikkuState(null, 'package', 'singletonServices')?.logger
-    if (!logger) {
-      throw new Error(
-        'Logger is required for registerQueues — pass it explicitly or ensure singleton services are initialized first'
-      )
-    }
-
-    return await registerQueueWorkers(
-      this.configMappings,
-      logger,
-      async (queueName, processor) => {
-        const worker = new Worker(
-          processor.name,
-          async (job: Bull.Job) => {
-            try {
-              return await runQueueJob({
-                job: await mapBullJobToQueueJob(
-                  job,
-                  this.redisConnectionOptions,
-                  this.queueEvents
-                ),
-                updateProgress: async (progress) => {
-                  await job.updateProgress(progress)
-                },
-              })
-            } catch (error) {
-              if (error instanceof QueueJobFailedError) {
-                // Let BullMQ handle this as a failed job
-                throw new Error(error.message)
-              } else if (error instanceof QueueJobDiscardedError) {
-                return // Don't throw, job is discarded, which I guess is considered
-                // a successful job removal
-              }
-              throw error
-            }
-          },
-          {
-            connection: this.redisConnectionOptions,
-            ...mapPikkuWorkerToBull(processor.config),
-          }
-        )
-        worker.on('error', console.error)
-        this.workers.set(queueName, worker)
-      }
-    )
-  }
-
-  /**
-   * Close all queues and connections
-   */
-  async close(): Promise<void> {
-    await Promise.all([
-      ...Array.from(this.workers.values()).map((worker) => worker.close()),
-      ...Array.from(this.queueEvents.values()).map((queueEvents) =>
-        queueEvents.close()
-      ),
-    ])
-    this.workers.clear()
-    this.queueEvents.clear()
-  }
-}

package/src/bull-scheduler-service.ts

@@ -1,202 +0,0 @@
-import type { ConnectionOptions } from 'bullmq'
-import { Queue, Worker } from 'bullmq'
-import type { CoreUserSession } from '@pikku/core'
-import type {
-  ScheduledTaskInfo,
-  ScheduledTaskSummary,
-} from '@pikku/core/ecosystem/services'
-import { SchedulerService } from '@pikku/core'
-import { parseDurationString } from '@pikku/core/ecosystem/types'
-import { pikkuState } from '@pikku/core/ecosystem'
-import { runScheduledTask } from '@pikku/core/scheduler'
-import { getScheduledTasks } from '@pikku/core/ecosystem/scheduler'
-
-/**
- * Data stored in scheduled job
- */
-interface ScheduledJobData {
-  rpcName: string
-  data?: any
-  session?: CoreUserSession
-}
-
-const RECURRING_QUEUE_NAME = 'pikku-recurring-scheduled-task'
-
-export class BullSchedulerService extends SchedulerService {
-  private queue: Queue
-  private recurringQueue: Queue
-  private recurringWorker?: Worker
-  private repeatJobKeys: string[] = []
-
-  constructor(private redisConnectionOptions: ConnectionOptions) {
-    super()
-    this.queue = new Queue('pikku-remote-internal-rpc', {
-      connection: redisConnectionOptions,
-    })
-    this.recurringQueue = new Queue(RECURRING_QUEUE_NAME, {
-      connection: redisConnectionOptions,
-    })
-  }
-
-  /**
-   * Initialize - wait for queue to be ready
-   */
-  async init(): Promise<void> {
-    await this.queue.waitUntilReady()
-  }
-
-  /**
-   * Schedule a one-off delayed RPC call
-   * Uses BullMQ add() with delay option
-   */
-  async scheduleRPC(
-    delay: number | string,
-    rpcName: string,
-    data?: any,
-    session?: CoreUserSession
-  ): Promise<string> {
-    // Parse delay if it's a string
-    const delayMs =
-      typeof delay === 'string' ? parseDurationString(delay) : delay
-
-    const jobData: ScheduledJobData = {
-      rpcName,
-      data,
-      session,
-    }
-
-    // Use add() with delay for one-off delayed execution
-    const job = await this.queue.add('pikku-remote-internal-rpc', jobData, {
-      delay: delayMs, // delay in milliseconds
-      jobId: `${rpcName}-${Date.now()}`, // Ensure uniqueness
-    })
-
-    if (!job.id) {
-      throw new Error('Failed to schedule RPC')
-    }
-
-    return job.id
-  }
-
-  /**
-   * Unschedule (remove) a task by ID
-   */
-  async unschedule(taskId: string): Promise<boolean> {
-    const job = await this.queue.getJob(taskId)
-    if (job) {
-      await job.remove()
-      return true
-    }
-    return false
-  }
-
-  /**
-   * Get a scheduled task by ID with full details
-   */
-  async getTask(taskId: string): Promise<ScheduledTaskInfo | null> {
-    const job = await this.queue.getJob(taskId)
-
-    if (!job) {
-      return null
-    }
-
-    const jobData = job.data as ScheduledJobData
-    const state = await job.getState()
-
-    // Calculate scheduled time from delay or processedOn
-    const scheduledFor = job.delay
-      ? new Date(job.timestamp + job.delay)
-      : new Date(job.timestamp)
-
-    return {
-      taskId: job.id!,
-      rpcName: jobData.rpcName,
-      scheduledFor,
-      data: jobData.data,
-      session: jobData.session,
-      status: state as any,
-    }
-  }
-
-  /**
-   * Get all scheduled tasks with minimal info
-   */
-  async getAllTasks(): Promise<ScheduledTaskSummary[]> {
-    const jobs = await this.queue.getJobs(['delayed', 'waiting'])
-
-    return jobs.map((job) => {
-      const jobData = job.data as ScheduledJobData
-      const scheduledFor = job.delay
-        ? new Date(job.timestamp + job.delay)
-        : new Date(job.timestamp)
-
-      return {
-        taskId: job.id!,
-        rpcName: jobData.rpcName,
-        scheduledFor,
-      }
-    })
-  }
-
-  /**
-   * Close the queue connection
-   */
-  async close(): Promise<void> {
-    if (this.recurringWorker) {
-      await this.recurringWorker.close()
-    }
-    await this.recurringQueue.close()
-    await this.queue.close()
-  }
-
-  /**
-   * Start recurring scheduled tasks.
-   * Creates a BullMQ Worker to process repeat jobs via runScheduledTask.
-   */
-  async start(): Promise<void> {
-    const logger = pikkuState(null, 'package', 'singletonServices')!.logger
-    const scheduledTasks = getScheduledTasks()
-
-    // Create a worker to process recurring scheduled task jobs
-    this.recurringWorker = new Worker(
-      RECURRING_QUEUE_NAME,
-      async (job) => {
-        const { rpcName } = job.data as ScheduledJobData
-        logger.info(`Running scheduled task: ${rpcName}`)
-        await runScheduledTask({ name: rpcName })
-      },
-      { connection: this.redisConnectionOptions }
-    )
-    this.recurringWorker.on('error', (err) => {
-      logger.error(`Recurring task worker error: ${err}`)
-    })
-
-    for (const [name, task] of scheduledTasks) {
-      const job = await this.recurringQueue.add(
-        name,
-        { rpcName: name } as ScheduledJobData,
-        {
-          repeat: { pattern: task.schedule },
-          jobId: `recurring:${name}`,
-        }
-      )
-      if (job.repeatJobKey) {
-        this.repeatJobKeys.push(job.repeatJobKey)
-      }
-    }
-  }
-
-  /**
-   * Stop recurring scheduled tasks by removing repeat jobs.
-   */
-  async stop(): Promise<void> {
-    for (const key of this.repeatJobKeys) {
-      await this.recurringQueue.removeRepeatableByKey(key)
-    }
-    this.repeatJobKeys = []
-    if (this.recurringWorker) {
-      await this.recurringWorker.close()
-      this.recurringWorker = undefined
-    }
-  }
-}

package/src/bull-service-factory.ts

@@ -1,83 +0,0 @@
-import type { ConnectionOptions } from 'bullmq'
-import { BullQueueService } from './bull-queue-service.js'
-import { BullQueueWorkers } from './bull-queue-worker.js'
-import { BullSchedulerService } from './bull-scheduler-service.js'
-
-/**
- * Factory class for BullMQ services
- * Manages Redis connection options shared across queue, worker, and scheduler services
- */
-export class BullServiceFactory {
-  private queueService?: BullQueueService
-  private queueWorkers?: BullQueueWorkers
-  private schedulerService?: BullSchedulerService
-
-  constructor(private redisConnectionOptions: ConnectionOptions = {}) {}
-
-  /**
-   * Initialize - no-op for BullMQ as connections are lazy
-   */
-  async init(): Promise<void> {
-    // No-op - BullMQ creates connections lazily
-  }
-
-  /**
-   * Get the queue service for publishing jobs
-   */
-  getQueueService(): BullQueueService {
-    if (!this.queueService) {
-      this.queueService = new BullQueueService(this.redisConnectionOptions)
-    }
-    return this.queueService
-  }
-
-  /**
-   * Get the queue workers for processing jobs
-   */
-  getQueueWorkers(): BullQueueWorkers {
-    if (!this.queueWorkers) {
-      this.queueWorkers = new BullQueueWorkers(this.redisConnectionOptions)
-    }
-    return this.queueWorkers
-  }
-
-  /**
-   * Get the scheduler service for managing delayed tasks
-   */
-  getSchedulerService(): BullSchedulerService {
-    if (!this.schedulerService) {
-      this.schedulerService = new BullSchedulerService(
-        this.redisConnectionOptions
-      )
-    }
-    return this.schedulerService
-  }
-
-  /**
-   * Close all services
-   */
-  async close(): Promise<void> {
-    const closePromises: Promise<void>[] = []
-
-    if (this.queueService) {
-      // BullQueueService doesn't have close method currently
-    }
-
-    if (this.queueWorkers) {
-      closePromises.push(this.queueWorkers.close())
-    }
-
-    if (this.schedulerService) {
-      closePromises.push(this.schedulerService.close())
-    }
-
-    await Promise.all(closePromises)
-  }
-
-  /**
-   * Alias for close() - used by stopSingletonServices
-   */
-  async stop(): Promise<void> {
-    await this.close()
-  }
-}

package/src/index.ts

@@ -1,19 +0,0 @@
-/**
- * @module @pikku/queue-bullmq
- *
- * Bull/Redis queue service for Pikku
- * Provides job results, retries, priorities, and most queue features
- */
-
-export { BullServiceFactory } from './bull-service-factory.js'
-export { BullQueueService } from './bull-queue-service.js'
-export { BullQueueWorkers } from './bull-queue-worker.js'
-export { BullSchedulerService } from './bull-scheduler-service.js'
-
-// Re-export core queue types for convenience
-export type { QueueService, QueueJob } from '@pikku/core/queue'
-export type {
-  PikkuWorkerConfig,
-  PikkuJobConfig,
-  JobOptions,
-} from '@pikku/core/ecosystem/queue'

package/src/utils.ts

@@ -1,66 +0,0 @@
-import type { QueueJob, QueueJobStatus } from '@pikku/core/queue'
-import type { ConnectionOptions, Job } from 'bullmq'
-import { QueueEvents } from 'bullmq'
-
-/**
- * Map Bull job state to our queue job status
- */
-const mapBullStateToStatus = (state: string): QueueJobStatus => {
-  switch (state) {
-    case 'waiting':
-      return 'waiting'
-    case 'active':
-      return 'active'
-    case 'completed':
-      return 'completed'
-    case 'failed':
-      return 'failed'
-    case 'delayed':
-      return 'delayed'
-    default:
-      return 'waiting'
-  }
-}
-
-/**
- * Map Bull job to QueueJob interface
- */
-export const mapBullJobToQueueJob = async <In, Out>(
-  bullJob: Job,
-  redisConnection: ConnectionOptions | undefined,
-  queueEventsMap: Map<string, QueueEvents>
-): Promise<QueueJob<In, Out>> => {
-  return {
-    queueName: bullJob.name,
-    id: bullJob.id || '',
-    data: bullJob.data,
-    result: bullJob.returnvalue as Out,
-    status: async () => mapBullStateToStatus(await bullJob.getState()),
-    waitForCompletion: async (ttl?: number): Promise<Out> => {
-      let queueEvents = queueEventsMap.get(bullJob.queueName)
-      if (!queueEvents) {
-        queueEvents = new QueueEvents(
-          bullJob.queueName,
-          redisConnection ? { connection: redisConnection } : undefined
-        )
-        queueEventsMap.set(bullJob.queueName, queueEvents)
-        await queueEvents.waitUntilReady()
-      }
-      return await bullJob.waitUntilFinished(queueEvents, ttl)
-    },
-    metadata: () => ({
-      progress: bullJob.progress,
-      attemptsMade: bullJob.attemptsMade,
-      maxAttempts: bullJob.opts.attempts || 1,
-      createdAt: new Date(bullJob.timestamp),
-      processedAt: bullJob.processedOn
-        ? new Date(bullJob.processedOn)
-        : undefined,
-      completedAt: bullJob.finishedOn
-        ? new Date(bullJob.finishedOn)
-        : undefined,
-      failedAt: bullJob.finishedOn ? new Date(bullJob.finishedOn) : undefined,
-      error: bullJob.failedReason,
-    }),
-  }
-}

package/tsconfig.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "module": "Node18",
-    "outDir": "dist",
-    "target": "esnext",
-    "declaration": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["**/*.test.ts", "node_modules"],
-  "references": [
-    {
-      "path": "../../core/tsconfig.json"
-    }
-  ]
-}

package/tsconfig.tsbuildinfo

@@ -1 +0,0 @@
-{"root":["./src/bull-queue-service.ts","./src/bull-queue-worker.ts","./src/bull-scheduler-service.ts","./src/bull-service-factory.ts","./src/index.ts","./src/utils.ts"],"version":"6.0.3"}