@open-mercato/scheduler 0.6.6-develop.6460.1.f94c74174c → 0.6.6-develop.6471.1.9ab5bdd79a

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/dist/modules/scheduler/api/jobs/[id]/executions/route.js +3 -1
  2. package/dist/modules/scheduler/api/jobs/[id]/executions/route.js.map +2 -2
  3. package/dist/modules/scheduler/api/queue-jobs/[jobId]/route.js +3 -1
  4. package/dist/modules/scheduler/api/queue-jobs/[jobId]/route.js.map +2 -2
  5. package/dist/modules/scheduler/api/trigger/route.js +4 -2
  6. package/dist/modules/scheduler/api/trigger/route.js.map +2 -2
  7. package/dist/modules/scheduler/cli.js +55 -50
  8. package/dist/modules/scheduler/cli.js.map +2 -2
  9. package/dist/modules/scheduler/commands/test-echo.js +3 -2
  10. package/dist/modules/scheduler/commands/test-echo.js.map +2 -2
  11. package/dist/modules/scheduler/di.js +4 -2
  12. package/dist/modules/scheduler/di.js.map +2 -2
  13. package/dist/modules/scheduler/lib/localLockStrategy.js +3 -1
  14. package/dist/modules/scheduler/lib/localLockStrategy.js.map +2 -2
  15. package/dist/modules/scheduler/lib/scheduledJobSubscriber.js +8 -6
  16. package/dist/modules/scheduler/lib/scheduledJobSubscriber.js.map +2 -2
  17. package/dist/modules/scheduler/services/bullmqSchedulerService.js +20 -17
  18. package/dist/modules/scheduler/services/bullmqSchedulerService.js.map +2 -2
  19. package/dist/modules/scheduler/services/localSchedulerService.js +21 -19
  20. package/dist/modules/scheduler/services/localSchedulerService.js.map +2 -2
  21. package/dist/modules/scheduler/services/schedulerService.js +5 -3
  22. package/dist/modules/scheduler/services/schedulerService.js.map +2 -2
  23. package/dist/modules/scheduler/workers/execute-schedule.worker.js +16 -15
  24. package/dist/modules/scheduler/workers/execute-schedule.worker.js.map +2 -2
  25. package/package.json +5 -5
  26. package/src/modules/scheduler/api/jobs/[id]/executions/route.ts +4 -1
  27. package/src/modules/scheduler/api/queue-jobs/[jobId]/route.ts +4 -1
  28. package/src/modules/scheduler/api/trigger/route.ts +5 -2
  29. package/src/modules/scheduler/cli.ts +55 -48
  30. package/src/modules/scheduler/commands/test-echo.ts +4 -2
  31. package/src/modules/scheduler/di.ts +6 -3
  32. package/src/modules/scheduler/lib/localLockStrategy.ts +4 -1
  33. package/src/modules/scheduler/lib/scheduledJobSubscriber.ts +9 -6
  34. package/src/modules/scheduler/services/__tests__/bullmqSchedulerService.test.ts +49 -74
  35. package/src/modules/scheduler/services/__tests__/localSchedulerService.test.ts +29 -67
  36. package/src/modules/scheduler/services/__tests__/schedulerService.test.ts +24 -9
  37. package/src/modules/scheduler/services/bullmqSchedulerService.ts +20 -16
  38. package/src/modules/scheduler/services/localSchedulerService.ts +22 -19
  39. package/src/modules/scheduler/services/schedulerService.ts +6 -3
  40. package/src/modules/scheduler/workers/execute-schedule.worker.ts +16 -14
@@ -5,6 +5,9 @@ import { SchedulerService } from './services/schedulerService.js'
5
5
  import { BullMQSchedulerService } from './services/bullmqSchedulerService.js'
6
6
  import { LocalSchedulerService } from './services/localSchedulerService.js'
7
7
  import { ScheduledJobSubscriber } from './lib/scheduledJobSubscriber.js'
8
+ import { createLogger } from '@open-mercato/shared/lib/logger'
9
+
10
+ const logger = createLogger('scheduler')
8
11
 
9
12
  // Process-level guard: ensures BullMQ sync runs at most once per process lifetime.
10
13
  let schedulerSynced = false
@@ -41,7 +44,7 @@ export function register(container: AppContainer) {
41
44
  }
42
45
  } catch (error) {
43
46
  // Best-effort registration - don't break if EM not available yet
44
- console.warn('[scheduler] Could not register subscriber:', error)
47
+ logger.warn('Could not register subscriber', { err: error })
45
48
  }
46
49
 
47
50
  // Cold start sync: reconcile DB schedules with BullMQ repeatable jobs.
@@ -51,8 +54,8 @@ export function register(container: AppContainer) {
51
54
  setImmediate(() => {
52
55
  const service = container.resolve('bullmqSchedulerService') as BullMQSchedulerService
53
56
  service.syncAll()
54
- .then(() => console.log('[scheduler] BullMQ cold start sync complete'))
55
- .catch((err: Error) => console.error('[scheduler] BullMQ cold start sync failed:', err.message))
57
+ .then(() => logger.info('BullMQ cold start sync complete'))
58
+ .catch((err: Error) => logger.error('BullMQ cold start sync failed', { err }))
56
59
  })
57
60
  }
58
61
  } else {
@@ -1,4 +1,7 @@
1
1
  import type { EntityManager } from '@mikro-orm/core'
2
+ import { createLogger } from '@open-mercato/shared/lib/logger'
3
+
4
+ const logger = createLogger('scheduler').child({ component: 'local' })
2
5
 
3
6
  /**
4
7
  * PostgreSQL advisory lock strategy for single-instance or local development
@@ -37,7 +40,7 @@ export class LocalLockStrategy {
37
40
  throw error
38
41
  }
39
42
 
40
- console.error('[scheduler:local] Failed to acquire lock:', error)
43
+ logger.error('Failed to acquire lock', { lockKey: key, err: error })
41
44
  return { acquired: false }
42
45
  }
43
46
  }
@@ -6,6 +6,9 @@ import type {
6
6
  import type { AwilixContainer } from 'awilix'
7
7
  import { ScheduledJob } from '../data/entities.js'
8
8
  import type { BullMQSchedulerService } from '../services/bullmqSchedulerService'
9
+ import { createLogger } from '@open-mercato/shared/lib/logger'
10
+
11
+ const logger = createLogger('scheduler').child({ component: 'sync' })
9
12
 
10
13
  /**
11
14
  * MikroORM Event Subscriber for ScheduledJob
@@ -56,7 +59,7 @@ export class ScheduledJobSubscriber implements EventSubscriber<ScheduledJob> {
56
59
  this.bullmqService = this.container.resolve<BullMQSchedulerService>('bullmqSchedulerService')
57
60
  }
58
61
  } catch (error) {
59
- console.warn('[scheduler:sync] Could not resolve BullMQSchedulerService:', error)
62
+ logger.warn('Could not resolve BullMQSchedulerService', { err: error })
60
63
  }
61
64
  }
62
65
 
@@ -102,25 +105,25 @@ export class ScheduledJobSubscriber implements EventSubscriber<ScheduledJob> {
102
105
  if (schedule.isEnabled && !schedule.deletedAt) {
103
106
  // Skip nextRunAt update since we're in afterFlush - it's already persisted
104
107
  await bullmqService.register(schedule, { skipNextRunUpdate: true })
105
- console.log(`[scheduler:sync] Synced ${changeSet.type} to BullMQ: ${schedule.name}`)
108
+ logger.info('Synced schedule to BullMQ', { changeType: changeSet.type, scheduleId: schedule.id, scheduleName: schedule.name })
106
109
  } else {
107
110
  // Disabled or soft-deleted - remove from BullMQ
108
111
  await bullmqService.unregister(schedule.id)
109
- console.log(`[scheduler:sync] Removed from BullMQ: ${schedule.name}`)
112
+ logger.info('Removed schedule from BullMQ', { scheduleId: schedule.id, scheduleName: schedule.name })
110
113
  }
111
114
  } else if (changeSet.type === 'delete') {
112
115
  // Hard delete - remove from BullMQ
113
116
  await bullmqService.unregister(schedule.id)
114
- console.log(`[scheduler:sync] Removed from BullMQ (deleted): ${schedule.id}`)
117
+ logger.info('Removed deleted schedule from BullMQ', { scheduleId: schedule.id })
115
118
  }
116
119
  } catch (error) {
117
120
  // Don't throw - we don't want to break the transaction
118
121
  // BullMQ sync is best-effort, DB is source of truth
119
- console.error(`[scheduler:sync] Failed to sync with BullMQ:`, {
122
+ logger.error('Failed to sync with BullMQ', {
120
123
  scheduleId: schedule.id,
121
124
  scheduleName: schedule.name,
122
125
  changeType: changeSet.type,
123
- error: error instanceof Error ? error.message : String(error),
126
+ err: error,
124
127
  })
125
128
  }
126
129
  }
@@ -1,6 +1,24 @@
1
1
  import { BullMQSchedulerService } from '../bullmqSchedulerService'
2
2
  import type { EntityManager } from '@mikro-orm/core'
3
3
  import { ScheduledJob } from '../../data/entities.js'
4
+ import { createLogger } from '@open-mercato/shared/lib/logger'
5
+
6
+ jest.mock('@open-mercato/shared/lib/logger', () => {
7
+ const mocked = {
8
+ debug: jest.fn(),
9
+ info: jest.fn(),
10
+ warn: jest.fn(),
11
+ error: jest.fn(),
12
+ child: jest.fn(),
13
+ }
14
+ mocked.child.mockImplementation(() => mocked)
15
+ return { createLogger: jest.fn(() => mocked) }
16
+ })
17
+
18
+ const mockedLogger = createLogger('scheduler')
19
+ const loggerDebug = mockedLogger.debug as jest.Mock
20
+ const loggerInfo = mockedLogger.info as jest.Mock
21
+ const loggerError = mockedLogger.error as jest.Mock
4
22
 
5
23
  // Mock BullMQ module
6
24
  const mockQueue = {
@@ -52,16 +70,13 @@ describe('BullMQSchedulerService', () => {
52
70
  isEnabled: false,
53
71
  } as ScheduledJob
54
72
 
55
- const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation()
56
-
57
73
  await service.register(schedule)
58
74
 
59
- expect(consoleDebugSpy).toHaveBeenCalledWith(
60
- '[scheduler:bullmq] Skipping disabled schedule: test-1'
75
+ expect(loggerDebug).toHaveBeenCalledWith(
76
+ 'Skipping disabled schedule',
77
+ { scheduleId: 'test-1' }
61
78
  )
62
79
  expect(mockQueue.add).not.toHaveBeenCalled()
63
-
64
- consoleDebugSpy.mockRestore()
65
80
  })
66
81
 
67
82
  it('should register cron schedule with BullMQ', async () => {
@@ -79,8 +94,6 @@ describe('BullMQSchedulerService', () => {
79
94
 
80
95
  mockQueue.add.mockResolvedValue({})
81
96
 
82
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
83
-
84
97
  await service.register(schedule)
85
98
 
86
99
  expect(mockQueue.add).toHaveBeenCalledWith(
@@ -99,8 +112,6 @@ describe('BullMQSchedulerService', () => {
99
112
  }),
100
113
  })
101
114
  )
102
-
103
- consoleLogSpy.mockRestore()
104
115
  })
105
116
 
106
117
  it('should register interval schedule with BullMQ', async () => {
@@ -118,8 +129,6 @@ describe('BullMQSchedulerService', () => {
118
129
 
119
130
  mockQueue.add.mockResolvedValue({})
120
131
 
121
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
122
-
123
132
  await service.register(schedule)
124
133
 
125
134
  expect(mockQueue.add).toHaveBeenCalledWith(
@@ -138,8 +147,6 @@ describe('BullMQSchedulerService', () => {
138
147
  }),
139
148
  })
140
149
  )
141
-
142
- consoleLogSpy.mockRestore()
143
150
  })
144
151
 
145
152
  it('should include organization scope in job data', async () => {
@@ -266,16 +273,12 @@ describe('BullMQSchedulerService', () => {
266
273
  const error = new Error('BullMQ connection failed')
267
274
  mockQueue.add.mockRejectedValue(error)
268
275
 
269
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
270
-
271
276
  await expect(service.register(schedule)).rejects.toThrow('BullMQ connection failed')
272
277
 
273
- expect(consoleErrorSpy).toHaveBeenCalledWith(
274
- '[scheduler:bullmq] Failed to register schedule: test-1',
275
- error
278
+ expect(loggerError).toHaveBeenCalledWith(
279
+ 'Failed to register schedule',
280
+ { scheduleId: 'test-1', err: error }
276
281
  )
277
-
278
- consoleErrorSpy.mockRestore()
279
282
  })
280
283
 
281
284
  it('should throw on invalid cron expression', async () => {
@@ -315,17 +318,14 @@ describe('BullMQSchedulerService', () => {
315
318
  ])
316
319
  mockQueue.removeRepeatableByKey.mockResolvedValue(true)
317
320
 
318
- const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation()
319
-
320
321
  await service.unregister('test-1')
321
322
 
322
323
  expect(mockQueue.getRepeatableJobs).toHaveBeenCalled()
323
324
  expect(mockQueue.removeRepeatableByKey).toHaveBeenCalledWith('key-1')
324
- expect(consoleDebugSpy).toHaveBeenCalledWith(
325
- '[scheduler:bullmq] Unregistered schedule: test-1'
325
+ expect(loggerDebug).toHaveBeenCalledWith(
326
+ 'Unregistered schedule',
327
+ { scheduleId: 'test-1' }
326
328
  )
327
-
328
- consoleDebugSpy.mockRestore()
329
329
  })
330
330
 
331
331
  it('should remove all repeatable jobs for the same schedule id', async () => {
@@ -350,16 +350,13 @@ describe('BullMQSchedulerService', () => {
350
350
  { id: 'schedule-other', name: 'schedule-other', key: 'key-1' },
351
351
  ])
352
352
 
353
- const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation()
354
-
355
353
  await service.unregister('test-1')
356
354
 
357
355
  expect(mockQueue.removeRepeatableByKey).not.toHaveBeenCalled()
358
- expect(consoleDebugSpy).toHaveBeenCalledWith(
359
- '[scheduler:bullmq] No repeatable job found for schedule: test-1'
356
+ expect(loggerDebug).toHaveBeenCalledWith(
357
+ 'No repeatable job found for schedule',
358
+ { scheduleId: 'test-1' }
360
359
  )
361
-
362
- consoleDebugSpy.mockRestore()
363
360
  })
364
361
 
365
362
  it('should match by name if id is not present', async () => {
@@ -377,16 +374,12 @@ describe('BullMQSchedulerService', () => {
377
374
  const error = new Error('BullMQ error')
378
375
  mockQueue.getRepeatableJobs.mockRejectedValue(error)
379
376
 
380
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
381
-
382
377
  await expect(service.unregister('test-1')).rejects.toThrow('BullMQ error')
383
378
 
384
- expect(consoleErrorSpy).toHaveBeenCalledWith(
385
- '[scheduler:bullmq] Failed to unregister schedule: test-1',
386
- error
379
+ expect(loggerError).toHaveBeenCalledWith(
380
+ 'Failed to unregister schedule',
381
+ { scheduleId: 'test-1', err: error }
387
382
  )
388
-
389
- consoleErrorSpy.mockRestore()
390
383
  })
391
384
  })
392
385
 
@@ -403,8 +396,6 @@ describe('BullMQSchedulerService', () => {
403
396
  ])
404
397
  mockQueue.add.mockResolvedValue({})
405
398
 
406
- const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation()
407
-
408
399
  await service.syncAll()
409
400
 
410
401
  expect(mockForkedEm.find).toHaveBeenCalledWith(ScheduledJob, {
@@ -416,11 +407,10 @@ describe('BullMQSchedulerService', () => {
416
407
  expect.any(Object),
417
408
  expect.any(Object)
418
409
  )
419
- expect(consoleDebugSpy).toHaveBeenCalledWith(
420
- '[scheduler:bullmq] Registering missing schedule: Schedule 2'
410
+ expect(loggerDebug).toHaveBeenCalledWith(
411
+ 'Registering missing schedule',
412
+ { scheduleId: 'schedule-2', scheduleName: 'Schedule 2' }
421
413
  )
422
-
423
- consoleDebugSpy.mockRestore()
424
414
  })
425
415
 
426
416
  it('should remove orphaned BullMQ jobs', async () => {
@@ -435,16 +425,13 @@ describe('BullMQSchedulerService', () => {
435
425
  ])
436
426
  mockQueue.removeRepeatableByKey.mockResolvedValue(true)
437
427
 
438
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
439
-
440
428
  await service.syncAll()
441
429
 
442
430
  expect(mockQueue.removeRepeatableByKey).toHaveBeenCalledWith('key-2')
443
- expect(consoleLogSpy).toHaveBeenCalledWith(
444
- '[scheduler:bullmq] Removing orphaned schedule: schedule-2'
431
+ expect(loggerInfo).toHaveBeenCalledWith(
432
+ 'Removing orphaned schedule',
433
+ { scheduleId: 'schedule-2' }
445
434
  )
446
-
447
- consoleLogSpy.mockRestore()
448
435
  })
449
436
 
450
437
  it('should repair duplicate repeatable jobs for existing schedules', async () => {
@@ -460,12 +447,11 @@ describe('BullMQSchedulerService', () => {
460
447
  mockQueue.removeRepeatableByKey.mockResolvedValue(true)
461
448
  mockQueue.add.mockResolvedValue({})
462
449
 
463
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
464
-
465
450
  await service.syncAll()
466
451
 
467
- expect(consoleLogSpy).toHaveBeenCalledWith(
468
- '[scheduler:bullmq] Repairing duplicate repeatable jobs for schedule: schedule-1'
452
+ expect(loggerInfo).toHaveBeenCalledWith(
453
+ 'Repairing duplicate repeatable jobs',
454
+ { scheduleId: 'schedule-1' }
469
455
  )
470
456
  expect(mockQueue.removeRepeatableByKey).toHaveBeenCalledTimes(2)
471
457
  expect(mockQueue.removeRepeatableByKey).toHaveBeenNthCalledWith(1, 'old-key-1')
@@ -475,26 +461,19 @@ describe('BullMQSchedulerService', () => {
475
461
  expect.any(Object),
476
462
  expect.any(Object),
477
463
  )
478
-
479
- consoleLogSpy.mockRestore()
480
464
  })
481
465
 
482
466
  it('should log sync completion', async () => {
483
467
  mockForkedEm.find.mockResolvedValue([])
484
468
  mockQueue.getRepeatableJobs.mockResolvedValue([])
485
469
 
486
- const consoleDebugSpy = jest.spyOn(console, 'debug').mockImplementation()
487
-
488
470
  await service.syncAll()
489
471
 
490
- expect(consoleDebugSpy).toHaveBeenCalledWith(
491
- '[scheduler:bullmq] Starting full sync...'
492
- )
493
- expect(consoleDebugSpy).toHaveBeenCalledWith(
494
- '[scheduler:bullmq] Sync complete - 0 schedules active'
472
+ expect(loggerDebug).toHaveBeenCalledWith('Starting full sync')
473
+ expect(loggerDebug).toHaveBeenCalledWith(
474
+ 'Sync complete',
475
+ { activeSchedules: 0 }
495
476
  )
496
-
497
- consoleDebugSpy.mockRestore()
498
477
  })
499
478
  })
500
479
 
@@ -516,17 +495,13 @@ describe('BullMQSchedulerService', () => {
516
495
  it('should return empty array on error', async () => {
517
496
  mockQueue.getRepeatableJobs.mockRejectedValue(new Error('BullMQ error'))
518
497
 
519
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
520
-
521
498
  const result = await service.getRepeatableJobs()
522
499
 
523
500
  expect(result).toEqual([])
524
- expect(consoleErrorSpy).toHaveBeenCalledWith(
525
- '[scheduler:bullmq] Failed to get repeatable jobs:',
526
- expect.any(Error)
501
+ expect(loggerError).toHaveBeenCalledWith(
502
+ 'Failed to get repeatable jobs',
503
+ { err: expect.any(Error) }
527
504
  )
528
-
529
- consoleErrorSpy.mockRestore()
530
505
  })
531
506
  })
532
507
 
@@ -2,6 +2,25 @@ import { LocalSchedulerService } from '../localSchedulerService'
2
2
  import type { EntityManager } from '@mikro-orm/core'
3
3
  import type { Queue } from '@open-mercato/queue'
4
4
  import { ScheduledJob } from '../../data/entities.js'
5
+ import { createLogger } from '@open-mercato/shared/lib/logger'
6
+
7
+ jest.mock('@open-mercato/shared/lib/logger', () => {
8
+ const mocked = {
9
+ debug: jest.fn(),
10
+ info: jest.fn(),
11
+ warn: jest.fn(),
12
+ error: jest.fn(),
13
+ child: jest.fn(),
14
+ }
15
+ mocked.child.mockImplementation(() => mocked)
16
+ return { createLogger: jest.fn(() => mocked) }
17
+ })
18
+
19
+ const mockedLogger = createLogger('scheduler')
20
+ const loggerDebug = mockedLogger.debug as jest.Mock
21
+ const loggerInfo = mockedLogger.info as jest.Mock
22
+ const loggerWarn = mockedLogger.warn as jest.Mock
23
+ const loggerError = mockedLogger.error as jest.Mock
5
24
 
6
25
  // Mock the typed event emitter
7
26
  const mockEmitSchedulerEvent = jest.fn()
@@ -88,22 +107,15 @@ describe('LocalSchedulerService', () => {
88
107
  it('should start polling engine', async () => {
89
108
  mockForkedEm.find.mockResolvedValue([])
90
109
 
91
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
92
-
93
110
  await service.start()
94
111
 
95
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] Starting polling engine...')
96
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] Poll interval: 1000ms')
97
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] ✓ Polling engine started')
98
-
99
- consoleLogSpy.mockRestore()
112
+ expect(loggerInfo).toHaveBeenCalledWith('Starting polling engine', { pollIntervalMs: 1000 })
113
+ expect(loggerInfo).toHaveBeenCalledWith('Polling engine started')
100
114
  })
101
115
 
102
116
  it('should run initial poll immediately', async () => {
103
117
  mockForkedEm.find.mockResolvedValue([])
104
118
 
105
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
106
-
107
119
  await service.start()
108
120
 
109
121
  expect(mockForkedEm.find).toHaveBeenCalledWith(ScheduledJob, {
@@ -114,21 +126,15 @@ describe('LocalSchedulerService', () => {
114
126
  limit: 100,
115
127
  orderBy: { nextRunAt: 'ASC' },
116
128
  })
117
-
118
- consoleLogSpy.mockRestore()
119
129
  })
120
130
 
121
131
  it('should not start if already running', async () => {
122
132
  mockForkedEm.find.mockResolvedValue([])
123
133
 
124
- const consoleWarnSpy = jest.spyOn(console, 'warn').mockImplementation()
125
-
126
134
  await service.start()
127
135
  await service.start()
128
136
 
129
- expect(consoleWarnSpy).toHaveBeenCalledWith('[scheduler:local] Already running')
130
-
131
- consoleWarnSpy.mockRestore()
137
+ expect(loggerWarn).toHaveBeenCalledWith('Polling engine already running')
132
138
  })
133
139
 
134
140
  it('should schedule recurring polls', async () => {
@@ -151,15 +157,11 @@ describe('LocalSchedulerService', () => {
151
157
  it('should stop polling engine', async () => {
152
158
  mockForkedEm.find.mockResolvedValue([])
153
159
 
154
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
155
-
156
160
  await service.start()
157
161
  await service.stop()
158
162
 
159
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] Stopping polling engine...')
160
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] ✓ Polling engine stopped')
161
-
162
- consoleLogSpy.mockRestore()
163
+ expect(loggerInfo).toHaveBeenCalledWith('Stopping polling engine')
164
+ expect(loggerInfo).toHaveBeenCalledWith('Polling engine stopped')
163
165
  })
164
166
 
165
167
  it('should clear poll timer', async () => {
@@ -201,38 +203,26 @@ describe('LocalSchedulerService', () => {
201
203
  })
202
204
  mockQueue.enqueue.mockResolvedValue(undefined as any)
203
205
 
204
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
205
-
206
206
  await service.start()
207
207
 
208
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] Found 1 due schedule(s)')
209
-
210
- consoleLogSpy.mockRestore()
208
+ expect(loggerInfo).toHaveBeenCalledWith('Found due schedules', { count: 1 })
211
209
  })
212
210
 
213
211
  it('should log when no schedules are due', async () => {
214
212
  mockForkedEm.find.mockResolvedValue([])
215
213
 
216
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
217
-
218
214
  await service.start()
219
215
 
220
- expect(consoleLogSpy).toHaveBeenCalledWith('[scheduler:local] No due schedules')
221
-
222
- consoleLogSpy.mockRestore()
216
+ expect(loggerDebug).toHaveBeenCalledWith('No due schedules')
223
217
  })
224
218
 
225
219
  it('should handle poll errors gracefully', async () => {
226
220
  const error = new Error('Database error')
227
221
  mockForkedEm.find.mockRejectedValue(error)
228
222
 
229
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
230
-
231
223
  await service.start()
232
224
 
233
- expect(consoleErrorSpy).toHaveBeenCalledWith('[scheduler:local] Poll failed:', error)
234
-
235
- consoleErrorSpy.mockRestore()
225
+ expect(loggerError).toHaveBeenCalledWith('Poll failed', { err: error })
236
226
  })
237
227
  })
238
228
 
@@ -260,16 +250,10 @@ describe('LocalSchedulerService', () => {
260
250
  mockForkedEm.find.mockResolvedValue([schedule])
261
251
  mockLockStrategy.runWithLock.mockResolvedValue({ acquired: false })
262
252
 
263
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
264
-
265
253
  await service.start()
266
254
 
267
- expect(consoleLogSpy).toHaveBeenCalledWith(
268
- '[scheduler:local] Schedule Test Schedule is already locked, skipping'
269
- )
255
+ expect(loggerDebug).toHaveBeenCalledWith('Schedule already locked, skipping')
270
256
  expect(mockEmitSchedulerEvent).not.toHaveBeenCalled()
271
-
272
- consoleLogSpy.mockRestore()
273
257
  })
274
258
 
275
259
  it('should execute queue target', async () => {
@@ -379,8 +363,6 @@ describe('LocalSchedulerService', () => {
379
363
  })
380
364
  mockQueue.enqueue.mockRejectedValue(error)
381
365
 
382
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
383
-
384
366
  await service.start()
385
367
 
386
368
  expect(mockEmitSchedulerEvent).toHaveBeenCalledWith(
@@ -391,8 +373,6 @@ describe('LocalSchedulerService', () => {
391
373
  error: 'Execution failed',
392
374
  })
393
375
  )
394
-
395
- consoleErrorSpy.mockRestore()
396
376
  })
397
377
 
398
378
  it('should update lastRunAt and nextRunAt', async () => {
@@ -426,8 +406,6 @@ describe('LocalSchedulerService', () => {
426
406
  })
427
407
  mockQueue.enqueue.mockRejectedValue(error)
428
408
 
429
- jest.spyOn(console, 'error').mockImplementation()
430
-
431
409
  await service.start()
432
410
 
433
411
  expect(mockLockStrategy.runWithLock).toHaveBeenCalledWith('schedule:test-1', expect.any(Function))
@@ -475,13 +453,9 @@ describe('LocalSchedulerService', () => {
475
453
  })
476
454
  mockRbacService.tenantHasFeature.mockResolvedValue(false)
477
455
 
478
- const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation()
479
-
480
456
  await service.start()
481
457
 
482
- expect(consoleLogSpy).toHaveBeenCalledWith(
483
- '[scheduler:local] Schedule Test Schedule skipped: missing feature test.feature'
484
- )
458
+ expect(loggerInfo).toHaveBeenCalledWith('Schedule skipped: missing required feature', { requireFeature: 'test.feature' })
485
459
  expect(mockEmitSchedulerEvent).toHaveBeenCalledWith(
486
460
  'scheduler.job.skipped',
487
461
  expect.objectContaining({
@@ -490,8 +464,6 @@ describe('LocalSchedulerService', () => {
490
464
  })
491
465
  )
492
466
  expect(mockQueue.enqueue).not.toHaveBeenCalled()
493
-
494
- consoleLogSpy.mockRestore()
495
467
  })
496
468
 
497
469
  it('should not check feature for system-scoped schedules', async () => {
@@ -527,8 +499,6 @@ describe('LocalSchedulerService', () => {
527
499
  })
528
500
  mockQueue.enqueue.mockRejectedValue(error)
529
501
 
530
- jest.spyOn(console, 'error').mockImplementation()
531
-
532
502
  await service.start()
533
503
 
534
504
  expect(mockForkedEm.flush).toHaveBeenCalled()
@@ -545,8 +515,6 @@ describe('LocalSchedulerService', () => {
545
515
  return { acquired: true }
546
516
  })
547
517
 
548
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
549
-
550
518
  await service.start()
551
519
 
552
520
  expect(mockEmitSchedulerEvent).toHaveBeenCalledWith(
@@ -555,8 +523,6 @@ describe('LocalSchedulerService', () => {
555
523
  error: 'Target queue is required for queue target type',
556
524
  })
557
525
  )
558
-
559
- consoleErrorSpy.mockRestore()
560
526
  })
561
527
 
562
528
  it('should throw if target command is missing for command target', async () => {
@@ -572,8 +538,6 @@ describe('LocalSchedulerService', () => {
572
538
  return { acquired: true }
573
539
  })
574
540
 
575
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
576
-
577
541
  await service.start()
578
542
 
579
543
  expect(mockEmitSchedulerEvent).toHaveBeenCalledWith(
@@ -582,8 +546,6 @@ describe('LocalSchedulerService', () => {
582
546
  error: 'Target command is required for command target type',
583
547
  })
584
548
  )
585
-
586
- consoleErrorSpy.mockRestore()
587
549
  })
588
550
 
589
551
  it('should pass payload to queue job', async () => {
@@ -2,6 +2,21 @@ import { SchedulerService, type ScheduleRegistration } from '../schedulerService
2
2
  import type { EntityManager } from '@mikro-orm/core'
3
3
  import { ScheduledJob } from '../../data/entities.js'
4
4
  import type { BullMQSchedulerService } from '../bullmqSchedulerService'
5
+ import { createLogger } from '@open-mercato/shared/lib/logger'
6
+
7
+ jest.mock('@open-mercato/shared/lib/logger', () => {
8
+ const mocked = {
9
+ debug: jest.fn(),
10
+ info: jest.fn(),
11
+ warn: jest.fn(),
12
+ error: jest.fn(),
13
+ child: jest.fn(),
14
+ }
15
+ mocked.child.mockImplementation(() => mocked)
16
+ return { createLogger: jest.fn(() => mocked) }
17
+ })
18
+
19
+ const loggerError = createLogger('scheduler').error as jest.Mock
5
20
 
6
21
  describe('SchedulerService', () => {
7
22
  let service: SchedulerService
@@ -128,16 +143,14 @@ describe('SchedulerService', () => {
128
143
  mockForkedEm.flush.mockResolvedValue()
129
144
  mockBullMQService.register.mockRejectedValue(new Error('BullMQ error'))
130
145
 
131
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
146
+ loggerError.mockClear()
132
147
 
133
148
  await expect(service.register(baseRegistration)).resolves.not.toThrow()
134
149
 
135
- expect(consoleErrorSpy).toHaveBeenCalledWith(
136
- '[scheduler] Failed to sync with BullMQ:',
137
- expect.any(Error)
150
+ expect(loggerError).toHaveBeenCalledWith(
151
+ 'Failed to sync with BullMQ',
152
+ { scheduleId: 'test-1', err: expect.any(Error) }
138
153
  )
139
-
140
- consoleErrorSpy.mockRestore()
141
154
  })
142
155
 
143
156
  it('should throw if next run calculation fails', async () => {
@@ -206,12 +219,14 @@ describe('SchedulerService', () => {
206
219
  mockForkedEm.flush.mockResolvedValue()
207
220
  mockBullMQService.unregister.mockRejectedValue(new Error('BullMQ error'))
208
221
 
209
- const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation()
222
+ loggerError.mockClear()
210
223
 
211
224
  await expect(service.unregister('test-1')).resolves.not.toThrow()
212
225
 
213
- expect(consoleErrorSpy).toHaveBeenCalled()
214
- consoleErrorSpy.mockRestore()
226
+ expect(loggerError).toHaveBeenCalledWith(
227
+ 'Failed to unregister from BullMQ',
228
+ { scheduleId: 'test-1', err: expect.any(Error) }
229
+ )
215
230
  })
216
231
 
217
232
  it('should do nothing if schedule does not exist', async () => {