@lota-sdk/core 0.4.8 → 0.4.10

package/src/queues/standalone-worker.ts

@@ -0,0 +1,39 @@
+import type { ManagedRuntime } from 'effect'
+import { Schema, Effect } from 'effect'
+
+import { serverLogger } from '../config/logger'
+import { initializeSandboxedWorkerRuntime } from '../workers/bootstrap'
+
+class StandaloneQueueWorkerError extends Schema.TaggedErrorClass<StandaloneQueueWorkerError>()(
+  'StandaloneQueueWorkerError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+function toStandaloneQueueWorkerError(cause: unknown): StandaloneQueueWorkerError {
+  return new StandaloneQueueWorkerError({ message: cause instanceof Error ? cause.message : String(cause), cause })
+}
+
+// eslint-disable-next-line typescript-eslint/no-explicit-any -- wildcard for host-provided ManagedRuntime
+export function runStandaloneQueueWorker(start: (runtime: ManagedRuntime.ManagedRuntime<any, any>) => void): void {
+  if (!import.meta.main) {
+    return
+  }
+
+  void Effect.runFork(
+    Effect.gen(function* () {
+      const runtime = yield* Effect.tryPromise({
+        try: () => initializeSandboxedWorkerRuntime(),
+        catch: (cause) => toStandaloneQueueWorkerError(cause),
+      })
+
+      yield* Effect.sync(() => start(runtime))
+    }).pipe(
+      Effect.catchTag('StandaloneQueueWorkerError', (error) =>
+        Effect.sync(() => {
+          serverLogger.error`Standalone queue worker failed: ${error.message}`
+          process.exit(1)
+        }),
+      ),
+    ),
+  )
+}

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

@@ -1,10 +1,14 @@
 import type { Job } from 'bullmq'
+import { Effect } from 'effect'
+import type { Context } from 'effect'
+import type IORedis from 'ioredis'
 
 import { ensureRecordId } from '../db/record-id'
-import { databaseService } from '../db/service'
-import { recentActivityTitleService } from '../services/recent-activity-title.service'
-import { threadTitleService } from '../services/thread-title.service'
-import { createQueueFactory } from './queue-factory'
+import { DatabaseServiceTag, RedisServiceTag } from '../effect/services'
+import { RecentActivityTitleServiceTag } from '../services/recent-activity-title.service'
+import { ThreadTitleServiceTag } from '../services/thread/thread-title.service'
+import { createQueueFactoryWithDeps } from './queue-factory'
+import { runStandaloneQueueWorker } from './standalone-worker'
 
 export const TITLE_GENERATION_QUEUE = 'title-generation'
 
@@ -25,23 +29,31 @@ interface RecentActivityTitleRefinementJob {
 
 type TitleGenerationJob = ThreadTitleGenerationJob | RecentActivityTitleRefinementJob
 
-async function processTitleGenerationJob(job: Job<TitleGenerationJob>): Promise<void> {
-  await databaseService.connect()
+interface TitleGenerationQueueDeps {
+  databaseService: Context.Service.Shape<typeof DatabaseServiceTag>
+  threadTitleService: Context.Service.Shape<typeof ThreadTitleServiceTag>
+  recentActivityTitleService: Context.Service.Shape<typeof RecentActivityTitleServiceTag>
+}
+
+function processTitleGenerationJob(deps: TitleGenerationQueueDeps, job: Job<TitleGenerationJob>): Promise<void> {
+  const { threadTitleService, recentActivityTitleService } = deps
   if (job.data.kind === 'thread-title') {
-    await threadTitleService.generateAndPersistTitle(ensureRecordId(job.data.threadId), job.data.sourceText)
-    return
+    return Effect.runPromise(
+      Effect.asVoid(threadTitleService.generateAndPersistTitle(ensureRecordId(job.data.threadId), job.data.sourceText)),
+    )
   }
 
-  await recentActivityTitleService.refineRecentActivityTitle(job.data.activityId)
+  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: ({ databaseService }) => databaseService.connect(),
   processor: processTitleGenerationJob,
 })
 
@@ -56,4 +68,26 @@ export function enqueueRecentActivityTitleRefinement(job: Omit<RecentActivityTit
   )
 }
 
-export const startTitleGenerationWorker = titleGeneration.startWorker
+export function startTitleGenerationWorker(options: {
+  registerSignals?: boolean
+  connectionProvider: () => IORedis
+  deps: TitleGenerationQueueDeps
+}): ReturnType<typeof titleGeneration.startWorker> {
+  return titleGeneration.startWorker({
+    deps: options.deps,
+    registerSignals: options.registerSignals,
+    connectionProvider: options.connectionProvider,
+  })
+}
+
+runStandaloneQueueWorker((runtime) => {
+  const resolve = <I, T>(tag: Context.Key<I, T>): T => runtime.runSync(Effect.service(tag))
+  startTitleGenerationWorker({
+    connectionProvider: () => resolve(RedisServiceTag).getConnectionForBullMQ(),
+    deps: {
+      databaseService: resolve(DatabaseServiceTag),
+      threadTitleService: resolve(ThreadTitleServiceTag),
+      recentActivityTitleService: resolve(RecentActivityTitleServiceTag),
+    },
+  })
+})

package/src/redis/connection.ts

@@ -1,6 +1,9 @@
+import { Duration, Effect, Exit, Scope } from 'effect'
 import IORedis from 'ioredis'
 import type { RedisOptions } from 'ioredis'
 
+import { RedisError } from '../effect/errors'
+import { effectTryServicePromise } from '../effect/helpers'
 import { getErrorMessage } from '../utils/errors'
 
 export interface RedisConnectionLogger {
@@ -10,7 +13,7 @@ export interface RedisConnectionLogger {
   error?: (message: string) => void
 }
 
-interface CreateRedisConnectionManagerOptions {
+export interface CreateRedisConnectionManagerOptions {
   url: string
   redisOptions?: RedisOptions
   healthCheckIntervalMs?: number
@@ -52,134 +55,200 @@ function log(logger: RedisConnectionLogger | undefined, level: keyof RedisConnec
   }
 }
 
-class RedisConnectionManagerImpl implements RedisConnectionManager {
-  private redis: IORedis | null = null
-  private isHealthy = false
-  private healthCheckInterval: ReturnType<typeof setInterval> | null = null
-  private isInitialized = false
-  private isClosing = false
-  private isHealthCheckRunning = false
-
-  constructor(private readonly options: CreateRedisConnectionManagerOptions) {
-    this.initializeConnection()
-  }
+interface ManagerState {
+  isHealthy: boolean
+  isClosing: boolean
+}
 
-  private initializeConnection(): void {
-    if (this.isInitialized) {
-      return
-    }
+/**
+ * Build the IORedis client + listeners as an `Effect.acquireRelease`. Each
+ * handler is held as a const ref so the release step can pass the same
+ * function to `client.off(...)`, then `quit()` (falling back to
+ * `disconnect()`) the client. Prevents tracked-handler leaks on disposal.
+ */
+function acquireRedisClient(
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<IORedis, RedisError, Scope.Scope> {
+  return Effect.acquireRelease(
+    Effect.try({
+      try: () => {
+        const redisOptions = options.redisOptions ?? DEFAULT_REDIS_OPTIONS
+        const client = new IORedis(options.url, redisOptions)
+
+        const onConnect = () => {
+          log(options.logger, 'info', 'Redis connected')
+          state.isHealthy = true
+        }
+        const onReady = () => {
+          log(options.logger, 'info', 'Redis ready')
+          state.isHealthy = true
+        }
+        const onError = (error: Error) => {
+          log(options.logger, 'error', `Redis error: ${error.message}`)
+          state.isHealthy = false
+        }
+        const onClose = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
+          )
+          state.isHealthy = false
+        }
+        const onReconnecting = () => {
+          log(options.logger, 'info', 'Redis reconnecting...')
+        }
+        const onEnd = () => {
+          log(
+            options.logger,
+            state.isClosing ? 'info' : 'warn',
+            state.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
+          )
+          state.isHealthy = false
+        }
 
-    this.isInitialized = true
+        client.on('connect', onConnect)
+        client.on('ready', onReady)
+        client.on('error', onError)
+        client.on('close', onClose)
+        client.on('reconnecting', onReconnecting)
+        client.on('end', onEnd)
+
+        // Carry the handler refs alongside the client so the release closure
+        // can detach exactly what was attached.
+        ;(client as ClientWithHandlers).__lotaHandlers = {
+          connect: onConnect,
+          ready: onReady,
+          error: onError,
+          close: onClose,
+          reconnecting: onReconnecting,
+          end: onEnd,
+        }
 
-    try {
-      const redisOptions = this.options.redisOptions ?? DEFAULT_REDIS_OPTIONS
-      this.redis = new IORedis(this.options.url, redisOptions)
-      this.setupEventHandlers()
-      this.startHealthChecks()
-    } catch (error) {
-      log(this.options.logger, 'error', `Failed to initialize Redis connection: ${getErrorMessage(error)}`)
-    }
-  }
+        return client
+      },
+      catch: (cause) =>
+        new RedisError({ message: `Failed to initialize Redis connection: ${getErrorMessage(cause)}`, cause }),
+    }),
+    (client) =>
+      Effect.gen(function* () {
+        state.isClosing = true
+
+        const handlers = (client as ClientWithHandlers).__lotaHandlers
+        if (handlers) {
+          client.off('connect', handlers.connect)
+          client.off('ready', handlers.ready)
+          client.off('error', handlers.error)
+          client.off('close', handlers.close)
+          client.off('reconnecting', handlers.reconnecting)
+          client.off('end', handlers.end)
+        }
 
-  private setupEventHandlers(): void {
-    if (!this.redis) return
-
-    this.redis.on('connect', () => {
-      log(this.options.logger, 'info', 'Redis connected')
-      this.isHealthy = true
-    })
-
-    this.redis.on('ready', () => {
-      log(this.options.logger, 'info', 'Redis ready')
-      this.isHealthy = true
-    })
-
-    this.redis.on('error', (error: Error) => {
-      log(this.options.logger, 'error', `Redis error: ${error.message}`)
-      this.isHealthy = false
-    })
-
-    this.redis.on('close', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection closed during shutdown' : 'Redis connection closed',
-      )
-      this.isHealthy = false
-    })
-
-    this.redis.on('reconnecting', () => {
-      log(this.options.logger, 'info', 'Redis reconnecting...')
-    })
-
-    this.redis.on('end', () => {
-      log(
-        this.options.logger,
-        this.isClosing ? 'info' : 'warn',
-        this.isClosing ? 'Redis connection ended during shutdown' : 'Redis connection ended',
-      )
-      this.isHealthy = false
-    })
-  }
+        if (client.status !== 'end') {
+          const quitExit = yield* Effect.exit(
+            effectTryServicePromise(() => client.quit(), 'Failed to close Redis connection manager'),
+          )
+          if (Exit.isFailure(quitExit)) {
+            log(options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(quitExit.cause)}`)
+            client.disconnect()
+          }
+        }
+      }),
+  )
+}
 
-  private startHealthChecks(): void {
-    if (this.healthCheckInterval) {
-      return
-    }
+interface RedisHandlers {
+  readonly connect: () => void
+  readonly ready: () => void
+  readonly error: (error: Error) => void
+  readonly close: () => void
+  readonly reconnecting: () => void
+  readonly end: () => void
+}
 
-    const intervalMs = this.options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
-    this.healthCheckInterval = setInterval(async () => {
-      if (this.isHealthCheckRunning) return
-      this.isHealthCheckRunning = true
+type ClientWithHandlers = IORedis & { __lotaHandlers?: RedisHandlers }
+
+/**
+ * Health-check loop wired via `Effect.forkScoped` so interruption is automatic
+ * when the owning scope closes. No more imperative fiber tracking.
+ */
+function startHealthCheckFiber(
+  client: IORedis,
+  options: CreateRedisConnectionManagerOptions,
+  state: ManagerState,
+): Effect.Effect<void, never, Scope.Scope> {
+  const intervalMs = options.healthCheckIntervalMs ?? DEFAULT_HEALTH_CHECK_INTERVAL_MS
+  const logger = options.logger
+  let isHealthCheckRunning = false
+
+  const loop = Effect.gen(function* () {
+    for (;;) {
+      yield* Effect.sleep(Duration.millis(intervalMs))
+      if (isHealthCheckRunning) continue
+
+      isHealthCheckRunning = true
       try {
-        if (this.redis && this.redis.status === 'ready') {
-          await this.redis.ping()
-          this.isHealthy = true
+        if (client.status === 'ready') {
+          const pingExit = yield* Effect.exit(effectTryServicePromise(() => client.ping(), 'Redis health check failed'))
+          if (Exit.isFailure(pingExit)) {
+            log(logger, 'warn', `Redis health check failed: ${getErrorMessage(pingExit.cause)}`)
+            state.isHealthy = false
+          } else {
+            state.isHealthy = true
+          }
         }
-      } catch (error) {
-        log(this.options.logger, 'warn', `Redis health check failed: ${getErrorMessage(error)}`)
-        this.isHealthy = false
       } finally {
-        this.isHealthCheckRunning = false
+        isHealthCheckRunning = false
       }
-    }, intervalMs)
-    this.healthCheckInterval.unref()
-  }
-
-  getConnection(): IORedis {
-    if (!this.redis) {
-      throw new Error('Redis connection not initialized')
     }
-    return this.redis
-  }
-
-  getConnectionForBullMQ(): IORedis {
-    return this.getConnection()
-  }
+  })
 
-  isConnectionHealthy(): boolean {
-    return this.isHealthy && this.redis?.status === 'ready'
-  }
+  return Effect.asVoid(Effect.forkScoped(loop))
+}
 
-  async closeConnection(): Promise<void> {
-    if (this.healthCheckInterval) {
-      clearInterval(this.healthCheckInterval)
-      this.healthCheckInterval = null
+/**
+ * Scoped builder for the Redis connection manager. The IORedis client and
+ * health-check fiber are both bound to the surrounding scope, so closing the
+ * scope tears down listeners + quits the client + interrupts the fiber.
+ */
+export function makeRedisConnectionManager(
+  options: CreateRedisConnectionManagerOptions,
+): Effect.Effect<RedisConnectionManager, RedisError, Scope.Scope> {
+  return Effect.gen(function* () {
+    const state: ManagerState = { isHealthy: false, isClosing: false }
+    const client = yield* acquireRedisClient(options, state)
+    yield* startHealthCheckFiber(client, options, state)
+
+    const manager: RedisConnectionManager = {
+      getConnection: () => client,
+      getConnectionForBullMQ: () => client,
+      isConnectionHealthy: () => state.isHealthy && client.status === 'ready',
+      closeConnection: () => Promise.resolve(),
     }
 
-    this.isClosing = true
-
-    try {
-      if (this.redis && this.redis.status !== 'end') {
-        await this.redis.quit()
-      }
-    } catch (error) {
-      log(this.options.logger, 'warn', `Redis quit failed, forcing disconnect: ${getErrorMessage(error)}`)
-      this.redis?.disconnect()
-    }
-  }
+    return manager
+  })
 }
 
+/**
+ * Standalone Promise-friendly factory for hosts that build the manager outside
+ * a Layer. Owns its own `Scope`; `closeConnection()` closes that scope, which
+ * runs the same finalizer chain (listener removal, quit/disconnect, fiber
+ * interrupt) that `Layer.effect` runs at runtime shutdown.
+ */
 export function createRedisConnectionManager(options: CreateRedisConnectionManagerOptions): RedisConnectionManager {
-  return new RedisConnectionManagerImpl(options)
+  const scope = Scope.makeUnsafe()
+  const built = Effect.runSync(Scope.provide(makeRedisConnectionManager(options), scope))
+  let closePromise: Promise<void> | null = null
+
+  return {
+    ...built,
+    closeConnection: () => {
+      if (!closePromise) {
+        closePromise = Effect.runPromise(Scope.close(scope, Exit.void).pipe(Effect.catchCause(() => Effect.void)))
+      }
+      return closePromise
+    },
+  }
 }

package/src/redis/index.ts

@@ -1,15 +1,13 @@
 import { createRedisConnectionManager } from './connection'
 import type { RedisConnectionManager } from './connection'
 export { DEFAULT_REDIS_OPTIONS, type RedisConnectionLogger } from './connection'
+export { withOrgMemoryLock, withOrgMemoryLockEffect } from './org-memory-lock'
+export { withLeaseLock } from './redis-lease-lock'
 export {
-  getRedisConnection,
-  getRedisConnectionForBullMQ,
-  setRedisConnectionManager,
-  type RedisConnectionAccessor,
-} from './connection-accessor'
-export { withOrgMemoryLock } from './org-memory-lock'
-export { LeaseLockLostError, withRedisLeaseLock } from './redis-lease-lock'
-export { closeSharedSubscriber, createThreadResumableContext } from './stream-context'
+  createThreadResumableContext,
+  SharedThreadStreamSubscriberLive,
+  SharedThreadStreamSubscriberTag,
+} from './stream-context'
 
 export { createRedisConnectionManager }
 export type { RedisConnectionManager }

package/src/redis/org-memory-lock.ts

@@ -1,6 +1,12 @@
+import { Schema, Effect } from 'effect'
+import type IORedis from 'ioredis'
+
 import { serverLogger } from '../config/logger'
-import { getRedisConnection } from './connection-accessor'
-import { withRedisLeaseLock } from './redis-lease-lock'
+import { LockAcquisitionError } from '../effect/errors'
+import type { LockLostError, RedisError } from '../effect/errors'
+import { withLeaseLock } from './redis-lease-lock'
+import type { RedisLeaseLockOptions } from './redis-lease-lock'
+import { getRuntimeRedisConnection } from './runtime-connection'
 
 const ORG_MEMORY_LOCK_PREFIX = 'lock:org-memory:org:'
 const ORG_MEMORY_LOCK_TTL_MS = 120_000
@@ -9,35 +15,62 @@ const ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS = 30_000
 const ORG_MEMORY_LOCK_MAX_WAIT_MS = 15 * 60 * 1000
 
-export async function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+class OrgMemoryLockCallbackError extends Schema.TaggedErrorClass<OrgMemoryLockCallbackError>()(
+  'OrgMemoryLockCallbackError',
+  { message: Schema.String, cause: Schema.Defect },
+) {}
+
+function createOrgMemoryLockOptions(redis: IORedis, orgId: string): RedisLeaseLockOptions & { redis: IORedis } {
+  return {
+    redis,
+    lockKey: `${ORG_MEMORY_LOCK_PREFIX}${orgId}`,
+    lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
+    retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
+    refreshIntervalMs: ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS,
+    waitLogIntervalMs: ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS,
+    maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
+    label: 'org memory lock',
+    logger: {
+      debug: (message) => {
+        serverLogger.debug`${message}`
+      },
+      info: (message) => {
+        serverLogger.info`${message}`
+      },
+      warn: (message) => {
+        serverLogger.warn`${message}`
+      },
+    },
+  }
+}
+
+export function withOrgMemoryLock<T>(orgId: string, fn: (signal: AbortSignal) => Promise<T>): Promise<T> {
+  return Effect.runPromise(
+    withOrgMemoryLockEffect(orgId, (signal) =>
+      Effect.tryPromise({
+        try: () => fn(signal),
+        catch: (cause) => new OrgMemoryLockCallbackError({ message: 'Org memory lock callback failed.', cause }),
+      }),
+    ),
+  )
+}
+
+export function withOrgMemoryLockEffect<A, E>(
+  orgId: string,
+  fn: (signal: AbortSignal) => Effect.Effect<A, E>,
+): Effect.Effect<A, E | LockAcquisitionError | LockLostError | RedisError> {
   const normalizedOrgId = orgId.trim()
 
   if (!normalizedOrgId) {
-    throw new Error('Organization id is required for memory lock')
+    return Effect.fail(
+      new LockAcquisitionError({
+        lockKey: `${ORG_MEMORY_LOCK_PREFIX}<missing-org-id>`,
+        maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
+      }),
+    )
   }
 
-  return withRedisLeaseLock(
-    {
-      redis: getRedisConnection(),
-      lockKey: `${ORG_MEMORY_LOCK_PREFIX}${normalizedOrgId}`,
-      lockTtlMs: ORG_MEMORY_LOCK_TTL_MS,
-      retryDelayMs: ORG_MEMORY_LOCK_RETRY_DELAY_MS,
-      refreshIntervalMs: ORG_MEMORY_LOCK_REFRESH_INTERVAL_MS,
-      waitLogIntervalMs: ORG_MEMORY_LOCK_WAIT_LOG_INTERVAL_MS,
-      maxWaitMs: ORG_MEMORY_LOCK_MAX_WAIT_MS,
-      label: 'org memory lock',
-      logger: {
-        debug: (message) => {
-          serverLogger.debug`${message}`
-        },
-        info: (message) => {
-          serverLogger.info`${message}`
-        },
-        warn: (message) => {
-          serverLogger.warn`${message}`
-        },
-      },
-    },
-    fn,
+  return Effect.sync(() => getRuntimeRedisConnection()).pipe(
+    Effect.flatMap((redis) => withLeaseLock(createOrgMemoryLockOptions(redis, normalizedOrgId), fn)),
   )
 }