@lota-sdk/core 0.4.12 → 0.4.14

package/src/workers/utils/thread-message-query.ts

@@ -11,7 +11,7 @@ import { TABLES } from '../../db/tables'
 import { ThreadMessageRowSchema } from '../../db/thread-message-row'
 import type { ThreadMessageRow } from '../../db/thread-message-row'
 import { normalizeTextBody } from '../../document/parsing'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import type { LotaRuntimeBackgroundCursor } from '../../runtime/runtime-extensions'
 import type { SocialChatHistoryMessage } from '../../services/social-chat-history.service'
 import { unsafeDateFrom } from '../../utils/date-time'
@@ -53,10 +53,10 @@ function readPersistedMessageParts(parts: ThreadMessageRow['parts']): ChatMessag
   return (Array.isArray(parts) ? normalizeMessageValue(parts) : []) as ChatMessage['parts']
 }
 
-class ThreadMessageQueryError extends Schema.TaggedErrorClass<ThreadMessageQueryError>()('ThreadMessageQueryError', {
-  message: Schema.String,
-  cause: Schema.Defect,
-}) {}
+class ThreadMessageQueryError extends Schema.TaggedErrorClass<ThreadMessageQueryError>()(
+  ERROR_TAGS.ThreadMessageQueryError,
+  { message: Schema.String, cause: Schema.Defect },
+) {}
 
 function mapThreadRow(row: ThreadMessageRow): ThreadDigestMessage {
   return {
@@ -72,10 +72,6 @@ function mapThreadRow(row: ThreadMessageRow): ThreadDigestMessage {
   }
 }
 
-const effectTryPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new ThreadMessageQueryError({ message, cause }),
-)
-
 export function compareDigestMessageOrder(left: DigestMessage, right: DigestMessage): number {
   const timeDiff = left.cursor.createdAt.getTime() - right.cursor.createdAt.getTime()
   if (timeDiff !== 0) return timeDiff
@@ -85,19 +81,20 @@ export function compareDigestMessageOrder(left: DigestMessage, right: DigestMess
 export function listThreadIdsForOrg(db: SurrealDBService, orgRef: RecordIdRef): Promise<RecordIdRef[]> {
   const EntityIdRowSchema = z.string().trim().min(1)
   return Effect.runPromise(
-    effectTryPromise(
-      () =>
-        db.query<unknown>(
-          new BoundQuery(
-            `SELECT VALUE type::string(id) FROM ${TABLES.THREAD}
+    db
+      .query<unknown>(
+        new BoundQuery(
+          `SELECT VALUE type::string(id) FROM ${TABLES.THREAD}
        WHERE organizationId = $organizationId`,
-            { organizationId: orgRef },
-          ),
+          { organizationId: orgRef },
+        ),
+      )
+      .pipe(
+        Effect.mapError(
+          (cause) => new ThreadMessageQueryError({ message: 'Failed to list thread ids for org digest.', cause }),
         ),
-      'Failed to list thread ids for org digest.',
-    ).pipe(
-      Effect.map((ids) => ids.map((value: unknown) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.THREAD))),
-    ),
+        Effect.map((ids) => ids.map((value: unknown) => ensureRecordId(EntityIdRowSchema.parse(value), TABLES.THREAD))),
+      ),
   )
 }
 
@@ -140,10 +137,13 @@ export function listEligibleThreadMessages(params: {
         return []
       }
 
-      const rows = yield* effectTryPromise(
-        () => params.db.query<unknown>(query),
-        'Failed to list eligible thread messages.',
-      )
+      const rows = yield* params.db
+        .query<unknown>(query)
+        .pipe(
+          Effect.mapError(
+            (cause) => new ThreadMessageQueryError({ message: 'Failed to list eligible thread messages.', cause }),
+          ),
+        )
       return rows.map((row: unknown) => mapThreadRow(ThreadMessageRowSchema.parse(row)))
     }),
   )

package/src/workers/worker-utils.ts

@@ -1,14 +1,20 @@
 import { fileURLToPath } from 'node:url'
 
 import type { Job, Worker } from 'bullmq'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 import type { Context } from 'effect'
 
 import { chatLogger } from '../config/logger'
+import { ERROR_TAGS } from '../effect/errors'
 import type { QueueJobServiceTag } from '../services/queue-job.service'
 
 export type QueueJobService = Context.Service.Shape<typeof QueueJobServiceTag>
 
+class QueueWorkerError extends Schema.TaggedErrorClass<QueueWorkerError>()(ERROR_TAGS.QueueWorkerError, {
+  phase: Schema.Literals(['close', 'process', 'shutdown-timeout']),
+  cause: Schema.Defect,
+}) {}
+
 export const DEFAULT_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 24 * 60 * 60, count: 200 } }
 export const LOW_JOB_RETENTION = { removeOnComplete: true, removeOnFail: { age: 6 * 60 * 60, count: 50 } }
 export const LONG_JOB_LOCK_DURATION_MS = 600_000
@@ -78,7 +84,14 @@ export const attachWorkerEvents = (worker: Worker, name: string, logger: typeof
 export const createWorkerShutdown = (worker: Worker, name: string, logger: typeof chatLogger = chatLogger) => {
   return () => {
     logger.info`Shutting down ${name} worker`
-    return Effect.runPromise(Effect.asVoid(Effect.tryPromise(() => worker.close())))
+    return Effect.runPromise(
+      Effect.asVoid(
+        Effect.tryPromise({
+          try: () => worker.close(),
+          catch: (cause) => new QueueWorkerError({ phase: 'close', cause }),
+        }),
+      ),
+    )
   }
 }
 
@@ -111,7 +124,10 @@ export function createTracedWorkerProcessor<TJob extends TracedWorkerJobLike, TR
             }),
           )
 
-          const result = yield* Effect.tryPromise(() => processor(job))
+          const result = yield* Effect.tryPromise({
+            try: () => processor(job),
+            catch: (cause) => new QueueWorkerError({ phase: 'process', cause }),
+          })
 
           yield* Effect.catch(queueJobService.markAttemptCompleted(trackedJob, result), (error) =>
             Effect.sync(() => {
@@ -163,7 +179,10 @@ export const registerShutdownSignals = ({
     shuttingDown = true
     void Effect.runFork(
       Effect.gen(function* () {
-        yield* Effect.tryPromise(() => Bun.sleep(timeoutMs))
+        yield* Effect.tryPromise({
+          try: () => Bun.sleep(timeoutMs),
+          catch: (cause) => new QueueWorkerError({ phase: 'shutdown-timeout', cause }),
+        })
         if (!forcedExitArmed) return
         logger.warn`Forced shutdown after ${timeoutMs}ms`
         process.exit(0)

package/src/effect/helpers.ts

@@ -1,123 +0,0 @@
-import { Cause, Effect } from 'effect'
-
-import { ServiceError } from './errors'
-
-export function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-  if (typeof value !== 'object' && typeof value !== 'function') {
-    return false
-  }
-
-  if (value === null) {
-    return false
-  }
-
-  return 'then' in value && typeof value.then === 'function'
-}
-
-type PromiseEffectEvaluator<A, E = never, R = never> =
-  | (() => PromiseLike<A> | Effect.Effect<A, E, R>)
-  | ((signal: AbortSignal) => PromiseLike<A> | Effect.Effect<A, E, R>)
-
-function invokePromiseEffectEvaluator<A, E, R>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-): PromiseLike<A> | Effect.Effect<A, E, R> {
-  return (evaluate as () => PromiseLike<A> | Effect.Effect<A, E, R>)()
-}
-
-export function effectTryPromise<A, E = never, R = never>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-): Effect.Effect<A, Cause.UnknownError, R>
-export function effectTryPromise<A, E1, E2, R>(
-  evaluate: PromiseEffectEvaluator<A, E1, R>,
-  onError: (cause: unknown) => E2,
-): Effect.Effect<A, E2, R>
-export function effectTryPromise<A, E1, E2, R>(
-  evaluate: PromiseEffectEvaluator<A, E1, R>,
-  onError?: (cause: unknown) => E2,
-): Effect.Effect<A, E2 | Cause.UnknownError, R> {
-  return Effect.suspend(() => {
-    try {
-      const value = invokePromiseEffectEvaluator(evaluate)
-      if (Effect.isEffect(value)) {
-        if (onError) {
-          return value.pipe(Effect.mapError((cause) => onError(cause)))
-        }
-
-        return value.pipe(Effect.mapError((cause) => new Cause.UnknownError(cause)))
-      }
-
-      return onError
-        ? Effect.tryPromise({ try: () => value, catch: onError })
-        : Effect.tryPromise({ try: () => value, catch: (cause) => new Cause.UnknownError(cause) })
-    } catch (cause) {
-      return Effect.fail(onError ? onError(cause) : new Cause.UnknownError(cause))
-    }
-  })
-}
-
-export function effectTryServicePromise<A, E = never, R = never>(
-  evaluate: PromiseEffectEvaluator<A, E, R>,
-  message: string,
-): Effect.Effect<A, ServiceError, R> {
-  return Effect.suspend(() => {
-    try {
-      const value = invokePromiseEffectEvaluator(evaluate)
-      if (Effect.isEffect(value)) {
-        return value.pipe(Effect.mapError((cause) => new ServiceError({ message, cause })))
-      }
-
-      return Effect.tryPromise({ try: () => value, catch: (cause) => new ServiceError({ message, cause }) })
-    } catch (cause) {
-      return Effect.fail(new ServiceError({ message, cause }))
-    }
-  })
-}
-
-export function makeEffectTryPromiseWithMessage<E>(onError: (message: string, cause: unknown) => E) {
-  return <A, E1 = never, R = never>(
-    evaluate: PromiseEffectEvaluator<A, E1, R>,
-    message: string,
-  ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(message, cause))
-}
-
-export function makeEffectTryPromiseWithOperation<E>(
-  onError: (operation: string, message: string, cause: unknown) => E,
-) {
-  return <A, E1 = never, R = never>(
-    operation: string,
-    message: string,
-    evaluate: PromiseEffectEvaluator<A, E1, R>,
-  ): Effect.Effect<A, E, R> => effectTryPromise(evaluate, (cause) => onError(operation, message, cause))
-}
-
-export function effectTryMaybeAsync<A>(evaluate: () => A | PromiseLike<A>): Effect.Effect<A, Cause.UnknownError, never>
-export function effectTryMaybeAsync<A, E>(
-  evaluate: () => A | PromiseLike<A>,
-  onError: (cause: unknown) => E,
-): Effect.Effect<A, E, never>
-export function effectTryMaybeAsync<A, E>(
-  evaluate: () => A | PromiseLike<A>,
-  onError?: (cause: unknown) => E,
-): Effect.Effect<A, E | Cause.UnknownError, never> {
-  return Effect.suspend(() => {
-    try {
-      const value = evaluate()
-      return isPromiseLike(value)
-        ? onError
-          ? effectTryPromise(() => value, onError)
-          : effectTryPromise(() => value)
-        : Effect.succeed(value)
-    } catch (cause) {
-      return Effect.fail(onError ? onError(cause) : new Cause.UnknownError(cause))
-    }
-  })
-}
-
-export function iterateEffect<A, E, R>(
-  initial: A,
-  options: { while: (state: A) => boolean; body: (state: A) => Effect.Effect<A, E, R> },
-): Effect.Effect<A, E, R> {
-  const step = (state: A): Effect.Effect<A, E, R> =>
-    options.while(state) ? options.body(state).pipe(Effect.flatMap(step)) : Effect.succeed(state)
-  return Effect.suspend(() => step(initial))
-}