@lota-sdk/core 0.4.9 → 0.4.10

package/src/queues/plan-agent-heartbeat.queue.ts

@@ -1,17 +1,21 @@
 import type { Job } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { PlanAgentHeartbeatServiceTag } from '../services/plan/plan-agent-heartbeat.service'
 import type { WorkerHandle } from '../workers/worker-utils'
 import { DEFAULT_JOB_RETENTION, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
+class PlanAgentHeartbeatQueueError extends Schema.TaggedErrorClass<PlanAgentHeartbeatQueueError>()(
+  '@lota-sdk/core/PlanAgentHeartbeatQueueError',
+  { message: Schema.String, cause: Schema.optional(Schema.Defect) },
+) {}
+
 export interface PlanAgentHeartbeatWakeJob {
   type: 'wake-node'
   organizationId: string
@@ -38,16 +42,6 @@ interface PlanAgentHeartbeatQueueDeps {
   planAgentHeartbeatService: Context.Service.Shape<typeof PlanAgentHeartbeatServiceTag>
 }
 
-let _deps: PlanAgentHeartbeatQueueDeps | null = null
-function getDeps(): PlanAgentHeartbeatQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Plan agent heartbeat queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
 function enqueueDelayedPlanAgentHeartbeatSweep(delayMs = PLAN_AGENT_HEARTBEAT_SWEEP_INTERVAL_MS): Promise<void> {
   return planAgentHeartbeatQueue.enqueue(
     { type: 'sweep' },
@@ -55,9 +49,11 @@ function enqueueDelayedPlanAgentHeartbeatSweep(delayMs = PLAN_AGENT_HEARTBEAT_SW
   )
 }
 
-function processPlanAgentHeartbeatJob(job: Job<PlanAgentHeartbeatJob>): Promise<void> {
-  const { planAgentHeartbeatService } = getDeps()
-
+function processPlanAgentHeartbeatJob(
+  deps: PlanAgentHeartbeatQueueDeps,
+  job: Job<PlanAgentHeartbeatJob>,
+): Promise<void> {
+  const { planAgentHeartbeatService } = deps
   return Effect.runPromise(
     Effect.gen(function* () {
       if (job.data.type === 'wake-node') {
@@ -68,20 +64,27 @@ function processPlanAgentHeartbeatJob(job: Job<PlanAgentHeartbeatJob>): Promise<
 
       yield* planAgentHeartbeatService.sweep({ organizationId: job.data.organizationId })
       if (!job.data.organizationId) {
-        yield* Effect.tryPromise(() => enqueueDelayedPlanAgentHeartbeatSweep())
+        yield* Effect.tryPromise({
+          try: () => enqueueDelayedPlanAgentHeartbeatSweep(),
+          catch: (cause) =>
+            new PlanAgentHeartbeatQueueError({
+              message: 'Failed to enqueue delayed plan-agent heartbeat sweep.',
+              cause,
+            }),
+        })
       }
     }),
   )
 }
 
-const planAgentHeartbeatQueue = createQueueFactory<PlanAgentHeartbeatJob>({
+const planAgentHeartbeatQueue = createQueueFactoryWithDeps<PlanAgentHeartbeatJob, PlanAgentHeartbeatQueueDeps>({
   name: PLAN_AGENT_HEARTBEAT_QUEUE,
   displayName: 'Plan agent heartbeat',
   jobName: 'plan-agent-heartbeat-job',
   concurrency: 2,
   lockDuration: LONG_JOB_LOCK_DURATION_MS,
   defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 5_000 } },
-  prepare: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processPlanAgentHeartbeatJob,
 })
 
@@ -113,8 +116,8 @@ export function startPlanAgentHeartbeatWorker(options: {
   connectionProvider: () => IORedis
   deps: PlanAgentHeartbeatQueueDeps
 }): WorkerHandle {
-  _deps = options.deps
   const handle = planAgentHeartbeatQueue.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

package/src/queues/plan-scheduler.queue.ts

@@ -4,7 +4,6 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { serverLogger } from '../config/logger'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { PlanCycleServiceTag } from '../services/plan/plan-cycle.service'
 import { PlanDeadlineServiceTag } from '../services/plan/plan-deadline.service'
@@ -12,7 +11,7 @@ import { PlanExecutorServiceTag } from '../services/plan/plan-executor.service'
 import { PlanSchedulerServiceTag } from '../services/plan/plan-scheduler.service'
 import { nowEpochMillis } from '../utils/date-time'
 import type { WorkerHandle } from '../workers/worker-utils'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 export interface PlanSchedulerFireJob {
@@ -37,16 +36,6 @@ interface PlanSchedulerQueueDeps {
   planCycleService: Context.Service.Shape<typeof PlanCycleServiceTag>
 }
 
-let _deps: PlanSchedulerQueueDeps | null = null
-function getDeps(): PlanSchedulerQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Plan scheduler queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
 class PlanSchedulerQueueError extends Schema.TaggedErrorClass<PlanSchedulerQueueError>()('PlanSchedulerQueueError', {
   stage: Schema.Literals(['remove-schedule-fire-job', 'recover-active-schedules', 'recover-deadline-checks']),
   message: Schema.String,
@@ -57,9 +46,8 @@ function toPlanSchedulerQueueError(stage: PlanSchedulerQueueError['stage'], caus
   return new PlanSchedulerQueueError({ stage, message: cause instanceof Error ? cause.message : String(cause), cause })
 }
 
-function processPlanSchedulerJob(job: Job<PlanSchedulerJob>): Promise<void> {
-  const { planSchedulerService, planDeadlineService, planExecutorService, planCycleService } = getDeps()
-
+function processPlanSchedulerJob(deps: PlanSchedulerQueueDeps, job: Job<PlanSchedulerJob>): Promise<void> {
+  const { planSchedulerService, planDeadlineService, planExecutorService, planCycleService } = deps
   switch (job.data.type) {
     case 'fire-schedule':
       return Effect.runPromise(
@@ -76,13 +64,13 @@ function processPlanSchedulerJob(job: Job<PlanSchedulerJob>): Promise<void> {
   }
 }
 
-const planScheduler = createQueueFactory<PlanSchedulerJob>({
+const planScheduler = createQueueFactoryWithDeps<PlanSchedulerJob, PlanSchedulerQueueDeps>({
   name: PLAN_SCHEDULER_QUEUE,
   displayName: 'Plan scheduler',
   jobName: 'plan-scheduler-job',
   concurrency: 1,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 5000 } },
-  prepare: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processPlanSchedulerJob,
 })
 
@@ -124,8 +112,8 @@ export function startPlanSchedulerWorker(options: {
   connectionProvider: () => IORedis
   deps: PlanSchedulerQueueDeps
 }): WorkerHandle {
-  _deps = options.deps
   const handle = planScheduler.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

package/src/queues/post-chat-memory.queue.ts

@@ -4,10 +4,9 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import type { MaybeAwaitableService } from '../effect/awaitable-effect'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { MemoryServiceTag } from '../services/memory/memory.service'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 interface PostChatMemoryMessage {
@@ -35,19 +34,8 @@ interface PostChatMemoryQueueDeps {
   memoryService: MaybeAwaitableService<Context.Service.Shape<typeof MemoryServiceTag>>
 }
 
-let _deps: PostChatMemoryQueueDeps | null = null
-function getDeps(): PostChatMemoryQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Post-chat memory queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
-function processPostChatMemoryJob(job: Job<PostChatMemoryExtractionJob>): Promise<void> {
-  const { memoryService } = getDeps()
-
+function processPostChatMemoryJob(deps: PostChatMemoryQueueDeps, job: Job<PostChatMemoryExtractionJob>): Promise<void> {
+  const { memoryService } = deps
   const data = job.data
   const userMessage = data.userMessage.trim()
   const agentMessages = data.agentMessages
@@ -93,7 +81,7 @@ function processPostChatMemoryJob(job: Job<PostChatMemoryExtractionJob>): Promis
   )
 }
 
-const postChatMemory = createQueueFactory<PostChatMemoryExtractionJob>({
+const postChatMemory = createQueueFactoryWithDeps<PostChatMemoryExtractionJob, PostChatMemoryQueueDeps>({
   name: 'post-chat-memory',
   displayName: 'Post-chat memory',
   jobName: 'extract-memory',
@@ -102,7 +90,7 @@ const postChatMemory = createQueueFactory<PostChatMemoryExtractionJob>({
   maxStalledCount: 10,
   stalledInterval: 120_000,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-  prepare: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processPostChatMemoryJob,
 })
 
@@ -115,8 +103,8 @@ export function startPostChatMemoryWorker(options: {
   connectionProvider: () => IORedis
   deps: PostChatMemoryQueueDeps
 }) {
-  _deps = options.deps
   return postChatMemory.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })

package/src/queues/queue-factory.ts

@@ -1,12 +1,13 @@
 import { Queue, Worker } from 'bullmq'
 import type { Job, JobsOptions, QueueOptions, WorkerOptions } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type IORedis from 'ioredis'
 
 import type { LotaLogger } from '../config/logger'
 import { serverLogger } from '../config/logger'
 import { getCurrentRuntime } from '../effect/runtime-ref'
 import { RedisServiceTag } from '../effect/services'
+import type { TrackedBullJobLike } from '../services/queue-job.service'
 import {
   attachWorkerEvents,
   createTracedWorkerProcessor,
@@ -17,11 +18,27 @@ import {
 } from '../workers/worker-utils'
 import type { WorkerHandle } from '../workers/worker-utils'
 
+class QueueFactoryError extends Schema.TaggedErrorClass<QueueFactoryError>()('@lota-sdk/core/QueueFactoryError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
 function getDefaultQueueConnectionProvider(): () => IORedis {
   const redis = getCurrentRuntime().runSync(Effect.service(RedisServiceTag))
   return () => redis.getConnectionForBullMQ()
 }
 
+type QueueShape<TJob> = Queue<TJob, unknown, string, TJob, unknown, string>
+type QueueMethod = 'add' | 'close' | 'remove' | 'removeDeduplicationKey' | 'removeJobScheduler'
+
+const queueMethodsThatWaitForClose = new Set<QueueMethod>([
+  'add',
+  'close',
+  'remove',
+  'removeDeduplicationKey',
+  'removeJobScheduler',
+])
+
 interface QueueFactoryConfigBase {
   name: string
   displayName: string
@@ -48,29 +65,72 @@ interface QueueFactoryConfigFile extends QueueFactoryConfigBase {
 
 export type QueueFactoryConfig<TJob> = QueueFactoryConfigInline<TJob> | QueueFactoryConfigFile
 
+interface QueueFactoryWithDepsConfig<TJob, TDeps> extends QueueFactoryConfigBase {
+  prepare?: (deps: TDeps, job: Job<TJob>) => Promise<void>
+  processor: (deps: TDeps, job: Job<TJob>) => Promise<unknown>
+}
+
+interface QueueWorkerConfigInline<TJob> {
+  prepare?: (job: Job<TJob>) => Promise<void>
+  processor: (job: Job<TJob>) => Promise<unknown>
+  processorPath?: never
+}
+
+interface QueueWorkerConfigFile {
+  processor?: never
+  processorPath: string
+}
+
+type QueueWorkerConfig<TJob> = QueueWorkerConfigInline<TJob> | QueueWorkerConfigFile
+
+export interface QueueFactoryWorkerOptions {
+  registerSignals?: boolean
+  connectionProvider?: () => IORedis
+}
+
 export interface QueueFactory<TJob> {
-  getQueue: () => Queue<TJob, unknown, string, TJob, unknown, string>
+  getQueue: () => QueueShape<TJob>
   enqueue: (job: TJob, options?: JobsOptions) => Promise<void>
-  startWorker: (options?: { registerSignals?: boolean; connectionProvider?: () => IORedis }) => WorkerHandle
+  startWorker: (options?: QueueFactoryWorkerOptions) => WorkerHandle
 }
 
-export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): QueueFactory<TJob> {
-  type QueueShape = Queue<TJob, unknown, string, TJob, unknown, string>
-  type QueueMethod = 'add' | 'close' | 'remove' | 'removeDeduplicationKey' | 'removeJobScheduler'
-  const queueMethodsThatWaitForClose = new Set<QueueMethod>([
-    'add',
-    'close',
-    'remove',
-    'removeDeduplicationKey',
-    'removeJobScheduler',
-  ])
-
-  let state: {
-    queue: QueueShape | null
-    rawQueue: QueueShape | null
+export interface QueueFactoryWithDeps<TJob, TDeps> {
+  getQueue: () => QueueShape<TJob>
+  enqueue: (job: TJob, options?: JobsOptions) => Promise<void>
+  startWorker: (options: QueueFactoryWorkerOptions & { deps: TDeps }) => WorkerHandle
+}
+
+export function recordEnqueuedJobMetadata(params: {
+  queueName: string
+  job: Omit<TrackedBullJobLike, 'queueName'>
+  logger?: LotaLogger
+}): Effect.Effect<string | undefined> {
+  const logger = params.logger ?? serverLogger
+  return getQueueJobService()
+    .recordEnqueued({ queueName: params.queueName, ...params.job })
+    .pipe(
+      Effect.tapError((error) =>
+        Effect.sync(() => {
+          logger.error`Failed to persist queued job metadata (queue=${params.queueName}, job=${params.job.id}): ${error}`
+        }),
+      ),
+      Effect.orElseSucceed(() => undefined),
+    )
+}
+
+function createQueueFactoryRuntime<TJob>(config: QueueFactoryConfigBase): {
+  getQueue: () => QueueShape<TJob>
+  enqueue: (job: TJob, options?: JobsOptions) => Promise<void>
+  startWorker: (workerConfig: QueueWorkerConfig<TJob>, options?: QueueFactoryWorkerOptions) => WorkerHandle
+} {
+  type State = {
+    queue: QueueShape<TJob> | null
+    rawQueue: QueueShape<TJob> | null
     connection: IORedis | null
     pendingClose: Promise<void> | null
-  } = { queue: null, rawQueue: null, connection: null, pendingClose: null }
+  }
+
+  let state: State = { queue: null, rawQueue: null, connection: null, pendingClose: null }
 
   const resolveConnectionProvider = (): (() => IORedis) =>
     config.connectionProvider ?? getDefaultQueueConnectionProvider()
@@ -90,7 +150,7 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
     })
   }
 
-  const wrapQueue = (queue: QueueShape): QueueShape =>
+  const wrapQueue = (queue: QueueShape<TJob>): QueueShape<TJob> =>
     new Proxy(queue, {
       get(target, property, receiver) {
         if (typeof property !== 'string') {
@@ -109,7 +169,7 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
       },
     })
 
-  const getQueue = (): QueueShape => {
+  const getQueue = (): QueueShape<TJob> => {
     const connection = getConnection()
     const isStale =
       state.rawQueue === null ||
@@ -146,36 +206,21 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
     return wrappedQueue
   }
 
-  const jobName = config.jobName
-  const toData = (job: TJob) => job
-
   const enqueue = (job: TJob, options?: JobsOptions): Promise<void> =>
     Effect.runPromise(
       Effect.gen(function* () {
-        const queuedJob = yield* Effect.tryPromise(() => getQueue().add(jobName, toData(job), options))
-        yield* getQueueJobService()
-          .recordEnqueued({
-            queueName: config.name,
-            id: queuedJob.id,
-            name: queuedJob.name,
-            data: queuedJob.data,
-            opts: queuedJob.opts,
-            attemptsMade: queuedJob.attemptsMade,
-            timestamp: queuedJob.timestamp,
-          })
-          .pipe(
-            Effect.tapError((error) =>
-              Effect.sync(() => {
-                serverLogger.error`Failed to persist queued job metadata (queue=${config.name}, job=${queuedJob.id}): ${error}`
-              }),
-            ),
-            Effect.orElseSucceed(() => undefined),
-          )
+        const queuedJob = yield* Effect.tryPromise({
+          try: () => getQueue().add(config.jobName, job, options),
+          catch: (cause) =>
+            new QueueFactoryError({ message: `Failed to enqueue job on queue "${config.name}".`, cause }),
+        })
+        yield* recordEnqueuedJobMetadata({ queueName: config.name, job: queuedJob, logger: config.logger })
       }),
     )
 
   const startWorker = (
-    options: { registerSignals?: boolean; connectionProvider?: () => IORedis } = {},
+    workerConfig: QueueWorkerConfig<TJob>,
+    options: QueueFactoryWorkerOptions = {},
   ): WorkerHandle => {
     const { registerSignals = import.meta.main, connectionProvider } = options
     const logger = config.logger ?? serverLogger
@@ -188,21 +233,28 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
       ...(config.maxStalledCount !== undefined ? { maxStalledCount: config.maxStalledCount } : {}),
     }
 
-    const worker = config.processorPath
-      ? new Worker(config.name, config.processorPath, workerOptions)
+    const worker = workerConfig.processorPath
+      ? new Worker(config.name, workerConfig.processorPath, workerOptions)
       : new Worker(
           config.name,
           createTracedWorkerProcessor(config.name, (job) =>
             Effect.runPromise(
               Effect.gen(function* () {
-                const inlineConfig = config as QueueFactoryConfigInline<TJob>
+                const inlineWorkerConfig = workerConfig as QueueWorkerConfigInline<TJob>
                 const typedJob = job as Job<TJob>
-                const prepare = inlineConfig.prepare
+                const prepare = inlineWorkerConfig.prepare
                 if (prepare) {
-                  yield* Effect.tryPromise(() => prepare(typedJob))
+                  yield* Effect.tryPromise({
+                    try: () => prepare(typedJob),
+                    catch: (cause) =>
+                      new QueueFactoryError({ message: `Worker prepare failed for queue "${config.name}".`, cause }),
+                  })
                 }
-                const processor = inlineConfig.processor
-                return yield* Effect.tryPromise(() => processor(typedJob))
+                return yield* Effect.tryPromise({
+                  try: () => inlineWorkerConfig.processor(typedJob),
+                  catch: (cause) =>
+                    new QueueFactoryError({ message: `Worker processor failed for queue "${config.name}".`, cause }),
+                })
               }),
             ),
           ),
@@ -222,3 +274,29 @@ export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): Queu
 
   return { getQueue, enqueue, startWorker }
 }
+
+export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): QueueFactory<TJob> {
+  const runtime = createQueueFactoryRuntime<TJob>(config)
+  return {
+    getQueue: runtime.getQueue,
+    enqueue: runtime.enqueue,
+    startWorker: (options) => runtime.startWorker(config, options),
+  }
+}
+
+export function createQueueFactoryWithDeps<TJob, TDeps>(
+  config: QueueFactoryWithDepsConfig<TJob, TDeps>,
+): QueueFactoryWithDeps<TJob, TDeps> {
+  const runtime = createQueueFactoryRuntime<TJob>(config)
+  const prepare = config.prepare
+
+  return {
+    getQueue: runtime.getQueue,
+    enqueue: runtime.enqueue,
+    startWorker: ({ deps, ...options }) =>
+      runtime.startWorker(
+        { prepare: prepare ? (job) => prepare(deps, job) : undefined, processor: (job) => config.processor(deps, job) },
+        options,
+      ),
+  }
+}

package/src/queues/title-generation.queue.ts

@@ -4,11 +4,10 @@ import type { Context } from 'effect'
 import type IORedis from 'ioredis'
 
 import { ensureRecordId } from '../db/record-id'
-import { ConfigurationError } from '../effect/errors'
 import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
 import { RecentActivityTitleServiceTag } from '../services/recent-activity-title.service'
 import { ThreadTitleServiceTag } from '../services/thread/thread-title.service'
-import { createQueueFactory } from './queue-factory'
+import { createQueueFactoryWithDeps } from './queue-factory'
 import { runStandaloneQueueWorker } from './standalone-worker'
 
 export const TITLE_GENERATION_QUEUE = 'title-generation'
@@ -36,18 +35,8 @@ interface TitleGenerationQueueDeps {
   recentActivityTitleService: Context.Service.Shape<typeof RecentActivityTitleServiceTag>
 }
 
-let _deps: TitleGenerationQueueDeps | null = null
-function getDeps(): TitleGenerationQueueDeps {
-  if (!_deps)
-    throw new ConfigurationError({
-      message: 'Title generation queue is not configured. Initialize the runtime before starting the worker.',
-      key: 'queue-deps',
-    })
-  return _deps
-}
-
-function processTitleGenerationJob(job: Job<TitleGenerationJob>): Promise<void> {
-  const { threadTitleService, recentActivityTitleService } = getDeps()
+function processTitleGenerationJob(deps: TitleGenerationQueueDeps, job: Job<TitleGenerationJob>): Promise<void> {
+  const { threadTitleService, recentActivityTitleService } = deps
   if (job.data.kind === 'thread-title') {
     return Effect.runPromise(
       Effect.asVoid(threadTitleService.generateAndPersistTitle(ensureRecordId(job.data.threadId), job.data.sourceText)),
@@ -57,14 +46,14 @@ function processTitleGenerationJob(job: Job<TitleGenerationJob>): Promise<void>
   return Effect.runPromise(Effect.asVoid(recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)))
 }
 
-const titleGeneration = createQueueFactory<TitleGenerationJob>({
+const titleGeneration = createQueueFactoryWithDeps<TitleGenerationJob, TitleGenerationQueueDeps>({
   name: TITLE_GENERATION_QUEUE,
   displayName: 'Title generation',
   jobName: 'title-generation',
   concurrency: 10,
   lockDuration: 300_000,
   defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-  prepare: () => getDeps().databaseService.connect(),
+  prepare: ({ databaseService }) => databaseService.connect(),
   processor: processTitleGenerationJob,
 })
 
@@ -84,8 +73,8 @@ export function startTitleGenerationWorker(options: {
   connectionProvider: () => IORedis
   deps: TitleGenerationQueueDeps
 }): ReturnType<typeof titleGeneration.startWorker> {
-  _deps = options.deps
   return titleGeneration.startWorker({
+    deps: options.deps,
     registerSignals: options.registerSignals,
     connectionProvider: options.connectionProvider,
   })