@lota-sdk/core 0.4.13 → 0.4.15

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

@@ -33,7 +33,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 { makeEffectTryPromiseWithMessage } from '../../effect/helpers'
+import { ERROR_TAGS } from '../../effect/errors'
 import { DatabaseServiceTag } from '../../effect/services'
 import { toIsoDateTimeString, toOptionalIsoDateTimeString } from '../../utils/date-time'
 
@@ -159,41 +159,37 @@ function serializeEvent(event: PlanEventRecord): SerializablePlanEvent {
   }
 }
 
-class PlanRunServiceError extends Schema.TaggedErrorClass<PlanRunServiceError>()('PlanRunServiceError', {
+class PlanRunServiceError extends Schema.TaggedErrorClass<PlanRunServiceError>()(ERROR_TAGS.PlanRunServiceError, {
   message: Schema.String,
   cause: Schema.optional(Schema.Defect),
 }) {}
 
-class PlanRunNotFoundError extends Schema.TaggedErrorClass<PlanRunNotFoundError>()('PlanRunNotFoundError', {
+class PlanRunNotFoundError extends Schema.TaggedErrorClass<PlanRunNotFoundError>()(ERROR_TAGS.PlanRunNotFoundError, {
   message: Schema.String,
   entity: Schema.Literals(['plan spec', 'plan run', 'plan node spec', 'plan node run']),
   id: Schema.String,
 }) {}
 
 class PlanRunSerializationError extends Schema.TaggedErrorClass<PlanRunSerializationError>()(
-  'PlanRunSerializationError',
+  '@lota-sdk/core/PlanRunSerializationError',
   { message: Schema.String },
 ) {}
 
-const effectTryPlanRunPromise = makeEffectTryPromiseWithMessage(
-  (message, cause) => new PlanRunServiceError({ message, cause }),
-)
-
-function tryPlanRunPromise<A>(
-  message: string,
-  evaluate: () => PromiseLike<A> | Effect.Effect<A, unknown>,
-): Effect.Effect<A, PlanRunServiceError> {
-  return effectTryPlanRunPromise(evaluate, message)
+function toPlanRunServiceError(message: string, cause: unknown): PlanRunServiceError {
+  return new PlanRunServiceError({ message, cause })
 }
 
 export function makePlanRunService(db: SurrealDBService) {
   const getPlanSpecByIdEffect = (planSpecId: RecordIdInput) =>
     Effect.gen(function* () {
       const planSpecRecordId = ensureRecordId(planSpecId, TABLES.PLAN_SPEC)
-      const spec = yield* tryPlanRunPromise(
-        `Failed to load plan spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`,
-        () => db.findOne(TABLES.PLAN_SPEC, { id: planSpecRecordId }, PlanSpecSchema),
-      )
+      const spec = yield* db
+        .findOne(TABLES.PLAN_SPEC, { id: planSpecRecordId }, PlanSpecSchema)
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(`Failed to load plan spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`, cause),
+          ),
+        )
 
       if (!spec) {
         return yield* new PlanRunNotFoundError({
@@ -207,40 +203,61 @@ export function makePlanRunService(db: SurrealDBService) {
     })
 
   const listPlanSpecsByThreadEffect = (threadId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan specs for thread ${recordIdToString(threadId, TABLES.THREAD)}`, () =>
-      db.findMany(TABLES.PLAN_SPEC, { threadId: ensureRecordId(threadId, TABLES.THREAD) }, PlanSpecSchema, {
+    db
+      .findMany(TABLES.PLAN_SPEC, { threadId: ensureRecordId(threadId, TABLES.THREAD) }, PlanSpecSchema, {
         orderBy: 'createdAt',
         orderDir: 'DESC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan specs for thread ${recordIdToString(threadId, TABLES.THREAD)}`,
+            cause,
+          ),
+        ),
+      )
 
   const listRunsBySpecEffect = (planSpecId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan runs for spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`, () =>
-      db.findMany(TABLES.PLAN_RUN, { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) }, PlanRunSchema, {
+    db
+      .findMany(TABLES.PLAN_RUN, { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) }, PlanRunSchema, {
         orderBy: 'createdAt',
         orderDir: 'DESC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan runs for spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`,
+            cause,
+          ),
+        ),
+      )
 
   const listNodeSpecsEffect = (planSpecId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan node specs for spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`, () =>
-      db.findMany(
+    db
+      .findMany(
         TABLES.PLAN_NODE_SPEC,
         { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC) },
         PlanNodeSpecRecordSchema,
         { orderBy: 'position', orderDir: 'ASC' },
-      ),
-    )
+      )
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan node specs for spec ${recordIdToString(planSpecId, TABLES.PLAN_SPEC)}`,
+            cause,
+          ),
+        ),
+      )
 
   const getNodeSpecByNodeIdEffect = (planSpecId: RecordIdInput, nodeId: string) =>
     Effect.gen(function* () {
-      const nodeSpec = yield* tryPlanRunPromise(`Failed to load plan node spec "${nodeId}"`, () =>
-        db.findOne(
+      const nodeSpec = yield* db
+        .findOne(
           TABLES.PLAN_NODE_SPEC,
           { planSpecId: ensureRecordId(planSpecId, TABLES.PLAN_SPEC), nodeId },
           PlanNodeSpecRecordSchema,
-        ),
-      )
+        )
+        .pipe(Effect.mapError((cause) => toPlanRunServiceError(`Failed to load plan node spec "${nodeId}"`, cause)))
 
       if (!nodeSpec) {
         return yield* new PlanRunNotFoundError({
@@ -256,9 +273,13 @@ export function makePlanRunService(db: SurrealDBService) {
   const getRunByIdEffect = (runId: RecordIdInput) =>
     Effect.gen(function* () {
       const runRecordId = ensureRecordId(runId, TABLES.PLAN_RUN)
-      const run = yield* tryPlanRunPromise(`Failed to load plan run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, () =>
-        db.findOne(TABLES.PLAN_RUN, { id: runRecordId }, PlanRunSchema),
-      )
+      const run = yield* db
+        .findOne(TABLES.PLAN_RUN, { id: runRecordId }, PlanRunSchema)
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(`Failed to load plan run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, cause),
+          ),
+        )
 
       if (!run) {
         return yield* new PlanRunNotFoundError({
@@ -273,14 +294,19 @@ export function makePlanRunService(db: SurrealDBService) {
 
   const getActiveRunRecordsEffect = (threadId: RecordIdInput) =>
     Effect.gen(function* () {
-      const runs = yield* tryPlanRunPromise(
-        `Failed to load active plan runs for thread ${recordIdToString(threadId, TABLES.THREAD)}`,
-        () =>
-          db.findMany(TABLES.PLAN_RUN, { threadId: ensureRecordId(threadId, TABLES.THREAD) }, PlanRunSchema, {
-            orderBy: 'updatedAt',
-            orderDir: 'DESC',
-          }),
-      )
+      const runs = yield* db
+        .findMany(TABLES.PLAN_RUN, { threadId: ensureRecordId(threadId, TABLES.THREAD) }, PlanRunSchema, {
+          orderBy: 'updatedAt',
+          orderDir: 'DESC',
+        })
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(
+              `Failed to load active plan runs for thread ${recordIdToString(threadId, TABLES.THREAD)}`,
+              cause,
+            ),
+          ),
+        )
       return runs.filter((run) => ACTIVE_RUN_STATUSES.has(run.status))
     })
 
@@ -305,26 +331,39 @@ export function makePlanRunService(db: SurrealDBService) {
       }
 
       const statuses = params.statuses ? new Set(params.statuses) : ACTIVE_RUN_STATUSES
-      const runs = yield* tryPlanRunPromise(
-        `Failed to load execution plans in context ${recordIdToString(params.organizationId, TABLES.ORGANIZATION)}`,
-        () => db.findMany(TABLES.PLAN_RUN, filter, PlanRunSchema, { orderBy: 'updatedAt', orderDir: 'DESC' }),
-      )
+      const runs = yield* db
+        .findMany(TABLES.PLAN_RUN, filter, PlanRunSchema, { orderBy: 'updatedAt', orderDir: 'DESC' })
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(
+              `Failed to load execution plans in context ${recordIdToString(params.organizationId, TABLES.ORGANIZATION)}`,
+              cause,
+            ),
+          ),
+        )
       return runs.filter((run) => statuses.has(run.status))
     })
 
   const listNodeRunsEffect = (runId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan node runs for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, () =>
-      db.findMany(TABLES.PLAN_NODE_RUN, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanNodeRunSchema, {
+    db
+      .findMany(TABLES.PLAN_NODE_RUN, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanNodeRunSchema, {
         orderBy: 'nodeId',
         orderDir: 'ASC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan node runs for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+            cause,
+          ),
+        ),
+      )
 
   const getNodeRunByNodeIdEffect = (runId: RecordIdInput, nodeId: string) =>
     Effect.gen(function* () {
-      const nodeRun = yield* tryPlanRunPromise(`Failed to load plan node run "${nodeId}"`, () =>
-        db.findOne(TABLES.PLAN_NODE_RUN, { runId: ensureRecordId(runId, TABLES.PLAN_RUN), nodeId }, PlanNodeRunSchema),
-      )
+      const nodeRun = yield* db
+        .findOne(TABLES.PLAN_NODE_RUN, { runId: ensureRecordId(runId, TABLES.PLAN_RUN), nodeId }, PlanNodeRunSchema)
+        .pipe(Effect.mapError((cause) => toPlanRunServiceError(`Failed to load plan node run "${nodeId}"`, cause)))
 
       if (!nodeRun) {
         return yield* new PlanRunNotFoundError({
@@ -338,20 +377,34 @@ export function makePlanRunService(db: SurrealDBService) {
     })
 
   const listArtifactsEffect = (runId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan artifacts for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, () =>
-      db.findMany(TABLES.PLAN_ARTIFACT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanArtifactSchema, {
+    db
+      .findMany(TABLES.PLAN_ARTIFACT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanArtifactSchema, {
         orderBy: 'createdAt',
         orderDir: 'ASC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan artifacts for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+            cause,
+          ),
+        ),
+      )
 
   const listAttemptsEffect = (runId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan attempts for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, () =>
-      db.findMany(TABLES.PLAN_NODE_ATTEMPT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanNodeAttemptSchema, {
+    db
+      .findMany(TABLES.PLAN_NODE_ATTEMPT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanNodeAttemptSchema, {
         orderBy: 'createdAt',
         orderDir: 'ASC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan attempts for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+            cause,
+          ),
+        ),
+      )
 
   const listValidationIssuesEffect = (params: {
     runId?: RecordIdInput
@@ -364,33 +417,45 @@ export function makePlanRunService(db: SurrealDBService) {
       if (params.planSpecId) filter.planSpecId = ensureRecordId(params.planSpecId, TABLES.PLAN_SPEC)
       if (params.attemptId) filter.attemptId = ensureRecordId(params.attemptId, TABLES.PLAN_NODE_ATTEMPT)
 
-      return yield* tryPlanRunPromise('Failed to load plan validation issues', () =>
-        db.findMany(TABLES.PLAN_VALIDATION_ISSUE, filter, PlanValidationIssueSchema, {
+      return yield* db
+        .findMany(TABLES.PLAN_VALIDATION_ISSUE, filter, PlanValidationIssueSchema, {
           orderBy: 'createdAt',
           orderDir: 'ASC',
-        }),
-      )
+        })
+        .pipe(Effect.mapError((cause) => toPlanRunServiceError('Failed to load plan validation issues', cause)))
     })
 
   const listApprovalsEffect = (runId: RecordIdInput) =>
-    tryPlanRunPromise(`Failed to load plan approvals for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`, () =>
-      db.findMany(TABLES.PLAN_APPROVAL, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanApprovalSchema, {
+    db
+      .findMany(TABLES.PLAN_APPROVAL, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanApprovalSchema, {
         orderBy: 'createdAt',
         orderDir: 'ASC',
-      }),
-    )
+      })
+      .pipe(
+        Effect.mapError((cause) =>
+          toPlanRunServiceError(
+            `Failed to load plan approvals for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+            cause,
+          ),
+        ),
+      )
 
   const getLatestCheckpointEffect = (runId: RecordIdInput) =>
     Effect.gen(function* () {
-      const checkpoints = yield* tryPlanRunPromise(
-        `Failed to load latest checkpoint for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
-        () =>
-          db.findMany(TABLES.PLAN_CHECKPOINT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanCheckpointSchema, {
-            orderBy: 'sequence',
-            orderDir: 'DESC',
-            limit: 1,
-          }),
-      )
+      const checkpoints = yield* db
+        .findMany(TABLES.PLAN_CHECKPOINT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanCheckpointSchema, {
+          orderBy: 'sequence',
+          orderDir: 'DESC',
+          limit: 1,
+        })
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(
+              `Failed to load latest checkpoint for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+              cause,
+            ),
+          ),
+        )
       return checkpoints.at(0) ?? null
     })
 
@@ -401,15 +466,20 @@ export function makePlanRunService(db: SurrealDBService) {
 
   const listEventsEffect = (runId: RecordIdInput, limit = 20) =>
     Effect.gen(function* () {
-      const events = yield* tryPlanRunPromise(
-        `Failed to load plan events for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
-        () =>
-          db.findMany(TABLES.PLAN_EVENT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanEventSchema, {
-            orderBy: 'createdAt',
-            orderDir: 'DESC',
-            limit,
-          }),
-      )
+      const events = yield* db
+        .findMany(TABLES.PLAN_EVENT, { runId: ensureRecordId(runId, TABLES.PLAN_RUN) }, PlanEventSchema, {
+          orderBy: 'createdAt',
+          orderDir: 'DESC',
+          limit,
+        })
+        .pipe(
+          Effect.mapError((cause) =>
+            toPlanRunServiceError(
+              `Failed to load plan events for run ${recordIdToString(runId, TABLES.PLAN_RUN)}`,
+              cause,
+            ),
+          ),
+        )
       return [...events].reverse()
     })
 
@@ -424,10 +494,16 @@ export function makePlanRunService(db: SurrealDBService) {
             return []
           }
 
-          const previousRun = yield* tryPlanRunPromise(
-            `Failed to load lineage run ${recordIdToString(currentRunId, TABLES.PLAN_RUN)}`,
-            () => db.findOne(TABLES.PLAN_RUN, { id: currentRunId }, PlanRunSchema),
-          )
+          const previousRun = yield* db
+            .findOne(TABLES.PLAN_RUN, { id: currentRunId }, PlanRunSchema)
+            .pipe(
+              Effect.mapError((cause) =>
+                toPlanRunServiceError(
+                  `Failed to load lineage run ${recordIdToString(currentRunId, TABLES.PLAN_RUN)}`,
+                  cause,
+                ),
+              ),
+            )
           if (!previousRun) {
             return []
           }