@lota-sdk/core 0.1.15 → 0.1.17

package/src/queues/queue-factory.ts

@@ -0,0 +1,100 @@
+import { Queue, Worker } from 'bullmq'
+import type { Job, JobsOptions, WorkerOptions } from 'bullmq'
+import type IORedis from 'ioredis'
+
+import { serverLogger } from '../config/logger'
+import { getRedisConnectionForBullMQ } from '../redis'
+import {
+  attachWorkerEvents,
+  createTracedWorkerProcessor,
+  createWorkerShutdown,
+  DEFAULT_JOB_RETENTION,
+  registerShutdownSignals,
+} from '../workers/worker-utils'
+import type { WorkerHandle } from '../workers/worker-utils'
+
+interface QueueFactoryConfigBase {
+  name: string
+  displayName: string
+  jobName: string
+  concurrency: number
+  lockDuration?: number
+  stalledInterval?: number
+  maxStalledCount?: number
+  defaultJobOptions?: JobsOptions
+  connectionProvider?: () => IORedis
+}
+
+interface QueueFactoryConfigInline<TJob> extends QueueFactoryConfigBase {
+  processor: (job: Job<TJob>) => Promise<void>
+  processorPath?: never
+}
+
+interface QueueFactoryConfigFile extends QueueFactoryConfigBase {
+  processor?: never
+  processorPath: string
+}
+
+export type QueueFactoryConfig<TJob> = QueueFactoryConfigInline<TJob> | QueueFactoryConfigFile
+
+export interface QueueFactory<TJob> {
+  getQueue: () => Queue<TJob, unknown, string>
+  enqueue: (job: TJob, options?: JobsOptions) => Promise<void>
+  startWorker: (options?: { registerSignals?: boolean }) => WorkerHandle
+}
+
+export function createQueueFactory<TJob>(config: QueueFactoryConfig<TJob>): QueueFactory<TJob> {
+  let _queue: Queue<TJob, unknown, string> | null = null
+
+  const getConnection = () => config.connectionProvider?.() ?? getRedisConnectionForBullMQ()
+
+  const getQueue = (): Queue<TJob, unknown, string> => {
+    if (!_queue) {
+      _queue = new Queue<TJob, unknown, string>(config.name, {
+        connection: getConnection(),
+        defaultJobOptions: { ...DEFAULT_JOB_RETENTION, ...config.defaultJobOptions },
+      })
+    }
+    return _queue
+  }
+
+  type QueueAdd = Queue<TJob, unknown, string>['add']
+  const jobName = config.jobName as Parameters<QueueAdd>[0]
+  const toData = (job: TJob) => job as Parameters<QueueAdd>[1]
+
+  const enqueue = async (job: TJob, options?: JobsOptions): Promise<void> => {
+    await getQueue().add(jobName, toData(job), options)
+  }
+
+  const startWorker = (options: { registerSignals?: boolean } = {}): WorkerHandle => {
+    const { registerSignals = import.meta.main } = options
+
+    const workerOptions: WorkerOptions = {
+      connection: getConnection(),
+      concurrency: config.concurrency,
+      ...(config.lockDuration !== undefined ? { lockDuration: config.lockDuration } : {}),
+      ...(config.stalledInterval !== undefined ? { stalledInterval: config.stalledInterval } : {}),
+      ...(config.maxStalledCount !== undefined ? { maxStalledCount: config.maxStalledCount } : {}),
+    }
+
+    const worker = config.processorPath
+      ? new Worker(config.name, config.processorPath, workerOptions)
+      : new Worker(
+          config.name,
+          createTracedWorkerProcessor(config.name, (config as QueueFactoryConfigInline<TJob>).processor),
+          workerOptions,
+        )
+
+    attachWorkerEvents(worker, config.displayName, serverLogger)
+
+    const shutdown = createWorkerShutdown(worker, config.displayName, serverLogger)
+
+    if (registerSignals) {
+      registerShutdownSignals({ name: config.displayName, shutdown, logger: serverLogger })
+    }
+
+    return { worker, shutdown }
+  }
+
+  return { getQueue, enqueue, startWorker }
+}

package/src/queues/recent-activity-title-refinement.queue.ts

@@ -1,65 +1,30 @@
-import { Queue, Worker } from 'bullmq'
 import type { Job } from 'bullmq'
 
-import { serverLogger } from '../config/logger'
 import { databaseService } from '../db/service'
-import { getRedisConnectionForBullMQ } from '../redis'
 import { recentActivityTitleService } from '../services/recent-activity-title.service'
-import {
-  attachWorkerEvents,
-  createTracedWorkerProcessor,
-  createWorkerShutdown,
-  DEFAULT_JOB_RETENTION,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 
 interface RecentActivityTitleRefinementJob {
   activityId: string
 }
 
-const RECENT_ACTIVITY_TITLE_REFINEMENT_QUEUE = 'recent-activity-title-refinement'
-
-let _recentActivityTitleRefinementQueue: Queue<RecentActivityTitleRefinementJob> | null = null
-function getRecentActivityTitleRefinementQueue(): Queue<RecentActivityTitleRefinementJob> {
-  if (!_recentActivityTitleRefinementQueue) {
-    _recentActivityTitleRefinementQueue = new Queue<RecentActivityTitleRefinementJob>(
-      RECENT_ACTIVITY_TITLE_REFINEMENT_QUEUE,
-      {
-        connection: getRedisConnectionForBullMQ(),
-        defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
-      },
-    )
-  }
-  return _recentActivityTitleRefinementQueue
-}
-
-export async function enqueueRecentActivityTitleRefinement(job: RecentActivityTitleRefinementJob) {
-  return await getRecentActivityTitleRefinementQueue().add('refine-recent-activity-title', job, {
-    jobId: `recent-activity-title:${job.activityId}`,
-  })
-}
-
 async function processRecentActivityTitleRefinementJob(job: Job<RecentActivityTitleRefinementJob>): Promise<void> {
   await databaseService.connect()
   await recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)
 }
 
-export function startRecentActivityTitleRefinementWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const worker = new Worker(
-    RECENT_ACTIVITY_TITLE_REFINEMENT_QUEUE,
-    createTracedWorkerProcessor(RECENT_ACTIVITY_TITLE_REFINEMENT_QUEUE, processRecentActivityTitleRefinementJob),
-    { connection: getRedisConnectionForBullMQ(), concurrency: 2, lockDuration: 300_000 },
-  )
-
-  attachWorkerEvents(worker, 'Recent activity title refinement', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Recent activity title refinement', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Recent activity title refinement', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
+const recentActivityTitleRefinement = createQueueFactory<RecentActivityTitleRefinementJob>({
+  name: 'recent-activity-title-refinement',
+  displayName: 'Recent activity title refinement',
+  jobName: 'refine-recent-activity-title',
+  concurrency: 10,
+  lockDuration: 300_000,
+  defaultJobOptions: { attempts: 3, backoff: { type: 'exponential', delay: 2_000 } },
+  processor: processRecentActivityTitleRefinementJob,
+})
+
+export function enqueueRecentActivityTitleRefinement(job: RecentActivityTitleRefinementJob) {
+  return recentActivityTitleRefinement.enqueue(job, { jobId: `recent-activity-title:${job.activityId}` })
 }
+
+export const startRecentActivityTitleRefinementWorker = recentActivityTitleRefinement.startWorker

package/src/queues/regular-chat-memory-digest.queue.ts

@@ -1,16 +1,5 @@
-import { Queue, Worker } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import { getRedisConnectionForBullMQ } from '../redis'
-import {
-  attachWorkerEvents,
-  DEFAULT_JOB_RETENTION,
-  getWorkerPath,
-  LONG_JOB_LOCK_DURATION_MS,
-  createWorkerShutdown,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { getWorkerPath, LONG_JOB_LOCK_DURATION_MS } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 import {
   buildRegularChatMemoryDigestDeduplicationId,
   buildRegularChatMemoryDigestJobOptions,
@@ -20,50 +9,25 @@ export interface RegularChatMemoryDigestJob {
   orgId: string
 }
 
-const REGULAR_CHAT_MEMORY_DIGEST_QUEUE = 'regular-chat-memory-digest'
-
-let _regularChatMemoryDigestQueue: Queue<RegularChatMemoryDigestJob> | null = null
-function getRegularChatMemoryDigestQueue(): Queue<RegularChatMemoryDigestJob> {
-  if (!_regularChatMemoryDigestQueue) {
-    _regularChatMemoryDigestQueue = new Queue<RegularChatMemoryDigestJob>(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-    })
-  }
-  return _regularChatMemoryDigestQueue
-}
-
-export async function enqueueRegularChatMemoryDigest(job: RegularChatMemoryDigestJob) {
-  return await getRegularChatMemoryDigestQueue().add(
-    'run-digest',
-    job,
-    buildRegularChatMemoryDigestJobOptions(job.orgId),
-  )
+const regularChatMemoryDigest = createQueueFactory<RegularChatMemoryDigestJob>({
+  name: 'regular-chat-memory-digest',
+  displayName: 'Regular chat memory digest',
+  jobName: 'run-digest',
+  concurrency: 1,
+  lockDuration: LONG_JOB_LOCK_DURATION_MS,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+  processorPath: getWorkerPath('regular-chat-memory-digest.worker.ts'),
+})
+
+export function enqueueRegularChatMemoryDigest(job: RegularChatMemoryDigestJob) {
+  return regularChatMemoryDigest.enqueue(job, buildRegularChatMemoryDigestJobOptions(job.orgId))
 }
 
 export async function clearRegularChatMemoryDigestDeduplicationKey(orgId: string): Promise<void> {
-  await getRegularChatMemoryDigestQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
+  await regularChatMemoryDigest.getQueue().removeDeduplicationKey(buildRegularChatMemoryDigestDeduplicationId(orgId))
 }
 
-export function startRegularChatMemoryDigestWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const processorPath = getWorkerPath('regular-chat-memory-digest.worker.ts')
-  const worker = new Worker(REGULAR_CHAT_MEMORY_DIGEST_QUEUE, processorPath, {
-    connection: getRedisConnectionForBullMQ(),
-    concurrency: 1,
-    lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  })
-
-  attachWorkerEvents(worker, 'Regular chat memory digest', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Regular chat memory digest', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Regular chat memory digest', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
-}
+export const startRegularChatMemoryDigestWorker = regularChatMemoryDigest.startWorker
 
 if (import.meta.main) {
   startRegularChatMemoryDigestWorker()

package/src/queues/skill-extraction.queue.ts

@@ -1,58 +1,26 @@
-import { Queue, Worker } from 'bullmq'
-
-import { serverLogger } from '../config/logger'
-import { getRedisConnectionForBullMQ } from '../redis'
-import {
-  attachWorkerEvents,
-  DEFAULT_JOB_RETENTION,
-  getWorkerPath,
-  LONG_JOB_LOCK_DURATION_MS,
-  createWorkerShutdown,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { getWorkerPath } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 import { buildSkillExtractionJobOptions } from './skill-extraction.config'
 
 export interface SkillExtractionJob {
   orgId: string
 }
 
-const SKILL_EXTRACTION_QUEUE = 'skill-extraction'
-
-let _skillExtractionQueue: Queue<SkillExtractionJob> | null = null
-function getSkillExtractionQueue(): Queue<SkillExtractionJob> {
-  if (!_skillExtractionQueue) {
-    _skillExtractionQueue = new Queue<SkillExtractionJob>(SKILL_EXTRACTION_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
-    })
-  }
-  return _skillExtractionQueue
+const skillExtraction = createQueueFactory<SkillExtractionJob>({
+  name: 'skill-extraction',
+  displayName: 'Skill extraction',
+  jobName: 'run-extraction',
+  concurrency: 10,
+  lockDuration: 600_000,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 5000 } },
+  processorPath: getWorkerPath('skill-extraction.worker.ts'),
+})
+
+export function enqueueSkillExtraction(job: SkillExtractionJob) {
+  return skillExtraction.enqueue(job, buildSkillExtractionJobOptions(job.orgId))
 }
 
-export async function enqueueSkillExtraction(job: SkillExtractionJob) {
-  return await getSkillExtractionQueue().add('run-extraction', job, buildSkillExtractionJobOptions(job.orgId))
-}
-
-export function startSkillExtractionWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const processorPath = getWorkerPath('skill-extraction.worker.ts')
-  const worker = new Worker(SKILL_EXTRACTION_QUEUE, processorPath, {
-    connection: getRedisConnectionForBullMQ(),
-    concurrency: 1,
-    lockDuration: LONG_JOB_LOCK_DURATION_MS,
-  })
-
-  attachWorkerEvents(worker, 'Skill extraction', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Skill extraction', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Skill extraction', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
-}
+export const startSkillExtractionWorker = skillExtraction.startWorker
 
 if (import.meta.main) {
   startSkillExtractionWorker()

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

@@ -1,65 +1,33 @@
-import { Queue, Worker } from 'bullmq'
 import type { Job } from 'bullmq'
 
-import { serverLogger } from '../config/logger'
 import { ensureRecordId } from '../db/record-id'
 import { databaseService } from '../db/service'
-import { getRedisConnectionForBullMQ } from '../redis'
 import { workstreamTitleService } from '../services/workstream-title.service'
-import {
-  attachWorkerEvents,
-  createTracedWorkerProcessor,
-  createWorkerShutdown,
-  DEFAULT_JOB_RETENTION,
-  registerShutdownSignals,
-} from '../workers/worker-utils'
-import type { WorkerHandle } from '../workers/worker-utils'
+import { createQueueFactory } from './queue-factory'
 
 interface WorkstreamTitleGenerationJob {
   workstreamId: string
   sourceText: string
 }
 
-const WORKSTREAM_TITLE_GENERATION_QUEUE = 'workstream-title-generation'
-
-let _workstreamTitleGenerationQueue: Queue<WorkstreamTitleGenerationJob> | null = null
-function getWorkstreamTitleGenerationQueue(): Queue<WorkstreamTitleGenerationJob> {
-  if (!_workstreamTitleGenerationQueue) {
-    _workstreamTitleGenerationQueue = new Queue<WorkstreamTitleGenerationJob>(WORKSTREAM_TITLE_GENERATION_QUEUE, {
-      connection: getRedisConnectionForBullMQ(),
-      defaultJobOptions: { ...DEFAULT_JOB_RETENTION, attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
-    })
-  }
-  return _workstreamTitleGenerationQueue
-}
-
-export async function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
-  return await getWorkstreamTitleGenerationQueue().add('generate-workstream-title', job, {
-    jobId: `workstream-title:${job.workstreamId}`,
-  })
-}
-
 async function processWorkstreamTitleGenerationJob(job: Job<WorkstreamTitleGenerationJob>): Promise<void> {
   await databaseService.connect()
   const workstreamRef = ensureRecordId(job.data.workstreamId)
   await workstreamTitleService.generateAndPersistTitle(workstreamRef, job.data.sourceText)
 }
 
-export function startWorkstreamTitleGenerationWorker(options: { registerSignals?: boolean } = {}): WorkerHandle {
-  const { registerSignals = import.meta.main } = options
-  const worker = new Worker(
-    WORKSTREAM_TITLE_GENERATION_QUEUE,
-    createTracedWorkerProcessor(WORKSTREAM_TITLE_GENERATION_QUEUE, processWorkstreamTitleGenerationJob),
-    { connection: getRedisConnectionForBullMQ(), concurrency: 2, lockDuration: 60_000 },
-  )
-
-  attachWorkerEvents(worker, 'Workstream title generation', serverLogger)
-
-  const shutdown = createWorkerShutdown(worker, 'Workstream title generation', serverLogger)
-
-  if (registerSignals) {
-    registerShutdownSignals({ name: 'Workstream title generation', shutdown, logger: serverLogger })
-  }
-
-  return { worker, shutdown }
+const workstreamTitleGeneration = createQueueFactory<WorkstreamTitleGenerationJob>({
+  name: 'workstream-title-generation',
+  displayName: 'Workstream title generation',
+  jobName: 'generate-workstream-title',
+  concurrency: 10,
+  lockDuration: 60_000,
+  defaultJobOptions: { attempts: 2, backoff: { type: 'exponential', delay: 2_000 } },
+  processor: processWorkstreamTitleGenerationJob,
+})
+
+export function enqueueWorkstreamTitleGeneration(job: WorkstreamTitleGenerationJob) {
+  return workstreamTitleGeneration.enqueue(job, { jobId: `workstream-title:${job.workstreamId}` })
 }
+
+export const startWorkstreamTitleGenerationWorker = workstreamTitleGeneration.startWorker

package/src/redis/connection.ts

@@ -58,6 +58,7 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
   private healthCheckInterval: ReturnType<typeof setInterval> | null = null
   private isInitialized = false
   private isClosing = false
+  private isHealthCheckRunning = false
 
   constructor(private readonly options: CreateRedisConnectionManagerOptions) {
     this.initializeConnection()
@@ -128,6 +129,8 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
 
     const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
     this.healthCheckInterval = setInterval(async () => {
+      if (this.isHealthCheckRunning) return
+      this.isHealthCheckRunning = true
       try {
         if (this.redis && this.redis.status === 'ready') {
           await this.redis.ping()
@@ -136,8 +139,11 @@ class RedisConnectionManagerImpl implements RedisConnectionManager {
       } catch (error) {
         log(this.options.logger, 'warn', `Redis health check failed: ${getErrorMessage(error)}`)
         this.isHealthy = false
+      } finally {
+        this.isHealthCheckRunning = false
       }
     }, intervalMs)
+    this.healthCheckInterval.unref()
   }
 
   getConnection(): IORedis {

package/src/redis/index.ts

@@ -9,7 +9,7 @@ export {
 } from './connection-accessor'
 export { withOrgMemoryLock } from './org-memory-lock'
 export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
-export { createWorkstreamResumableContext } from './stream-context'
+export { closeSharedSubscriber, createWorkstreamResumableContext } from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }

package/src/redis/redis-lease-lock.ts

@@ -1,4 +1,3 @@
-import { randomUUID } from 'node:crypto'
 import { setTimeout as delay } from 'node:timers/promises'
 
 import type IORedis from 'ioredis'
@@ -147,7 +146,7 @@ export async function withRedisLeaseLock<T>(
   const heldInfoThresholdMs = options.heldInfoThresholdMs ?? 5_000
   const label = options.label ?? 'redis lease lock'
 
-  const lockValue = randomUUID()
+  const lockValue = crypto.randomUUID()
   const waitStart = Date.now()
   await acquireLeaseLock({ ...options, lockKey, lockValue, label, retryDelayMs, waitLogIntervalMs, maxWaitMs })
   const waitedMs = Date.now() - waitStart

package/src/redis/stream-context.ts

@@ -44,6 +44,17 @@ function getSharedSubscriber(): Subscriber {
   return sharedSubscriber.subscriber
 }
 
+export async function closeSharedSubscriber(): Promise<void> {
+  if (!sharedSubscriber) return
+  const { client } = sharedSubscriber
+  sharedSubscriber = undefined
+  try {
+    await client.quit()
+  } catch {
+    client.disconnect()
+  }
+}
+
 export function createWorkstreamResumableContext() {
   const redis = getRedisConnection()
   return createResumableStreamContext({