@lota-sdk/core 0.4.13 → 0.4.14

package/src/services/plan/plan-scheduler.service.ts

@@ -7,8 +7,7 @@ import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
 import type { SurrealDBService } from '../../db/service'
 import { TABLES } from '../../db/tables'
-import { NotFoundError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS, NotFoundError } from '../../effect/errors'
 import { DatabaseServiceTag } from '../../effect/services'
 import type { PlanSchedulerQueueRuntime } from '../../queues/plan-scheduler.queue'
 import { LotaQueuesServiceTag } from '../../queues/queues.service'
@@ -20,79 +19,74 @@ interface PlanSchedulerRuntimeDeps {
   recoverDeadlineChecks(): Promise<void>
 }
 
-class PlanSchedulerError extends Schema.TaggedErrorClass<PlanSchedulerError>()('PlanSchedulerError', {
+class PlanSchedulerError extends Schema.TaggedErrorClass<PlanSchedulerError>()(ERROR_TAGS.PlanSchedulerError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-const effectTryPromise = makeEffectTryPromiseWithMessage((message, cause) => new PlanSchedulerError({ message, cause }))
+function toPlanSchedulerError(message: string, cause: unknown): PlanSchedulerError {
+  return new PlanSchedulerError({ message, cause })
+}
 
-function requireScheduleField<A>(value: A | undefined, message: string): A {
+function requireScheduleFieldEffect<A>(value: A | undefined, message: string): Effect.Effect<A, PlanSchedulerError> {
   if (value === undefined) {
-    throw new PlanSchedulerError({ message })
+    return Effect.fail(new PlanSchedulerError({ message }))
   }
-  return value
+  return Effect.succeed(value)
 }
 
-function computeNextCronDate(cronExpression: string, baseTime: Date): Date {
+function computeNextCronDateEffect(cronExpression: string, baseTime: Date): Effect.Effect<Date, PlanSchedulerError> {
   const parsedCron = Cron.parse(cronExpression)
   if (!Result.isSuccess(parsedCron)) {
-    throw new PlanSchedulerError({ message: `Invalid cron expression: "${cronExpression}".` })
-  }
-
-  try {
-    return Cron.next(parsedCron.success, baseTime)
-  } catch (cause) {
-    throw new PlanSchedulerError({
-      message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
-      cause,
-    })
+    return Effect.fail(new PlanSchedulerError({ message: `Invalid cron expression: "${cronExpression}".` }))
   }
+  return Effect.try({
+    try: () => Cron.next(parsedCron.success, baseTime),
+    catch: (cause) =>
+      new PlanSchedulerError({
+        message: `Failed to compute the next fire time for cron expression "${cronExpression}".`,
+        cause,
+      }),
+  })
 }
 
-// `computeNextFireAt` must stay purely synchronous — no Clock, no service lookups, no async.
-// `computeNextFireAtEffect` wraps it with `Effect.try` so the same logic is composable from
-// Effect callers without an `Effect.runSync` round trip.
-function computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
+// `computeNextFireAtEffect` is the canonical Effect-channel form. A sync
+// wrapper `computeNextFireAt` (below, on the service) is exposed via
+// `Effect.runSync` for backward-compat sync call sites; the effect has no
+// layer requirements so running it synchronously is safe.
+function computeNextFireAtEffect(
+  spec: PlanScheduleSpec,
+  baseTime: Date = nowDate(),
+): Effect.Effect<Date, PlanSchedulerError> {
   switch (spec.type) {
     case 'immediate':
-      return baseTime
+      return Effect.succeed(baseTime)
 
     case 'absolute':
-      return unsafeDateFrom(requireScheduleField(spec.at, 'Absolute schedules require an "at" timestamp.'))
+      return requireScheduleFieldEffect(spec.at, 'Absolute schedules require an "at" timestamp.').pipe(
+        Effect.map((at) => unsafeDateFrom(at)),
+      )
 
-    case 'relative': {
-      const delayMs = requireScheduleField(spec.delayMs, 'Relative schedules require "delayMs".')
-      return unsafeDateFrom(baseTime.getTime() + delayMs)
-    }
+    case 'relative':
+      return requireScheduleFieldEffect(spec.delayMs, 'Relative schedules require "delayMs".').pipe(
+        Effect.map((delayMs) => unsafeDateFrom(baseTime.getTime() + delayMs)),
+      )
 
-    case 'cron': {
-      const cronExpression = requireScheduleField(spec.cron, 'Cron schedules require a "cron" expression.')
-      return computeNextCronDate(cronExpression, baseTime)
-    }
+    case 'cron':
+      return requireScheduleFieldEffect(spec.cron, 'Cron schedules require a "cron" expression.').pipe(
+        Effect.flatMap((cronExpression) => computeNextCronDateEffect(cronExpression, baseTime)),
+      )
 
-    case 'monitoring': {
-      const intervalMs = requireScheduleField(spec.intervalMs, 'Monitoring schedules require "intervalMs".')
-      return unsafeDateFrom(baseTime.getTime() + intervalMs)
-    }
+    case 'monitoring':
+      return requireScheduleFieldEffect(spec.intervalMs, 'Monitoring schedules require "intervalMs".').pipe(
+        Effect.map((intervalMs) => unsafeDateFrom(baseTime.getTime() + intervalMs)),
+      )
 
     default:
-      throw new PlanSchedulerError({ message: 'Unsupported schedule type in schedule specification.' })
+      return Effect.fail(new PlanSchedulerError({ message: 'Unsupported schedule type in schedule specification.' }))
   }
 }
 
-const isPlanSchedulerError = Schema.is(PlanSchedulerError)
-
-function computeNextFireAtEffect(spec: PlanScheduleSpec, baseTime?: Date): Effect.Effect<Date, PlanSchedulerError> {
-  return Effect.try({
-    try: () => computeNextFireAt(spec, baseTime),
-    catch: (cause) =>
-      isPlanSchedulerError(cause)
-        ? cause
-        : new PlanSchedulerError({ message: 'Failed to compute the next fire time.', cause }),
-  })
-}
-
 export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: PlanSchedulerQueueRuntime) {
   const loadPlanSchedulerQueue = (): Effect.Effect<PlanSchedulerQueueRuntime, PlanSchedulerError> =>
     Effect.succeed(schedulerQueue)
@@ -108,35 +102,33 @@ export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: P
     Effect.gen(function* () {
       const nextFireAt = yield* computeNextFireAtEffect(params.scheduleSpec)
       const now = nowDate()
-      const record = yield* effectTryPromise(
-        () =>
-          db.create(
-            TABLES.PLAN_SCHEDULE,
-            {
-              organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
-              threadId: ensureRecordId(params.threadId, TABLES.THREAD),
-              planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
-              runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
-              nodeId: params.nodeId,
-              scheduleSpec: params.scheduleSpec,
-              status: 'active',
-              fireCount: 0,
-              nextFireAt: toDatabaseDateTime(nextFireAt),
-              createdAt: now,
-            },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to create plan schedule.',
-      )
-      const { enqueueScheduleFire } = yield* loadPlanSchedulerQueue()
-      yield* effectTryPromise(
-        () =>
-          enqueueScheduleFire(
+      const record = yield* db
+        .create(
+          TABLES.PLAN_SCHEDULE,
+          {
+            organizationId: ensureRecordId(params.organizationId, TABLES.ORGANIZATION),
+            threadId: ensureRecordId(params.threadId, TABLES.THREAD),
+            planSpecId: params.planSpecId ? ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC) : undefined,
+            runId: params.runId ? ensureRecordId(params.runId, TABLES.PLAN_RUN) : undefined,
+            nodeId: params.nodeId,
+            scheduleSpec: params.scheduleSpec,
+            status: 'active',
+            fireCount: 0,
+            nextFireAt: toDatabaseDateTime(nextFireAt),
+            createdAt: now,
+          },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to create plan schedule.', cause)))
+      const queue = yield* loadPlanSchedulerQueue()
+      yield* Effect.tryPromise({
+        try: () =>
+          queue.enqueueScheduleFire(
             recordIdToString(record.id, TABLES.PLAN_SCHEDULE),
             Math.max(0, nextFireAt.getTime() - nowEpochMillis()),
           ),
-        'Failed to enqueue schedule fire job.',
-      )
+        catch: (cause) => toPlanSchedulerError('Failed to enqueue schedule fire job.', cause),
+      })
       return record
     })
 
@@ -154,88 +146,84 @@ export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: P
       const nextFireAt: Date | null = isActive ? yield* computeNextFireAtEffect(schedule.scheduleSpec, now) : null
       const newStatus: 'active' | 'completed' = isActive ? 'active' : 'completed'
 
-      yield* effectTryPromise(
-        () =>
-          db.update(
-            TABLES.PLAN_SCHEDULE,
-            schedule.id,
-            {
-              fireCount: newFireCount,
-              lastFiredAt: now,
-              nextFireAt: toDatabaseDateTime(nextFireAt),
-              status: newStatus,
-            },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to update fired schedule.',
-      )
+      yield* db
+        .update(
+          TABLES.PLAN_SCHEDULE,
+          schedule.id,
+          { fireCount: newFireCount, lastFiredAt: now, nextFireAt: toDatabaseDateTime(nextFireAt), status: newStatus },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to update fired schedule.', cause)))
 
       if (newStatus === 'active') {
         if (!nextFireAt) {
           return yield* new PlanSchedulerError({ message: 'Recurring schedules must resolve a next fire time.' })
         }
-        const { enqueueScheduleFire } = yield* loadPlanSchedulerQueue()
-        yield* effectTryPromise(
-          () =>
-            enqueueScheduleFire(
+        const queue = yield* loadPlanSchedulerQueue()
+        yield* Effect.tryPromise({
+          try: () =>
+            queue.enqueueScheduleFire(
               recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE),
               Math.max(0, nextFireAt.getTime() - nowEpochMillis()),
             ),
-          'Failed to enqueue next schedule fire job.',
-        )
+          catch: (cause) => toPlanSchedulerError('Failed to enqueue next schedule fire job.', cause),
+        })
       }
 
       const runId = schedule.runId
       const nodeId = schedule.nodeId
       const promotedNode = Boolean(runId && nodeId)
       if (runId && nodeId) {
-        yield* effectTryPromise(
-          () =>
+        yield* Effect.tryPromise({
+          try: () =>
             runtimeDeps.promoteDelayedNode({
               runId: recordIdToString(runId, TABLES.PLAN_RUN),
               nodeId,
               emittedBy: 'plan-scheduler',
             }),
-          'Failed to promote delayed plan node.',
-        )
+          catch: (cause) => toPlanSchedulerError('Failed to promote delayed plan node.', cause),
+        })
       }
 
       const advancedCycle =
         schedule.planSpecId && !schedule.runId
-          ? yield* effectTryPromise(
-              () =>
-                db.findOne(
-                  TABLES.PLAN_CYCLE,
-                  { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
-                  PlanCycleRecordSchema,
+          ? yield* db
+              .findOne(
+                TABLES.PLAN_CYCLE,
+                { scheduleId: ensureRecordId(schedule.id, TABLES.PLAN_SCHEDULE) },
+                PlanCycleRecordSchema,
+              )
+              .pipe(
+                Effect.mapError((cause) => toPlanSchedulerError('Failed to load plan cycle for schedule.', cause)),
+                Effect.tap((cycle) =>
+                  cycle
+                    ? Effect.tryPromise({
+                        try: () => runtimeDeps.advanceCycle(cycle.id),
+                        catch: (cause) => toPlanSchedulerError('Failed to advance plan cycle.', cause),
+                      })
+                    : Effect.void,
                 ),
-              'Failed to load plan cycle for schedule.',
-            ).pipe(
-              Effect.tap((cycle) =>
-                cycle
-                  ? effectTryPromise(() => runtimeDeps.advanceCycle(cycle.id), 'Failed to advance plan cycle.')
-                  : Effect.void,
-              ),
-              Effect.map((cycle) => cycle !== null),
-            )
+                Effect.map((cycle) => cycle !== null),
+              )
           : false
 
       if (promotedNode || advancedCycle) {
-        yield* effectTryPromise(() => runtimeDeps.recoverDeadlineChecks(), 'Failed to recover deadline checks.')
+        yield* Effect.tryPromise({
+          try: () => runtimeDeps.recoverDeadlineChecks(),
+          catch: (cause) => toPlanSchedulerError('Failed to recover deadline checks.', cause),
+        })
       }
     })
 
   const fireScheduleByIdEffect = (scheduleId: string, runtimeDeps: PlanSchedulerRuntimeDeps) =>
     Effect.gen(function* () {
-      const schedule = yield* effectTryPromise(
-        () =>
-          db.findOne(
-            TABLES.PLAN_SCHEDULE,
-            { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to load schedule by id.',
-      )
+      const schedule = yield* db
+        .findOne(
+          TABLES.PLAN_SCHEDULE,
+          { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to load schedule by id.', cause)))
       if (!schedule || schedule.status !== 'active') return
 
       yield* fireScheduleEffect(schedule, runtimeDeps)
@@ -243,30 +231,33 @@ export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: P
 
   const recoverActiveSchedulesEffect = () =>
     Effect.gen(function* () {
-      const activeSchedules = yield* effectTryPromise(
-        () =>
-          db.queryMany(
-            new BoundQuery(`SELECT * FROM ${TABLES.PLAN_SCHEDULE} WHERE status = $status ORDER BY nextFireAt ASC`, {
-              status: 'active',
-            }),
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to load active schedules.',
-      )
-      const { enqueueScheduleFire } = yield* loadPlanSchedulerQueue()
+      const activeSchedules = yield* db
+        .queryMany(
+          new BoundQuery(`SELECT * FROM ${TABLES.PLAN_SCHEDULE} WHERE status = $status ORDER BY nextFireAt ASC`, {
+            status: 'active',
+          }),
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to load active schedules.', cause)))
+      const queue = yield* loadPlanSchedulerQueue()
       yield* Effect.forEach(
         activeSchedules.filter(
-          (schedule): schedule is typeof schedule & { nextFireAt: Date } => schedule.nextFireAt !== undefined,
+          (schedule: PlanScheduleRecord): schedule is PlanScheduleRecord & { nextFireAt: Date } =>
+            schedule.nextFireAt !== undefined,
         ),
         (schedule) =>
-          effectTryPromise(
-            () =>
-              enqueueScheduleFire(
+          Effect.tryPromise({
+            try: () =>
+              queue.enqueueScheduleFire(
                 recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE),
                 Math.max(0, unsafeDateFrom(schedule.nextFireAt).getTime() - nowEpochMillis()),
               ),
-            `Failed to re-enqueue schedule ${recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)}.`,
-          ),
+            catch: (cause) =>
+              toPlanSchedulerError(
+                `Failed to re-enqueue schedule ${recordIdToString(schedule.id, TABLES.PLAN_SCHEDULE)}.`,
+                cause,
+              ),
+          }),
         { concurrency: 5, discard: true },
       )
     })
@@ -274,50 +265,50 @@ export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: P
   const cancelScheduleEffect = (scheduleId: RecordIdInput) => {
     const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
     return Effect.gen(function* () {
-      const { removeScheduleFireJob } = yield* loadPlanSchedulerQueue()
-      yield* effectTryPromise(() => removeScheduleFireJob(idStr), 'Failed to remove schedule fire job.')
-      yield* effectTryPromise(
-        () =>
-          db.update(
-            TABLES.PLAN_SCHEDULE,
-            ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-            { status: 'cancelled' },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to cancel schedule.',
-      )
+      const queue = yield* loadPlanSchedulerQueue()
+      yield* Effect.tryPromise({
+        try: () => queue.removeScheduleFireJob(idStr),
+        catch: (cause) => toPlanSchedulerError('Failed to remove schedule fire job.', cause),
+      })
+      yield* db
+        .update(
+          TABLES.PLAN_SCHEDULE,
+          ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+          { status: 'cancelled' },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to cancel schedule.', cause)))
     })
   }
 
   const pauseScheduleEffect = (scheduleId: RecordIdInput) => {
     const idStr = recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE)
     return Effect.gen(function* () {
-      const { removeScheduleFireJob } = yield* loadPlanSchedulerQueue()
-      yield* effectTryPromise(() => removeScheduleFireJob(idStr), 'Failed to remove schedule fire job.')
-      yield* effectTryPromise(
-        () =>
-          db.update(
-            TABLES.PLAN_SCHEDULE,
-            ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-            { status: 'paused' },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to pause schedule.',
-      )
+      const queue = yield* loadPlanSchedulerQueue()
+      yield* Effect.tryPromise({
+        try: () => queue.removeScheduleFireJob(idStr),
+        catch: (cause) => toPlanSchedulerError('Failed to remove schedule fire job.', cause),
+      })
+      yield* db
+        .update(
+          TABLES.PLAN_SCHEDULE,
+          ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+          { status: 'paused' },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to pause schedule.', cause)))
     })
   }
 
   const resumeScheduleEffect = (scheduleId: RecordIdInput) =>
     Effect.gen(function* () {
-      const schedule = yield* effectTryPromise(
-        () =>
-          db.findOne(
-            TABLES.PLAN_SCHEDULE,
-            { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to load schedule for resume.',
-      )
+      const schedule = yield* db
+        .findOne(
+          TABLES.PLAN_SCHEDULE,
+          { id: ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE) },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to load schedule for resume.', cause)))
       if (!schedule) {
         return yield* new NotFoundError({
           resource: TABLES.PLAN_SCHEDULE,
@@ -327,43 +318,42 @@ export function makePlanSchedulerService(db: SurrealDBService, schedulerQueue: P
       }
 
       const nextFireAt = yield* computeNextFireAtEffect(schedule.scheduleSpec)
-      yield* effectTryPromise(
-        () =>
-          db.update(
-            TABLES.PLAN_SCHEDULE,
-            ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
-            { status: 'active', nextFireAt: toDatabaseDateTime(nextFireAt) },
-            PlanScheduleRecordSchema,
-          ),
-        'Failed to resume schedule.',
-      )
-      const { enqueueScheduleFire } = yield* loadPlanSchedulerQueue()
-      yield* effectTryPromise(
-        () =>
-          enqueueScheduleFire(
+      yield* db
+        .update(
+          TABLES.PLAN_SCHEDULE,
+          ensureRecordId(scheduleId, TABLES.PLAN_SCHEDULE),
+          { status: 'active', nextFireAt: toDatabaseDateTime(nextFireAt) },
+          PlanScheduleRecordSchema,
+        )
+        .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to resume schedule.', cause)))
+      const queue = yield* loadPlanSchedulerQueue()
+      yield* Effect.tryPromise({
+        try: () =>
+          queue.enqueueScheduleFire(
             recordIdToString(scheduleId, TABLES.PLAN_SCHEDULE),
             Math.max(0, nextFireAt.getTime() - nowEpochMillis()),
           ),
-        'Failed to enqueue resumed schedule.',
-      )
+        catch: (cause) => toPlanSchedulerError('Failed to enqueue resumed schedule.', cause),
+      })
     })
 
   const listSchedulesEffect = (threadId: RecordIdInput) =>
-    effectTryPromise(
-      () =>
-        db.findMany(
-          TABLES.PLAN_SCHEDULE,
-          { threadId: ensureRecordId(threadId, TABLES.THREAD) },
-          PlanScheduleRecordSchema,
-          { orderBy: 'createdAt', orderDir: 'ASC' },
-        ),
-      'Failed to list schedules.',
-    )
+    db
+      .findMany(TABLES.PLAN_SCHEDULE, { threadId: ensureRecordId(threadId, TABLES.THREAD) }, PlanScheduleRecordSchema, {
+        orderBy: 'createdAt',
+        orderDir: 'ASC',
+      })
+      .pipe(Effect.mapError((cause) => toPlanSchedulerError('Failed to list schedules.', cause)))
 
   return {
     createSchedule: createScheduleEffect,
+    /**
+     * Sync wrapper for legacy callers. Throws `PlanSchedulerError` on
+     * invalid specs. The underlying `computeNextFireAtEffect` has no layer
+     * requirements so `Effect.runSync` is safe here.
+     */
     computeNextFireAt(spec: PlanScheduleSpec, baseTime: Date = nowDate()): Date {
-      return computeNextFireAt(spec, baseTime)
+      return Effect.runSync(computeNextFireAtEffect(spec, baseTime))
     },
     /** Called by the BullMQ worker when a fire-schedule job executes. */
     fireScheduleById: fireScheduleByIdEffect,

package/src/services/plan/plan-template.service.ts

@@ -50,7 +50,7 @@ type InstantiateTemplateParams = {
 }
 
 class PlanTemplateNotFoundError extends Schema.TaggedErrorClass<PlanTemplateNotFoundError>()(
-  'PlanTemplateNotFoundError',
+  '@lota-sdk/core/PlanTemplateNotFoundError',
   { templateId: Schema.String, message: Schema.String },
 ) {}
 

package/src/services/plan/plan-transaction-events.ts

@@ -5,7 +5,7 @@ import type { DatabaseTransaction, SurrealDBService } from '../../db/service'
 import type { makePlanEventDeliveryService } from './plan-event-delivery.service'
 
 class PlanTransactionEventsError extends Schema.TaggedErrorClass<PlanTransactionEventsError>()(
-  'PlanTransactionEventsError',
+  '@lota-sdk/core/PlanTransactionEventsError',
   { message: Schema.String, cause: Schema.optional(Schema.Defect) },
 ) {}
 

package/src/services/plan/plan-workspace.service.ts

@@ -1,14 +1,11 @@
 import { Context, Effect, Layer, Schema } from 'effect'
 
 import { ServiceError } from '../../effect/errors'
-import { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
 import { RedisServiceTag } from '../../effect/services'
 import { toValidationError } from '../../effect/zod'
 import type { RedisConnectionManager } from '../../redis/connection'
 import { nowEpochMillis } from '../../utils/date-time'
 
-const tryWorkspacePromise = makeEffectTryPromiseWithMessage((message, cause) => new ServiceError({ message, cause }))
-
 const PlanWorkspaceEntrySchema = Schema.Struct({
   value: Schema.Unknown,
   version: Schema.Number,
@@ -59,10 +56,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
         timestamp: nowEpochMillis(),
       }
       const serialized = yield* Schema.encodeEffect(PlanWorkspaceEntryJsonSchema)(entry)
-      yield* tryWorkspacePromise(
-        () => conn.hset(hashKey, fieldKey, serialized),
-        'Failed to write plan workspace entry.',
-      )
+      yield* Effect.tryPromise({
+        try: () => conn.hset(hashKey, fieldKey, serialized),
+        catch: (cause) => new ServiceError({ message: 'Failed to write plan workspace entry.', cause }),
+      })
     })
 
   const snapshotReadEffect = (params: { runId: string; readerNodeId: string; snapshotSequence?: number }) =>
@@ -70,7 +67,10 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const conn = redis.getConnection()
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const nodePrefix = `${params.readerNodeId}:`
-      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace snapshot.')
+      const all = yield* Effect.tryPromise({
+        try: () => conn.hgetall(hashKey),
+        catch: (cause) => new ServiceError({ message: 'Failed to read plan workspace snapshot.', cause }),
+      })
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [fieldKey, raw] of Object.entries(all)) {
         if (!fieldKey.startsWith(nodePrefix)) continue
@@ -89,11 +89,17 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
       const hashKey = `${PLAN_WORKSPACE_KEY_PREFIX}${params.runId}`
       const key = params.key
       if (key !== undefined) {
-        const raw = yield* tryWorkspacePromise(() => conn.hget(hashKey, key), 'Failed to read plan workspace entry.')
+        const raw = yield* Effect.tryPromise({
+          try: () => conn.hget(hashKey, key),
+          catch: (cause) => new ServiceError({ message: 'Failed to read plan workspace entry.', cause }),
+        })
         if (!raw) return {}
         return { [key]: yield* parsePlanWorkspaceEntryEffect(key, raw) }
       }
-      const all = yield* tryWorkspacePromise(() => conn.hgetall(hashKey), 'Failed to read plan workspace entries.')
+      const all = yield* Effect.tryPromise({
+        try: () => conn.hgetall(hashKey),
+        catch: (cause) => new ServiceError({ message: 'Failed to read plan workspace entries.', cause }),
+      })
       const result: Record<string, PlanWorkspaceEntry> = {}
       for (const [k, v] of Object.entries(all)) {
         result[k] = yield* parsePlanWorkspaceEntryEffect(k, v)
@@ -103,10 +109,13 @@ export function makePlanWorkspaceService(redis: RedisConnectionManager) {
 
   const cleanupEffect = (runId: string) =>
     Effect.asVoid(
-      tryWorkspacePromise(() => {
-        const conn = redis.getConnection()
-        return conn.del(`${PLAN_WORKSPACE_KEY_PREFIX}${runId}`)
-      }, 'Failed to clean up plan workspace.'),
+      Effect.tryPromise({
+        try: () => {
+          const conn = redis.getConnection()
+          return conn.del(`${PLAN_WORKSPACE_KEY_PREFIX}${runId}`)
+        },
+        catch: (cause) => new ServiceError({ message: 'Failed to clean up plan workspace.', cause }),
+      }),
     )
 
   return {