@pikku/core 0.11.2 → 0.12.1

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

@@ -9,7 +9,7 @@ import {
   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()
@@ -38,9 +38,9 @@ const createMockJob = (
   data,
 })
 
-const addTestQueueFunction = (pikkuFuncName: string) => {
-  pikkuState(null, 'function', 'meta')[pikkuFuncName] = {
-    pikkuFuncName,
+const addTestQueueFunction = (pikkuFuncId: string) => {
+  pikkuState(null, 'function', 'meta')[pikkuFuncId] = {
+    pikkuFuncId,
     inputSchemaName: null,
     outputSchemaName: null,
     middleware: undefined,
@@ -51,7 +51,7 @@ const addTestQueueFunction = (pikkuFuncName: string) => {
 describe('wireQueueWorker', () => {
   test('should successfully wire a queue worker', () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'test-queue',
+      name: 'test-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           return { processed: true }
@@ -60,10 +60,9 @@ describe('wireQueueWorker', () => {
       },
     }
 
-    // Set up metadata first
     pikkuState(null, 'queue', 'meta')['test-queue'] = {
-      pikkuFuncName: 'queue_test-queue',
-      queueName: 'test-queue',
+      pikkuFuncId: 'queue_test-queue',
+      name: 'test-queue',
     }
     addTestQueueFunction('queue_test-queue')
     wireQueueWorker(mockWorker)
@@ -75,7 +74,7 @@ describe('wireQueueWorker', () => {
 
   test('should throw error when processor metadata not found', () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'missing-meta-queue',
+      name: 'missing-meta-queue',
       func: {
         func: async () => {},
         auth: false,
@@ -85,7 +84,9 @@ describe('wireQueueWorker', () => {
     assert.throws(
       () => wireQueueWorker(mockWorker),
       (error: any) => {
-        assert(error.message.includes('Queue processor metadata not found'))
+        assert(
+          error.message.includes('Missing generated metadata for queue worker')
+        )
         assert(error.message.includes('missing-meta-queue'))
         return true
       }
@@ -98,7 +99,7 @@ describe('wireQueueWorker', () => {
     }
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'worker-with-middleware',
+      name: 'worker-with-middleware',
       func: {
         func: async () => {},
         auth: false,
@@ -110,8 +111,8 @@ describe('wireQueueWorker', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['worker-with-middleware'] = {
-      pikkuFuncName: 'queue_worker-with-middleware',
-      queueName: 'worker-with-middleware',
+      pikkuFuncId: 'queue_worker-with-middleware',
+      name: 'worker-with-middleware',
     }
     addTestQueueFunction('queue_worker-with-middleware')
     wireQueueWorker(mockWorker)
@@ -126,7 +127,7 @@ describe('wireQueueWorker', () => {
 describe('getQueueWorkers', () => {
   test('should return the registrations map', () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'test-queue',
+      name: 'test-queue',
       func: {
         func: async () => {},
         auth: false,
@@ -134,8 +135,8 @@ describe('getQueueWorkers', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['test-queue'] = {
-      pikkuFuncName: 'queue_test-queue',
-      queueName: 'test-queue',
+      pikkuFuncId: 'queue_test-queue',
+      name: 'test-queue',
     }
     addTestQueueFunction('queue_test-queue')
     wireQueueWorker(mockWorker)
@@ -155,7 +156,7 @@ describe('getQueueWorkers', () => {
 describe('removeQueueWorker', () => {
   test('should successfully remove a queue worker', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'removable-queue',
+      name: 'removable-queue',
       func: {
         func: async () => {},
         auth: false,
@@ -163,8 +164,8 @@ describe('removeQueueWorker', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['removable-queue'] = {
-      pikkuFuncName: 'queue_removable-queue',
-      queueName: 'removable-queue',
+      pikkuFuncId: 'queue_removable-queue',
+      name: 'removable-queue',
     }
     addTestQueueFunction('queue_removable-queue')
     wireQueueWorker(mockWorker)
@@ -198,7 +199,7 @@ describe('runQueueJob', () => {
     let receivedData: any
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'simple-queue',
+      name: 'simple-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           jobProcessed = true
@@ -210,19 +211,21 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['simple-queue'] = {
-      pikkuFuncName: 'queue_simple-queue',
-      queueName: 'simple-queue',
+      pikkuFuncId: 'queue_simple-queue',
+      name: 'simple-queue',
     }
     addTestQueueFunction('queue_simple-queue')
     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,
     })
 
@@ -238,7 +241,7 @@ describe('runQueueJob', () => {
 
   test('should handle job.fail() by throwing QueueJobFailedError', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'fail-queue',
+      name: 'fail-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           await wire.queue.fail('Processing failed')
@@ -248,19 +251,21 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['fail-queue'] = {
-      pikkuFuncName: 'queue_fail-queue',
-      queueName: 'fail-queue',
+      pikkuFuncId: 'queue_fail-queue',
+      name: 'fail-queue',
     }
     addTestQueueFunction('queue_fail-queue')
     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,
         })
       },
@@ -276,7 +281,7 @@ describe('runQueueJob', () => {
 
   test('should handle job.fail() without reason', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'fail-no-reason-queue',
+      name: 'fail-no-reason-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           await wire.queue.fail()
@@ -286,19 +291,21 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['fail-no-reason-queue'] = {
-      pikkuFuncName: 'queue_fail-no-reason-queue',
-      queueName: 'fail-no-reason-queue',
+      pikkuFuncId: 'queue_fail-no-reason-queue',
+      name: 'fail-no-reason-queue',
     }
     addTestQueueFunction('queue_fail-no-reason-queue')
     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,
         })
       },
@@ -312,7 +319,7 @@ describe('runQueueJob', () => {
 
   test('should handle job.discard() by throwing QueueJobDiscardedError', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'discard-queue',
+      name: 'discard-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           await wire.queue.discard('Invalid data')
@@ -322,19 +329,21 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['discard-queue'] = {
-      pikkuFuncName: 'queue_discard-queue',
-      queueName: 'discard-queue',
+      pikkuFuncId: 'queue_discard-queue',
+      name: 'discard-queue',
     }
     addTestQueueFunction('queue_discard-queue')
     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,
         })
       },
@@ -352,7 +361,7 @@ describe('runQueueJob', () => {
     const progressUpdates: Array<number | string | object> = []
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'progress-queue',
+      name: 'progress-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           await wire.queue.updateProgress(25)
@@ -365,17 +374,19 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['progress-queue'] = {
-      pikkuFuncName: 'queue_progress-queue',
-      queueName: 'progress-queue',
+      pikkuFuncId: 'queue_progress-queue',
+      name: 'progress-queue',
     }
     addTestQueueFunction('queue_progress-queue')
     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)
@@ -387,7 +398,7 @@ describe('runQueueJob', () => {
 
   test('should use default updateProgress when not provided', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'default-progress-queue',
+      name: 'default-progress-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           await wire.queue.updateProgress(50)
@@ -398,17 +409,19 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['default-progress-queue'] = {
-      pikkuFuncName: 'queue_default-progress-queue',
-      queueName: 'default-progress-queue',
+      pikkuFuncId: 'queue_default-progress-queue',
+      name: 'default-progress-queue',
     }
     addTestQueueFunction('queue_default-progress-queue')
     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,
     })
 
@@ -421,7 +434,7 @@ describe('runQueueJob', () => {
     let capturedWire: any
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'wire-queue',
+      name: 'wire-queue',
       func: {
         func: async (services: any, data: any, wire: any) => {
           capturedWire = wire
@@ -432,17 +445,19 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['wire-queue'] = {
-      pikkuFuncName: 'queue_wire-queue',
-      queueName: 'wire-queue',
+      pikkuFuncId: 'queue_wire-queue',
+      name: 'wire-queue',
     }
     addTestQueueFunction('queue_wire-queue')
     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,
     })
 
@@ -455,17 +470,21 @@ 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,
         })
       },
       (error: any) => {
-        assert(error.message.includes('Processor metadata not found'))
+        assert(
+          error.message.includes('Missing generated metadata for queue worker')
+        )
         assert(error.message.includes('missing-meta-queue'))
         return true
       }
@@ -473,19 +492,20 @@ describe('runQueueJob', () => {
   })
 
   test('should throw error when queue worker registration not found', async () => {
-    // Add metadata but not registration
     pikkuState(null, 'queue', 'meta')['no-registration-queue'] = {
-      pikkuFuncName: 'queue_no-registration-queue',
-      queueName: 'no-registration-queue',
+      pikkuFuncId: 'queue_no-registration-queue',
+      name: 'no-registration-queue',
     }
 
     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,
         })
       },
@@ -502,7 +522,7 @@ describe('runQueueJob', () => {
     const mockWireService = { custom: 'service' }
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'session-services-queue',
+      name: 'session-services-queue',
       func: {
         func: async () => 'ok',
         auth: false,
@@ -510,22 +530,26 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['session-services-queue'] = {
-      pikkuFuncName: 'queue_session-services-queue',
-      queueName: 'session-services-queue',
+      pikkuFuncId: 'queue_session-services-queue',
+      name: 'session-services-queue',
     }
     addTestQueueFunction('queue_session-services-queue')
     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)
@@ -533,7 +557,7 @@ describe('runQueueJob', () => {
 
   test('should log errors when job processing fails', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'error-queue',
+      name: 'error-queue',
       func: {
         func: async () => {
           throw new Error('Processing error')
@@ -543,19 +567,21 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['error-queue'] = {
-      pikkuFuncName: 'queue_error-queue',
-      queueName: 'error-queue',
+      pikkuFuncId: 'queue_error-queue',
+      name: 'error-queue',
     }
     addTestQueueFunction('queue_error-queue')
     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,
         })
       },
@@ -580,7 +606,7 @@ describe('runQueueJob', () => {
     }
 
     const mockWorker: CoreQueueWorker = {
-      queueName: 'middleware-queue',
+      name: 'middleware-queue',
       func: {
         func: async () => {
           executionOrder.push('job')
@@ -592,17 +618,19 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['middleware-queue'] = {
-      pikkuFuncName: 'queue_middleware-queue',
-      queueName: 'middleware-queue',
+      pikkuFuncId: 'queue_middleware-queue',
+      name: 'middleware-queue',
     }
     addTestQueueFunction('queue_middleware-queue')
     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,
     })
 
@@ -611,7 +639,7 @@ describe('runQueueJob', () => {
 
   test('should log debug message on successful job completion', async () => {
     const mockWorker: CoreQueueWorker = {
-      queueName: 'debug-queue',
+      name: 'debug-queue',
       func: {
         func: async () => 'success',
         auth: false,
@@ -619,17 +647,19 @@ describe('runQueueJob', () => {
     }
 
     pikkuState(null, 'queue', 'meta')['debug-queue'] = {
-      pikkuFuncName: 'queue_debug-queue',
-      queueName: 'debug-queue',
+      pikkuFuncId: 'queue_debug-queue',
+      name: 'debug-queue',
     }
     addTestQueueFunction('queue_debug-queue')
     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,
     })
 
@@ -639,3 +669,42 @@ describe('runQueueJob', () => {
     assert(debugLogs[0].message.includes('Successfully processed job job-777'))
   })
 })
+
+describe('runQueueJob with pikkuState services', () => {
+  test('delegates queue job execution using pikkuState services', async () => {
+    const mockWorker: CoreQueueWorker = {
+      name: 'bound-runner-queue',
+      func: {
+        func: async (_services: any, data: any) => {
+          return data.value + 1
+        },
+        auth: false,
+      },
+    }
+
+    pikkuState(null, 'queue', 'meta')['bound-runner-queue'] = {
+      pikkuFuncId: 'queue_bound-runner-queue',
+      name: 'bound-runner-queue',
+    }
+    addTestQueueFunction('queue_bound-runner-queue')
+    wireQueueWorker(mockWorker)
+
+    const mockLogger = createMockLogger()
+    pikkuState(null, 'package', 'singletonServices', {
+      logger: mockLogger,
+    } as any)
+
+    await runQueueJob({
+      job: createMockJob('bound-runner-queue', 'job-888', { value: 41 }),
+    })
+
+    const logs = mockLogger.getLogs()
+    assert(
+      logs.some(
+        (log) =>
+          log.level === 'debug' &&
+          String(log.message).includes('Successfully processed job job-888')
+      )
+    )
+  })
+})

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

@@ -1,13 +1,17 @@
-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,
   CorePikkuFunctionSessionless,
 } from '../../function/functions.types.js'
 import { getErrorResponse, PikkuError } from '../../errors/error-handler.js'
-import { pikkuState } from '../../pikku-state.js'
+import { PikkuMissingMetaError } from '../../errors/errors.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
@@ -53,15 +57,15 @@ export const wireQueueWorker = <
 ) => {
   // Get processor metadata
   const meta = pikkuState(null, 'queue', 'meta')
-  const processorMeta = meta[queueWorker.queueName]
+  const processorMeta = meta[queueWorker.name]
   if (!processorMeta) {
-    throw new Error(
-      `Queue processor metadata not found for '${queueWorker.queueName}'. Make sure to run the CLI to generate metadata.`
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for queue worker '${queueWorker.name}'`
     )
   }
 
   // Register the function with pikku
-  addFunction(processorMeta.pikkuFuncName, {
+  addFunction(processorMeta.pikkuFuncId, {
     func: queueWorker.func.func,
     auth: queueWorker.func.auth,
     permissions: queueWorker.func.permissions,
@@ -71,7 +75,7 @@ export const wireQueueWorker = <
 
   // Store processor definition in state - runtime adapters will pick this up
   const registrations = pikkuState(null, 'queue', 'registrations')
-  registrations.set(queueWorker.queueName, queueWorker)
+  registrations.set(queueWorker.name, queueWorker)
 }
 
 /**
@@ -99,22 +103,22 @@ 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')
   const processorMeta = meta[job.queueName]
   if (!processorMeta) {
-    throw new Error(`Processor metadata not found for: ${job.queueName}`)
+    throw new PikkuMissingMetaError(
+      `Missing generated metadata for queue worker '${job.queueName}'`
+    )
   }
 
   // Get the queue worker registration to access middleware
@@ -153,7 +157,7 @@ export async function runQueueJob({
     const result = await runPikkuFunc(
       'queue',
       job.queueName,
-      processorMeta.pikkuFuncName,
+      processorMeta.pikkuFuncId,
       {
         singletonServices,
         createWireServices,

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

@@ -1,6 +1,6 @@
-import { CommonWireMeta } from '../../types/core.types.js'
-import { CorePikkuFunctionConfig } from '../../function/functions.types.js'
-import { QueueConfigMapping } from './validate-worker-config.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
@@ -148,7 +148,7 @@ export interface QueueWorkers {
 export type QueueWorkersMeta = Record<
   string,
   CommonWireMeta & {
-    queueName: string
+    name: string
     config?: PikkuWorkerConfig
   }
 >
@@ -163,7 +163,7 @@ export type CoreQueueWorker<
     any
   > = CorePikkuFunctionConfig<any, any, any>,
 > = {
-  queueName: string
+  name: string
   func: PikkuFunctionConfig
   config?: PikkuWorkerConfig
   errors?: string[]