@pikku/redis 0.11.2 → 0.12.1

package/src/redis-workflow-run-service.ts

@@ -0,0 +1,227 @@
+import type {
+  WorkflowRun,
+  StepState,
+  WorkflowStatus,
+  WorkflowRunService,
+} from '@pikku/core/workflow'
+import type { Redis } from 'ioredis'
+
+export class RedisWorkflowRunService implements WorkflowRunService {
+  constructor(
+    private redis: Redis,
+    private keyPrefix = 'workflows'
+  ) {}
+
+  private runKey(runId: string): string {
+    return `${this.keyPrefix}:run:${runId}`
+  }
+
+  private stepKeyPattern(runId: string): string {
+    return `${this.keyPrefix}:step:${runId}:*`
+  }
+
+  private stepHistoryKey(stepId: string): string {
+    return `${this.keyPrefix}:step-history:${stepId}`
+  }
+
+  private versionKey(name: string, graphHash: string): string {
+    return `${this.keyPrefix}:version:${name}:${graphHash}`
+  }
+
+  async listRuns(options?: {
+    workflowName?: string
+    status?: string
+    limit?: number
+    offset?: number
+  }): Promise<WorkflowRun[]> {
+    const { workflowName, status, limit = 50, offset = 0 } = options ?? {}
+
+    const runKeys = await this.scanKeys(`${this.keyPrefix}:run:*`)
+
+    const runs: WorkflowRun[] = []
+    for (const key of runKeys) {
+      const data = await this.redis.hgetall(key)
+      if (!data.id) continue
+
+      if (workflowName && data.workflow !== workflowName) continue
+      if (status && data.status !== status) continue
+
+      runs.push(this.mapRunData(data))
+    }
+
+    runs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime())
+
+    return runs.slice(offset, offset + limit)
+  }
+
+  async getRun(id: string): Promise<WorkflowRun | null> {
+    const data = await this.redis.hgetall(this.runKey(id))
+    if (!data.id) return null
+    return this.mapRunData(data)
+  }
+
+  async getRunSteps(
+    runId: string
+  ): Promise<
+    Array<StepState & { stepName: string; rpcName?: string; data?: any }>
+  > {
+    const stepKeys = await this.scanKeys(this.stepKeyPattern(runId))
+
+    const steps: Array<
+      StepState & { stepName: string; rpcName?: string; data?: any }
+    > = []
+
+    for (const key of stepKeys) {
+      const data = await this.redis.hgetall(key)
+      if (!data.stepId) continue
+
+      steps.push({
+        stepId: data.stepId,
+        stepName: this.extractStepName(key, runId),
+        rpcName: data.rpcName || undefined,
+        data: data.data ? JSON.parse(data.data) : undefined,
+        status: data.status as any,
+        result: data.result ? JSON.parse(data.result) : undefined,
+        error: data.error ? JSON.parse(data.error) : undefined,
+        attemptCount: Number(data.attemptCount || 1),
+        retries: data.retries ? Number(data.retries) : undefined,
+        retryDelay: data.retryDelay || undefined,
+        createdAt: new Date(Number(data.createdAt)),
+        updatedAt: new Date(Number(data.updatedAt)),
+      })
+    }
+
+    steps.sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime())
+
+    return steps
+  }
+
+  async getRunHistory(
+    runId: string
+  ): Promise<Array<StepState & { stepName: string }>> {
+    const stepKeys = await this.scanKeys(this.stepKeyPattern(runId))
+
+    const allHistoryEntries: Array<StepState & { stepName: string }> = []
+
+    for (const key of stepKeys) {
+      const data = await this.redis.hgetall(key)
+      if (!data.stepId) continue
+
+      const historyEntries = await this.redis.zrange(
+        this.stepHistoryKey(data.stepId),
+        0,
+        -1
+      )
+
+      for (const entryStr of historyEntries) {
+        const entry = JSON.parse(entryStr)
+        allHistoryEntries.push({
+          stepId: entry.stepId,
+          stepName: entry.stepName,
+          status: entry.status,
+          result: entry.result ? JSON.parse(entry.result) : undefined,
+          error: entry.error ? JSON.parse(entry.error) : undefined,
+          attemptCount: entry.attemptCount,
+          retries: entry.retries,
+          retryDelay: entry.retryDelay,
+          createdAt: new Date(entry.createdAt),
+          updatedAt: new Date(entry.createdAt),
+          runningAt: entry.runningAt ? new Date(entry.runningAt) : undefined,
+          scheduledAt: entry.scheduledAt
+            ? new Date(entry.scheduledAt)
+            : undefined,
+          succeededAt: entry.succeededAt
+            ? new Date(entry.succeededAt)
+            : undefined,
+          failedAt: entry.failedAt ? new Date(entry.failedAt) : undefined,
+        })
+      }
+    }
+
+    return allHistoryEntries.sort(
+      (a, b) => a.createdAt.getTime() - b.createdAt.getTime()
+    )
+  }
+
+  async getDistinctWorkflowNames(): Promise<string[]> {
+    const runKeys = await this.scanKeys(`${this.keyPrefix}:run:*`)
+
+    const names = new Set<string>()
+    for (const key of runKeys) {
+      const workflow = await this.redis.hget(key, 'workflow')
+      if (workflow) names.add(workflow)
+    }
+
+    return [...names].sort()
+  }
+
+  async getWorkflowVersion(
+    name: string,
+    graphHash: string
+  ): Promise<{ graph: any; source: string } | null> {
+    const data = await this.redis.hgetall(this.versionKey(name, graphHash))
+    if (!data.graph) return null
+    return {
+      graph: JSON.parse(data.graph),
+      source: data.source!,
+    }
+  }
+
+  async deleteRun(id: string): Promise<boolean> {
+    const exists = await this.redis.exists(this.runKey(id))
+    if (!exists) return false
+
+    const stepKeys = await this.scanKeys(this.stepKeyPattern(id))
+
+    const keysToDelete = [this.runKey(id)]
+
+    for (const stepKey of stepKeys) {
+      const stepId = await this.redis.hget(stepKey, 'stepId')
+      keysToDelete.push(stepKey)
+      if (stepId) {
+        keysToDelete.push(this.stepHistoryKey(stepId))
+      }
+    }
+
+    await this.redis.del(...keysToDelete)
+    return true
+  }
+
+  private mapRunData(data: Record<string, string>): WorkflowRun {
+    return {
+      id: data.id!,
+      workflow: data.workflow!,
+      status: data.status! as WorkflowStatus,
+      input: JSON.parse(data.input!),
+      output: data.output ? JSON.parse(data.output) : undefined,
+      error: data.error ? JSON.parse(data.error) : undefined,
+      inline: data.inline === 'true' ? true : undefined,
+      graphHash: data.graphHash || undefined,
+      wire: data.wire ? JSON.parse(data.wire) : { type: 'unknown' },
+      createdAt: new Date(Number(data.createdAt!)),
+      updatedAt: new Date(Number(data.updatedAt!)),
+    }
+  }
+
+  private extractStepName(key: string, runId: string): string {
+    const prefix = `${this.keyPrefix}:step:${runId}:`
+    return key.slice(prefix.length)
+  }
+
+  private async scanKeys(pattern: string): Promise<string[]> {
+    const keys: string[] = []
+    let cursor = '0'
+    do {
+      const [newCursor, foundKeys] = await this.redis.scan(
+        cursor,
+        'MATCH',
+        pattern,
+        'COUNT',
+        100
+      )
+      cursor = newCursor
+      keys.push(...foundKeys)
+    } while (cursor !== '0')
+    return keys
+  }
+}

package/src/redis-workflow-service.ts

@@ -2,6 +2,7 @@ import type { SerializedError } from '@pikku/core'
 import {
   PikkuWorkflowService,
   type WorkflowRun,
+  type WorkflowRunWire,
   type StepState,
   type WorkflowStatus,
 } from '@pikku/core/workflow'
@@ -204,7 +205,9 @@ export class RedisWorkflowService extends PikkuWorkflowService {
   async createRun(
     workflowName: string,
     input: any,
-    inline?: boolean
+    inline: boolean,
+    graphHash: string,
+    wire: WorkflowRunWire
   ): Promise<string> {
     const id = randomUUID()
     const now = Date.now()
@@ -223,6 +226,10 @@ export class RedisWorkflowService extends PikkuWorkflowService {
       JSON.stringify(input),
       'inline',
       inline ? 'true' : 'false',
+      'graphHash',
+      graphHash,
+      'wire',
+      JSON.stringify(wire),
       'createdAt',
       now.toString(),
       'updatedAt',
@@ -248,6 +255,8 @@ export class RedisWorkflowService extends PikkuWorkflowService {
       output: data.output ? JSON.parse(data.output) : undefined,
       error: data.error ? JSON.parse(data.error) : undefined,
       inline: data.inline === 'true' ? true : undefined,
+      graphHash: data.graphHash || undefined,
+      wire: data.wire ? JSON.parse(data.wire) : { type: 'unknown' },
       createdAt: new Date(Number(data.createdAt!)),
       updatedAt: new Date(Number(data.updatedAt!)),
     }
@@ -708,13 +717,14 @@ export class RedisWorkflowService extends PikkuWorkflowService {
 
   async getCompletedGraphState(runId: string): Promise<{
     completedNodeIds: string[]
+    failedNodeIds: string[]
     branchKeys: Record<string, string>
   }> {
     const completedNodeIds: string[] = []
+    const failedNodeIds: string[] = []
     const branchKeys: Record<string, string> = {}
 
-    // Scan for step keys with 'node:' prefix
-    const pattern = `${this.keyPrefix}:step:${runId}:node:*`
+    const pattern = `${this.keyPrefix}:step:${runId}:*`
     let cursor = '0'
 
     do {
@@ -727,28 +737,38 @@ export class RedisWorkflowService extends PikkuWorkflowService {
       )
       cursor = newCursor
 
-      // Check each key for succeeded status and branch_taken
       for (const key of foundKeys) {
-        const data = await this.redis.hmget(key, 'status', 'branchTaken')
-        const [status, branchTaken] = data
+        const data = await this.redis.hmget(
+          key,
+          'status',
+          'branchTaken',
+          'attemptCount',
+          'retries'
+        )
+        const [status, branchTaken, attemptCount, retries] = data
+
+        const parts = key.split(':')
+        const stepIndex = parts.lastIndexOf('step')
+        if (stepIndex === -1 || stepIndex + 1 >= parts.length) continue
+        if (parts[stepIndex + 1] !== runId) continue
+        const nodeId = parts.slice(stepIndex + 2).join(':')
 
         if (status === 'succeeded') {
-          // Extract node ID from key: workflows:step:runId:node:nodeId
-          const parts = key.split(':')
-          const nodeIndex = parts.indexOf('node')
-          if (nodeIndex !== -1 && nodeIndex < parts.length - 1) {
-            const nodeId = parts.slice(nodeIndex + 1).join(':')
-            completedNodeIds.push(nodeId)
-
-            if (branchTaken) {
-              branchKeys[nodeId] = branchTaken
-            }
+          completedNodeIds.push(nodeId)
+          if (branchTaken) {
+            branchKeys[nodeId] = branchTaken
+          }
+        } else if (status === 'failed') {
+          const maxAttempts = (parseInt(retries || '0', 10) || 0) + 1
+          const attempts = parseInt(attemptCount || '0', 10) || 0
+          if (attempts >= maxAttempts) {
+            failedNodeIds.push(nodeId)
           }
         }
       }
     } while (cursor !== '0')
 
-    return { completedNodeIds, branchKeys }
+    return { completedNodeIds, failedNodeIds, branchKeys }
   }
 
   async getNodesWithoutSteps(
@@ -760,7 +780,7 @@ export class RedisWorkflowService extends PikkuWorkflowService {
     const result: string[] = []
 
     for (const nodeId of nodeIds) {
-      const key = this.stepKey(runId, `node:${nodeId}`)
+      const key = this.stepKey(runId, nodeId)
       const exists = await this.redis.exists(key)
       if (!exists) {
         result.push(nodeId)
@@ -779,7 +799,7 @@ export class RedisWorkflowService extends PikkuWorkflowService {
     const results: Record<string, any> = {}
 
     for (const nodeId of nodeIds) {
-      const key = this.stepKey(runId, `node:${nodeId}`)
+      const key = this.stepKey(runId, nodeId)
       const data = await this.redis.hmget(key, 'status', 'result')
       const [status, result] = data
 
@@ -842,6 +862,44 @@ export class RedisWorkflowService extends PikkuWorkflowService {
     return JSON.parse(stateStr)
   }
 
+  private versionKey(name: string, graphHash: string): string {
+    return `${this.keyPrefix}:version:${name}:${graphHash}`
+  }
+
+  async upsertWorkflowVersion(
+    name: string,
+    graphHash: string,
+    graph: any,
+    source: string
+  ): Promise<void> {
+    const key = this.versionKey(name, graphHash)
+    const exists = await this.redis.exists(key)
+    if (!exists) {
+      await this.redis.hmset(
+        key,
+        'graph',
+        JSON.stringify(graph),
+        'source',
+        source,
+        'createdAt',
+        Date.now().toString()
+      )
+    }
+  }
+
+  async getWorkflowVersion(
+    name: string,
+    graphHash: string
+  ): Promise<{ graph: any; source: string } | null> {
+    const key = this.versionKey(name, graphHash)
+    const data = await this.redis.hgetall(key)
+    if (!data.graph) return null
+    return {
+      graph: JSON.parse(data.graph),
+      source: data.source!,
+    }
+  }
+
   async close(): Promise<void> {
     if (this.ownsConnection) {
       await this.redis.quit()