@pikku/redis 0.11.1 → 0.12.0

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'
@@ -201,7 +202,13 @@ export class RedisWorkflowService extends PikkuWorkflowService {
     )
   }
 
-  async createRun(workflowName: string, input: any): Promise<string> {
+  async createRun(
+    workflowName: string,
+    input: any,
+    inline: boolean,
+    graphHash: string,
+    wire: WorkflowRunWire
+  ): Promise<string> {
     const id = randomUUID()
     const now = Date.now()
 
@@ -217,6 +224,12 @@ export class RedisWorkflowService extends PikkuWorkflowService {
       'running',
       'input',
       JSON.stringify(input),
+      'inline',
+      inline ? 'true' : 'false',
+      'graphHash',
+      graphHash,
+      'wire',
+      JSON.stringify(wire),
       'createdAt',
       now.toString(),
       'updatedAt',
@@ -241,6 +254,9 @@ export class RedisWorkflowService extends PikkuWorkflowService {
       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!)),
     }
@@ -695,6 +711,195 @@ export class RedisWorkflowService extends PikkuWorkflowService {
     }
   }
 
+  // ============================================================================
+  // Workflow Graph Methods
+  // ============================================================================
+
+  async getCompletedGraphState(runId: string): Promise<{
+    completedNodeIds: string[]
+    failedNodeIds: string[]
+    branchKeys: Record<string, string>
+  }> {
+    const completedNodeIds: string[] = []
+    const failedNodeIds: string[] = []
+    const branchKeys: Record<string, string> = {}
+
+    const pattern = `${this.keyPrefix}:step:${runId}:*`
+    let cursor = '0'
+
+    do {
+      const [newCursor, foundKeys] = await this.redis.scan(
+        cursor,
+        'MATCH',
+        pattern,
+        'COUNT',
+        100
+      )
+      cursor = newCursor
+
+      for (const key of foundKeys) {
+        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') {
+          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, failedNodeIds, branchKeys }
+  }
+
+  async getNodesWithoutSteps(
+    runId: string,
+    nodeIds: string[]
+  ): Promise<string[]> {
+    if (nodeIds.length === 0) return []
+
+    const result: string[] = []
+
+    for (const nodeId of nodeIds) {
+      const key = this.stepKey(runId, nodeId)
+      const exists = await this.redis.exists(key)
+      if (!exists) {
+        result.push(nodeId)
+      }
+    }
+
+    return result
+  }
+
+  async getNodeResults(
+    runId: string,
+    nodeIds: string[]
+  ): Promise<Record<string, any>> {
+    if (nodeIds.length === 0) return {}
+
+    const results: Record<string, any> = {}
+
+    for (const nodeId of nodeIds) {
+      const key = this.stepKey(runId, nodeId)
+      const data = await this.redis.hmget(key, 'status', 'result')
+      const [status, result] = data
+
+      if (status === 'succeeded' && result) {
+        results[nodeId] = JSON.parse(result)
+      }
+    }
+
+    return results
+  }
+
+  async setBranchTaken(stepId: string, branchKey: string): Promise<void> {
+    // Extract runId and stepName from stepId (format: runId:stepName:timestamp)
+    const parts = stepId.split(':')
+    const runId = parts[0]!
+    const stepName = parts.slice(1, -1).join(':')
+
+    const now = Date.now()
+    const key = this.stepKey(runId, stepName)
+
+    await this.redis.hmset(
+      key,
+      'branchTaken',
+      branchKey,
+      'updatedAt',
+      now.toString()
+    )
+  }
+
+  async updateRunState(
+    runId: string,
+    name: string,
+    value: unknown
+  ): Promise<void> {
+    const key = this.runKey(runId)
+    const now = Date.now()
+
+    // Get existing state or create empty object
+    const existingState = await this.redis.hget(key, 'state')
+    const state = existingState ? JSON.parse(existingState) : {}
+
+    // Update the specific field
+    state[name] = value
+
+    await this.redis.hmset(
+      key,
+      'state',
+      JSON.stringify(state),
+      'updatedAt',
+      now.toString()
+    )
+  }
+
+  async getRunState(runId: string): Promise<Record<string, unknown>> {
+    const key = this.runKey(runId)
+    const stateStr = await this.redis.hget(key, 'state')
+    if (!stateStr) {
+      return {}
+    }
+    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()