@lota-sdk/core 0.4.9 → 0.4.10

package/src/services/plan/plan-event-delivery.service.ts

@@ -187,67 +187,72 @@ export function makePlanEventDeliveryService(deps: PlanEventDeliveryDeps) {
     })
   }
 
-  function dispatchEventEffect(event: PlanEventRecord) {
-    return Effect.gen(function* () {
-      const eventId = recordIdToString(event.id, TABLES.PLAN_EVENT)
-      const deliveredKey = buildDeliveredKey(eventId)
-      const exists = yield* Effect.tryPromise({
-        try: () => redis.getConnection().exists(deliveredKey),
-        catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
-      })
-      if (exists) {
-        return
-      }
+  const dispatchEventEffect = Effect.fn('PlanEventDelivery.dispatchEvent')(function* (event: PlanEventRecord) {
+    const eventId = recordIdToString(event.id, TABLES.PLAN_EVENT)
+    const deliveredKey = buildDeliveredKey(eventId)
+    const exists = yield* Effect.tryPromise({
+      try: () => redis.getConnection().exists(deliveredKey),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
+    })
+    if (exists) {
+      return
+    }
 
-      yield* deliverEvent(event)
-      yield* Effect.tryPromise({
-        try: () => redis.getConnection().set(deliveredKey, '1', 'PX', PLAN_EVENT_DELIVERED_TTL_MS),
-        catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
-      })
+    yield* deliverEvent(event)
+    yield* Effect.tryPromise({
+      try: () => redis.getConnection().set(deliveredKey, '1', 'PX', PLAN_EVENT_DELIVERED_TTL_MS),
+      catch: (error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error }),
     })
-  }
+  })
 
-  function dispatchUndeliveredEventsEffect(runId: string, options?: { limit?: number }) {
-    return Effect.gen(function* () {
-      const run = yield* planRunService
-        .getRunById(runId)
-        .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
-      const events = yield* planRunService
-        .listEvents(run.id, options?.limit ?? 200)
-        .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
+  const dispatchUndeliveredEventsEffect = Effect.fn('PlanEventDelivery.dispatchUndeliveredEvents')(function* (
+    runId: string,
+    options?: { limit?: number },
+  ) {
+    const run = yield* planRunService
+      .getRunById(runId)
+      .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
+    const events = yield* planRunService
+      .listEvents(run.id, options?.limit ?? 200)
+      .pipe(Effect.mapError((error) => new PlanEventDeliveryError({ message: getErrorMessage(error), cause: error })))
 
-      for (const event of events) {
-        yield* dispatchEventEffect(event)
-      }
-    })
-  }
+    for (const event of events) {
+      yield* dispatchEventEffect(event)
+    }
+  })
+
+  const dispatchEventsEffect = Effect.fn('PlanEventDelivery.dispatchEvents')(function* (events: PlanEventRecord[]) {
+    const runIds = new Set(events.map((event) => recordIdToString(event.runId, TABLES.PLAN_RUN)))
+    for (const runId of runIds) {
+      yield* dispatchUndeliveredEventsEffect(runId)
+    }
+  })
 
   return {
     dispatchEvents(events: PlanEventRecord[]): Promise<void> {
-      return runPromise(
-        Effect.gen(function* () {
-          const runIds = new Set(events.map((event) => recordIdToString(event.runId, TABLES.PLAN_RUN)))
-          for (const runId of runIds) {
-            yield* dispatchUndeliveredEventsEffect(runId)
-          }
-        }),
-      )
+      return runPromise(dispatchEventsEffect(events))
     },
 
+    dispatchEventsEffect,
+
     dispatchEvent(event: PlanEventRecord): Promise<void> {
       return runPromise(dispatchEventEffect(event))
     },
 
+    dispatchEventEffect,
+
     dispatchUndeliveredEvents(runId: string, options?: { limit?: number }): Promise<void> {
       return runPromise(dispatchUndeliveredEventsEffect(runId, options))
     },
+
+    dispatchUndeliveredEventsEffect,
   }
 }
 
 export class PlanEventDeliveryServiceTag extends Context.Service<
   PlanEventDeliveryServiceTag,
   ReturnType<typeof makePlanEventDeliveryService>
->()('PlanEventDeliveryService') {}
+>()('@lota-sdk/core/PlanEventDeliveryService') {}
 
 export const PlanEventDeliveryServiceLive = Layer.effect(
   PlanEventDeliveryServiceTag,

package/src/services/plan/plan-executor-graph.ts

@@ -6,7 +6,8 @@ import type {
   PlanSpecRecord,
 } from '@lota-sdk/shared'
 import { PlanNodeRunSchema } from '@lota-sdk/shared'
-import { Effect } from 'effect'
+import { Effect, Match, Schema } from 'effect'
+import type { z } from 'zod'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId, recordIdToString } from '../../db/record-id'
@@ -29,6 +30,22 @@ import { emitEvent, replaceRun } from './plan-executor-persistence'
 
 const delayedNodePromotionQueueModule = Effect.tryPromise(() => import('../../queues/delayed-node-promotion.queue'))
 
+class PlanExecutorGraphError extends Schema.TaggedErrorClass<PlanExecutorGraphError>()('PlanExecutorGraphError', {
+  message: Schema.String,
+  cause: Schema.optional(Schema.Defect),
+}) {}
+
+function parseRowOrFail<T>(
+  schema: z.ZodType<T>,
+  value: unknown,
+  operation: string,
+): Effect.Effect<T, PlanExecutorGraphError> {
+  return Effect.try({
+    try: () => schema.parse(value),
+    catch: (cause) => new PlanExecutorGraphError({ message: `Failed to parse ${operation} row`, cause }),
+  })
+}
+
 export function syncRunGraph(
   context: PlanExecutorContext,
   params: {
@@ -150,14 +167,13 @@ export function syncRunGraph(
           }
 
           if (nodeSpec.upstreamNodeIds.length > 0 && activeIncomingEdges.length === 0) {
-            const skippedNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, {
-                status: 'skipped',
-                completedAt: currentTime,
-                blockedReason: null,
-                failureClass: null,
-              }),
-            )
+            const skippedNodeRunRow = yield* updateNodeRun(nodeRun, {
+              status: 'skipped',
+              completedAt: currentTime,
+              blockedReason: null,
+              failureClass: null,
+            })
+            const skippedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, skippedNodeRunRow, 'plan node run')
             replaceNodeRun(skippedNodeRun)
             yield* emitEvent({
               tx: params.tx,
@@ -186,9 +202,12 @@ export function syncRunGraph(
           const hasNonImmediateSchedule = nodeSchedule && nodeSchedule.type !== 'immediate'
 
           if (hasNonImmediateSchedule) {
-            const scheduledNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
-            )
+            const scheduledNodeRunRow = yield* updateNodeRun(nodeRun, {
+              status: 'scheduled',
+              resolvedInput,
+              scheduledAt: currentTime,
+            })
+            const scheduledNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, scheduledNodeRunRow, 'plan node run')
             replaceNodeRun(scheduledNodeRun)
             yield* planSchedulerService.createSchedule({
               organizationId: currentRun.organizationId,
@@ -214,9 +233,12 @@ export function syncRunGraph(
           } else if (nodeSpec.delayAfterPredecessorMs) {
             const delayAfterPredecessorMs = nodeSpec.delayAfterPredecessorMs
             const { enqueueDelayedNodePromotion } = yield* delayedNodePromotionQueueModule
-            const scheduledNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'scheduled', resolvedInput, scheduledAt: currentTime }),
-            )
+            const scheduledNodeRunRow = yield* updateNodeRun(nodeRun, {
+              status: 'scheduled',
+              resolvedInput,
+              scheduledAt: currentTime,
+            })
+            const scheduledNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, scheduledNodeRunRow, 'plan node run')
             replaceNodeRun(scheduledNodeRun)
             yield* Effect.tryPromise(() =>
               enqueueDelayedNodePromotion(
@@ -242,9 +264,12 @@ export function syncRunGraph(
             })
             changed = true
           } else {
-            const readyNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'ready', resolvedInput, readyAt: currentTime }),
-            )
+            const readyNodeRunRow = yield* updateNodeRun(nodeRun, {
+              status: 'ready',
+              resolvedInput,
+              readyAt: currentTime,
+            })
+            const readyNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, readyNodeRunRow, 'plan node run')
             replaceNodeRun(readyNodeRun)
             yield* emitEvent({
               tx: params.tx,
@@ -271,13 +296,12 @@ export function syncRunGraph(
           const nodeRun = getNodeRunsById().get(nodeSpec.nodeId)
           if (!nodeRun) continue
 
-          const completedNodeRun = PlanNodeRunSchema.parse(
-            yield* updateNodeRun(nodeRun, {
-              status: 'completed',
-              startedAt: nodeRun.startedAt ?? currentTime,
-              completedAt: currentTime,
-            }),
-          )
+          const completedNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'completed',
+            startedAt: nodeRun.startedAt ?? currentTime,
+            completedAt: currentTime,
+          })
+          const completedNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, completedNodeRunRow, 'plan node run')
           replaceNodeRun(completedNodeRun)
           yield* emitEvent({
             tx: params.tx,
@@ -318,8 +342,14 @@ export function syncRunGraph(
               message: `Expected ready node run for "${nextHumanNodeSpec.nodeId}".`,
             })
           }
-          const awaitingHumanNodeRun = PlanNodeRunSchema.parse(
-            yield* updateNodeRun(nodeRun, { status: 'awaiting-human', startedAt: nodeRun.startedAt ?? currentTime }),
+          const awaitingHumanNodeRunRow = yield* updateNodeRun(nodeRun, {
+            status: 'awaiting-human',
+            startedAt: nodeRun.startedAt ?? currentTime,
+          })
+          const awaitingHumanNodeRun = yield* parseRowOrFail(
+            PlanNodeRunSchema,
+            awaitingHumanNodeRunRow,
+            'plan node run',
           )
           replaceNodeRun(awaitingHumanNodeRun)
 
@@ -377,9 +407,11 @@ export function syncRunGraph(
                 message: `Expected ready node run for "${nextActionNodeSpec.nodeId}".`,
               })
             }
-            const runningNodeRun = PlanNodeRunSchema.parse(
-              yield* updateNodeRun(nodeRun, { status: 'running', startedAt: nodeRun.startedAt ?? currentTime }),
-            )
+            const runningNodeRunRow = yield* updateNodeRun(nodeRun, {
+              status: 'running',
+              startedAt: nodeRun.startedAt ?? currentTime,
+            })
+            const runningNodeRun = yield* parseRowOrFail(PlanNodeRunSchema, runningNodeRunRow, 'plan node run')
             replaceNodeRun(runningNodeRun)
 
             currentRun = yield* replaceRun(params.tx, currentRun, {
@@ -418,44 +450,59 @@ export function syncRunGraph(
               emittedBy: params.emittedBy,
               capturedEvents: params.capturedEvents,
             })
-          } else if (currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))) {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'completed',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: [],
-              completedAt: currentTime,
-            })
-
-            yield* emitEvent({
-              tx: params.tx,
-              run: currentRun,
-              spec: params.spec,
-              eventType: 'run-status-changed',
-              fromStatus: params.run.status,
-              toStatus: currentRun.status,
-              message: `Run "${params.spec.title}" completed.`,
-              emittedBy: params.emittedBy,
-              capturedEvents: params.capturedEvents,
-            })
-          } else if (hasScheduledOrMonitoring) {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'running',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: currentNodeRuns
-                .filter((candidate) => candidate.status === 'ready')
-                .map((candidate) => candidate.nodeId),
-            })
           } else {
-            currentRun = yield* replaceRun(params.tx, currentRun, {
-              status: 'blocked',
-              currentNodeId: null,
-              waitingNodeId: null,
-              readyNodeIds: currentNodeRuns
-                .filter((candidate) => candidate.status === 'ready')
-                .map((candidate) => candidate.nodeId),
-            })
+            const allTerminalSuccess = currentNodeRuns.every((nodeRun) => isSuccessfulTerminalStatus(nodeRun.status))
+            const runStatus: 'completed' | 'running' | 'blocked' = allTerminalSuccess
+              ? 'completed'
+              : hasScheduledOrMonitoring
+                ? 'running'
+                : 'blocked'
+            const readyIds = currentNodeRuns
+              .filter((candidate) => candidate.status === 'ready')
+              .map((candidate) => candidate.nodeId)
+
+            currentRun = yield* Match.value(runStatus).pipe(
+              Match.when('completed', () =>
+                replaceRun(params.tx, currentRun, {
+                  status: 'completed',
+                  currentNodeId: null,
+                  waitingNodeId: null,
+                  readyNodeIds: [],
+                  completedAt: currentTime,
+                }),
+              ),
+              Match.when('running', () =>
+                replaceRun(params.tx, currentRun, {
+                  status: 'running',
+                  currentNodeId: null,
+                  waitingNodeId: null,
+                  readyNodeIds: readyIds,
+                }),
+              ),
+              Match.when('blocked', () =>
+                replaceRun(params.tx, currentRun, {
+                  status: 'blocked',
+                  currentNodeId: null,
+                  waitingNodeId: null,
+                  readyNodeIds: readyIds,
+                }),
+              ),
+              Match.exhaustive,
+            )
+
+            if (runStatus === 'completed') {
+              yield* emitEvent({
+                tx: params.tx,
+                run: currentRun,
+                spec: params.spec,
+                eventType: 'run-status-changed',
+                fromStatus: params.run.status,
+                toStatus: currentRun.status,
+                message: `Run "${params.spec.title}" completed.`,
+                emittedBy: params.emittedBy,
+                capturedEvents: params.capturedEvents,
+              })
+            }
           }
         }
       } else {

package/src/services/plan/plan-executor-helpers.ts

@@ -12,7 +12,7 @@ import {
   isSafePath,
   isSafePathOrRoot,
 } from '@lota-sdk/shared'
-import { Effect } from 'effect'
+import { Effect, Schema } from 'effect'
 
 import type { RecordIdInput } from '../../db/record-id'
 import { ensureRecordId } from '../../db/record-id'
@@ -25,10 +25,11 @@ import { isExecutableConditionExpression, readPathValue } from './plan-helpers'
 const SUCCESSFUL_TERMINAL_NODE_STATUSES = new Set(['completed', 'partial', 'skipped', 'scheduled', 'monitoring'])
 const HUMAN_NODE_TYPE_SET = new Set<string>(HUMAN_NODE_TYPE_VALUES)
 const STRUCTURAL_NODE_TYPE_SET = new Set<string>(STRUCTURAL_NODE_TYPE_VALUES)
+const decodeJsonLiteralEffect = Schema.decodeUnknownEffect(Schema.UnknownFromJsonString)
 
 function parseLiteralValue(raw: string): Effect.Effect<unknown> {
   const trimmed = raw.trim()
-  if (!trimmed.length) return Effect.succeed(undefined)
+  if (!trimmed.length) return Effect.void
   if (trimmed === 'true') return Effect.succeed(true)
   if (trimmed === 'false') return Effect.succeed(false)
   if (trimmed === 'null') return Effect.succeed(null)
@@ -41,9 +42,7 @@ function parseLiteralValue(raw: string): Effect.Effect<unknown> {
     return Effect.succeed(trimmed.slice(1, -1))
   }
 
-  return Effect.try({ try: (): unknown => JSON.parse(trimmed), catch: (cause) => cause }).pipe(
-    Effect.catch(() => Effect.succeed(trimmed)),
-  )
+  return decodeJsonLiteralEffect(trimmed).pipe(Effect.catch(() => Effect.succeed(trimmed)))
 }
 
 function buildArtifactContext(artifacts: Array<{ name: string; kind: string; payload?: unknown }>) {
@@ -149,7 +148,53 @@ type PlanNodeRunUpdate = Omit<
   completedAt?: string | Date | null
 }
 
+function patchField<K extends string, V>(
+  key: K,
+  patch: V | null | undefined,
+  existing: V | undefined,
+): Partial<Record<K, V>> {
+  if (patch === null) return {}
+  if (patch !== undefined) return { [key]: patch } as Partial<Record<K, V>>
+  if (existing !== undefined) return { [key]: existing } as Partial<Record<K, V>>
+  return {}
+}
+
 export function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpdate) {
+  const patchedAttemptId =
+    patch.latestAttemptId === null
+      ? null
+      : patch.latestAttemptId !== undefined
+        ? ensureRecordId(patch.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT)
+        : undefined
+  const existingAttemptId =
+    nodeRun.latestAttemptId !== undefined
+      ? ensureRecordId(nodeRun.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT)
+      : undefined
+
+  const patchedScheduledAt =
+    patch.scheduledAt === null
+      ? null
+      : patch.scheduledAt !== undefined
+        ? toDatabaseDateTime(patch.scheduledAt)
+        : undefined
+  const existingScheduledAt = nodeRun.scheduledAt !== undefined ? toDatabaseDateTime(nodeRun.scheduledAt) : undefined
+
+  const patchedReadyAt =
+    patch.readyAt === null ? null : patch.readyAt !== undefined ? toDatabaseDateTime(patch.readyAt) : undefined
+  const existingReadyAt = nodeRun.readyAt !== undefined ? toDatabaseDateTime(nodeRun.readyAt) : undefined
+
+  const patchedStartedAt =
+    patch.startedAt === null ? null : patch.startedAt !== undefined ? toDatabaseDateTime(patch.startedAt) : undefined
+  const existingStartedAt = nodeRun.startedAt !== undefined ? toDatabaseDateTime(nodeRun.startedAt) : undefined
+
+  const patchedCompletedAt =
+    patch.completedAt === null
+      ? null
+      : patch.completedAt !== undefined
+        ? toDatabaseDateTime(patch.completedAt)
+        : undefined
+  const existingCompletedAt = nodeRun.completedAt !== undefined ? toDatabaseDateTime(nodeRun.completedAt) : undefined
+
   return {
     runId: ensureRecordId(nodeRun.runId, TABLES.PLAN_RUN),
     planSpecId: ensureRecordId(nodeRun.planSpecId, TABLES.PLAN_SPEC),
@@ -157,76 +202,16 @@ export function toNodeRunData(nodeRun: PlanNodeRunRecord, patch: PlanNodeRunUpda
     status: patch.status ?? nodeRun.status,
     attemptCount: patch.attemptCount ?? nodeRun.attemptCount,
     retryCount: patch.retryCount ?? nodeRun.retryCount,
-    ...(patch.resolvedInput === null
-      ? {}
-      : patch.resolvedInput !== undefined
-        ? { resolvedInput: patch.resolvedInput }
-        : nodeRun.resolvedInput
-          ? { resolvedInput: nodeRun.resolvedInput }
-          : {}),
-    ...(patch.latestStructuredOutput === null
-      ? {}
-      : patch.latestStructuredOutput !== undefined
-        ? { latestStructuredOutput: patch.latestStructuredOutput }
-        : nodeRun.latestStructuredOutput
-          ? { latestStructuredOutput: nodeRun.latestStructuredOutput }
-          : {}),
-    ...(patch.latestNotes === null
-      ? {}
-      : patch.latestNotes !== undefined
-        ? { latestNotes: patch.latestNotes }
-        : nodeRun.latestNotes
-          ? { latestNotes: nodeRun.latestNotes }
-          : {}),
-    ...(patch.latestAttemptId === null
-      ? {}
-      : patch.latestAttemptId !== undefined
-        ? { latestAttemptId: ensureRecordId(patch.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT) }
-        : nodeRun.latestAttemptId
-          ? { latestAttemptId: ensureRecordId(nodeRun.latestAttemptId, TABLES.PLAN_NODE_ATTEMPT) }
-          : {}),
-    ...(patch.blockedReason === null
-      ? {}
-      : patch.blockedReason !== undefined
-        ? { blockedReason: patch.blockedReason }
-        : nodeRun.blockedReason
-          ? { blockedReason: nodeRun.blockedReason }
-          : {}),
-    ...(patch.failureClass === null
-      ? {}
-      : patch.failureClass !== undefined
-        ? { failureClass: patch.failureClass }
-        : nodeRun.failureClass
-          ? { failureClass: nodeRun.failureClass }
-          : {}),
-    ...(patch.scheduledAt === null
-      ? {}
-      : patch.scheduledAt !== undefined
-        ? { scheduledAt: toDatabaseDateTime(patch.scheduledAt) }
-        : nodeRun.scheduledAt
-          ? { scheduledAt: toDatabaseDateTime(nodeRun.scheduledAt) }
-          : {}),
-    ...(patch.readyAt === null
-      ? {}
-      : patch.readyAt !== undefined
-        ? { readyAt: toDatabaseDateTime(patch.readyAt) }
-        : nodeRun.readyAt
-          ? { readyAt: toDatabaseDateTime(nodeRun.readyAt) }
-          : {}),
-    ...(patch.startedAt === null
-      ? {}
-      : patch.startedAt !== undefined
-        ? { startedAt: toDatabaseDateTime(patch.startedAt) }
-        : nodeRun.startedAt
-          ? { startedAt: toDatabaseDateTime(nodeRun.startedAt) }
-          : {}),
-    ...(patch.completedAt === null
-      ? {}
-      : patch.completedAt !== undefined
-        ? { completedAt: toDatabaseDateTime(patch.completedAt) }
-        : nodeRun.completedAt
-          ? { completedAt: toDatabaseDateTime(nodeRun.completedAt) }
-          : {}),
+    ...patchField('resolvedInput', patch.resolvedInput, nodeRun.resolvedInput ?? undefined),
+    ...patchField('latestStructuredOutput', patch.latestStructuredOutput, nodeRun.latestStructuredOutput ?? undefined),
+    ...patchField('latestNotes', patch.latestNotes, nodeRun.latestNotes ?? undefined),
+    ...patchField('latestAttemptId', patchedAttemptId, existingAttemptId),
+    ...patchField('blockedReason', patch.blockedReason, nodeRun.blockedReason ?? undefined),
+    ...patchField('failureClass', patch.failureClass, nodeRun.failureClass ?? undefined),
+    ...patchField('scheduledAt', patchedScheduledAt, existingScheduledAt),
+    ...patchField('readyAt', patchedReadyAt, existingReadyAt),
+    ...patchField('startedAt', patchedStartedAt, existingStartedAt),
+    ...patchField('completedAt', patchedCompletedAt, existingCompletedAt),
   }
 }