@pikku/core 0.12.0 → 0.12.1

package/src/wirings/queue/queue-runner.test.ts

@@ -5,12 +5,11 @@ import {
   getQueueWorkers,
   removeQueueWorker,
   runQueueJob,
-  createQueueJobRunner,
   QueueJobFailedError,
   QueueJobDiscardedError,
 } from './queue-runner.js'
 import { resetPikkuState, pikkuState } from '../../pikku-state.js'
-import { CoreQueueWorker, QueueJob } from './queue.types.js'
+import type { CoreQueueWorker, QueueJob } from './queue.types.js'
 
 beforeEach(() => {
   resetPikkuState()
@@ -219,12 +218,14 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('simple-queue', 'job-123', {
       message: 'test data',
     })
 
     const result = await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
     })
 
@@ -257,12 +258,14 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('fail-queue', 'job-fail-123')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -295,12 +298,14 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('fail-no-reason-queue', 'job-456')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -331,12 +336,14 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('discard-queue', 'job-discard-789')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -374,10 +381,12 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('progress-queue', 'job-progress-999')
 
     await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
       updateProgress: async (progress) => {
         progressUpdates.push(progress)
@@ -407,10 +416,12 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('default-progress-queue', 'job-111')
 
     await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
     })
 
@@ -441,10 +452,12 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('wire-queue', 'job-int-123')
 
     await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
     })
 
@@ -457,12 +470,14 @@ describe('runQueueJob', () => {
 
   test('should throw error when processor metadata not found', async () => {
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('missing-meta-queue', 'job-222')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -483,12 +498,14 @@ describe('runQueueJob', () => {
     }
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('no-registration-queue', 'job-333')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -520,15 +537,19 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
-    const job = createMockJob('session-services-queue', 'job-444')
-
-    await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
-      job,
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+    pikkuState(null, 'package', 'factories', {
       createWireServices: async () => {
         createWireServicesCalled = true
         return mockWireService as any
       },
+    } as any)
+    const job = createMockJob('session-services-queue', 'job-444')
+
+    await runQueueJob({
+      job,
     })
 
     assert.equal(createWireServicesCalled, true)
@@ -553,12 +574,14 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('error-queue', 'job-555')
 
     await assert.rejects(
       async () => {
         await runQueueJob({
-          singletonServices: { logger: mockLogger } as any,
           job,
         })
       },
@@ -602,10 +625,12 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('middleware-queue', 'job-666')
 
     await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
     })
 
@@ -629,10 +654,12 @@ describe('runQueueJob', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
     const job = createMockJob('debug-queue', 'job-777')
 
     await runQueueJob({
-      singletonServices: { logger: mockLogger } as any,
       job,
     })
 
@@ -643,8 +670,8 @@ describe('runQueueJob', () => {
   })
 })
 
-describe('createQueueJobRunner', () => {
-  test('delegates queue job execution using bound services', async () => {
+describe('runQueueJob with pikkuState services', () => {
+  test('delegates queue job execution using pikkuState services', async () => {
     const mockWorker: CoreQueueWorker = {
       name: 'bound-runner-queue',
       func: {
@@ -663,11 +690,11 @@ describe('createQueueJobRunner', () => {
     wireQueueWorker(mockWorker)
 
     const mockLogger = createMockLogger()
-    const runJob = createQueueJobRunner({
-      singletonServices: { logger: mockLogger } as any,
-    })
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
 
-    await runJob({
+    await runQueueJob({
       job: createMockJob('bound-runner-queue', 'job-888', { value: 41 }),
     })
 

package/src/wirings/queue/queue-runner.ts

@@ -1,4 +1,4 @@
-import type { CoreServices, PikkuWire } from '../../types/core.types.js'
+import type { PikkuWire } from '../../types/core.types.js'
 import type { CoreQueueWorker, QueueJob, PikkuQueue } from './queue.types.js'
 import type {
   CorePikkuFunctionConfig,
@@ -6,9 +6,12 @@ import type {
 } from '../../function/functions.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
 import { PikkuMissingMetaError } from '../../errors/errors.js'
-import { pikkuState } from '../../pikku-state.js'
+import {
+  getSingletonServices,
+  getCreateWireServices,
+  pikkuState,
+} from '../../pikku-state.js'
 import { addFunction, runPikkuFunc } from '../../function/function-runner.js'
-import { CreateWireServices } from '../../types/core.types.js'
 
 /**
  * Error class for queue processor not found
@@ -100,16 +103,14 @@ export async function removeQueueWorker(name: string): Promise<void> {
  * Process a single queue job - this function is called by queue consumers
  */
 export async function runQueueJob({
-  singletonServices,
-  createWireServices,
   job,
   updateProgress,
 }: {
-  singletonServices: CoreServices
-  createWireServices?: CreateWireServices
   job: QueueJob
   updateProgress?: (progress: number | string | object) => Promise<void>
 }): Promise<void> {
+  const singletonServices = getSingletonServices()
+  const createWireServices = getCreateWireServices()
   const logger = singletonServices.logger
 
   const meta = pikkuState(null, 'queue', 'meta')
@@ -189,26 +190,3 @@ export async function runQueueJob({
     throw error
   }
 }
-
-export const createQueueJobRunner = ({
-  singletonServices,
-  createWireServices,
-}: {
-  singletonServices: CoreServices
-  createWireServices?: CreateWireServices
-}) => {
-  return async ({
-    job,
-    updateProgress,
-  }: {
-    job: QueueJob
-    updateProgress?: (progress: number | string | object) => Promise<void>
-  }) => {
-    await runQueueJob({
-      singletonServices,
-      createWireServices,
-      job,
-      updateProgress,
-    })
-  }
-}

package/src/wirings/queue/queue.types.ts

@@ -1,7 +1,6 @@
-import { CommonWireMeta } from '../../types/core.types.js'
-import { CorePikkuFunctionConfig } from '../../function/functions.types.js'
-import { QueueConfigMapping } from './validate-worker-config.js'
-import { Logger } from '../../services/logger.js'
+import type { CommonWireMeta } from '../../types/core.types.js'
+import type { CorePikkuFunctionConfig } from '../../function/functions.types.js'
+import type { QueueConfigMapping } from './validate-worker-config.js'
 
 /**
  * Configuration for queue workers - how jobs are processed
@@ -139,15 +138,6 @@ export interface QueueWorkers {
   /** Configuration mapping for validation */
   configMappings: QueueConfigMapping
 
-  /** Set runtime queue job runner callback and logger */
-  setJobRunner(
-    runJob: (params: {
-      job: QueueJob
-      updateProgress?: (progress: number | string | object) => Promise<void>
-    }) => Promise<void>,
-    logger: Logger
-  ): void
-
   /** Scan state and register all compatible processors */
   registerQueues(): Promise<Record<string, ConfigValidationResult[]>>
 }

package/src/wirings/queue/register-queue-helper.ts

@@ -1,10 +1,8 @@
 import type { ConfigValidationResult, CoreQueueWorker } from './queue.types.js'
 import { getQueueWorkers } from './queue-runner.js'
-import {
-  QueueConfigMapping,
-  validateWorkerConfig,
-} from './validate-worker-config.js'
-import { Logger } from '../../services/logger.js'
+import type { QueueConfigMapping } from './validate-worker-config.js'
+import { validateWorkerConfig } from './validate-worker-config.js'
+import type { Logger } from '../../services/logger.js'
 
 /**
  * Queue processor registration callback

package/src/wirings/queue/validate-worker-config.test.ts

@@ -0,0 +1,108 @@
+import { describe, test } from 'node:test'
+import assert from 'node:assert'
+import { validateWorkerConfig } from './validate-worker-config.js'
+import type { QueueConfigMapping } from './validate-worker-config.js'
+
+const createTestMapping = (): QueueConfigMapping => ({
+  supported: {
+    concurrency: {
+      queueProperty: 'concurrency',
+      description: 'Number of concurrent workers',
+    },
+    maxRetries: {
+      queueProperty: 'maxRetries',
+      description: 'Maximum retry attempts',
+    },
+  },
+  unsupported: {
+    rateLimitMax: {
+      reason: 'Not supported',
+      explanation: 'This queue does not support rate limiting',
+    },
+  },
+  fallbacks: {
+    retryDelay: {
+      reason: 'Partial support',
+      explanation: 'Uses fixed delay instead of exponential',
+      fallbackValue: '1000ms fixed',
+    },
+  },
+})
+
+describe('validateWorkerConfig', () => {
+  test('should return empty results for empty config', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, {})
+    assert.deepStrictEqual(result.applied, {})
+    assert.deepStrictEqual(result.ignored, {})
+    assert.deepStrictEqual(result.warnings, [])
+    assert.deepStrictEqual(result.fallbacks, {})
+  })
+
+  test('should return empty results for undefined config', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping)
+    assert.deepStrictEqual(result.applied, {})
+    assert.deepStrictEqual(result.ignored, {})
+  })
+
+  test('should apply supported configurations', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, { concurrency: 5 } as any)
+    assert.deepStrictEqual(result.applied, { concurrency: 5 })
+    assert.deepStrictEqual(result.ignored, {})
+    assert.strictEqual(result.warnings.length, 0)
+  })
+
+  test('should ignore unsupported configurations with warning', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, { rateLimitMax: 100 } as any)
+    assert.deepStrictEqual(result.ignored, { rateLimitMax: 100 })
+    assert.strictEqual(result.warnings.length, 1)
+    assert.ok(result.warnings[0].includes('Not supported'))
+  })
+
+  test('should handle fallback configurations', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, { retryDelay: 2000 } as any)
+    assert.deepStrictEqual(result.applied, { retryDelay: 2000 })
+    assert.deepStrictEqual(result.fallbacks, { retryDelay: '1000ms fixed' })
+    assert.strictEqual(result.warnings.length, 1)
+    assert.ok(result.warnings[0].includes('Partial support'))
+  })
+
+  test('should warn about unknown configurations', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, {
+      unknownOption: 'val',
+    } as any)
+    assert.deepStrictEqual(result.ignored, { unknownOption: 'val' })
+    assert.strictEqual(result.warnings.length, 1)
+    assert.ok(result.warnings[0].includes('Unknown configuration'))
+  })
+
+  test('should skip undefined values', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, {
+      concurrency: undefined,
+    } as any)
+    assert.deepStrictEqual(result.applied, {})
+  })
+
+  test('should handle mixed supported and unsupported configs', () => {
+    const mapping = createTestMapping()
+    const result = validateWorkerConfig(mapping, {
+      concurrency: 3,
+      maxRetries: 5,
+      rateLimitMax: 100,
+      retryDelay: 1000,
+    } as any)
+    assert.deepStrictEqual(result.applied, {
+      concurrency: 3,
+      maxRetries: 5,
+      retryDelay: 1000,
+    })
+    assert.deepStrictEqual(result.ignored, { rateLimitMax: 100 })
+    assert.strictEqual(result.warnings.length, 2)
+  })
+})

package/src/wirings/queue/validate-worker-config.ts

@@ -1,4 +1,7 @@
-import { PikkuWorkerConfig, ConfigValidationResult } from './queue.types.js'
+import type {
+  PikkuWorkerConfig,
+  ConfigValidationResult,
+} from './queue.types.js'
 
 /**
  * Configuration mapping structure for queue implementations

package/src/wirings/rpc/index.ts

@@ -1,2 +1,4 @@
 export { PikkuRPCService, rpcService, RPCNotFoundError } from './rpc-runner.js'
 export type { PikkuRPC, RPCMeta } from './rpc-types.js'
+export { wireAddon } from './wire-addon.js'
+export type { WireAddonConfig } from './wire-addon.js'