@pikku/core 0.12.3 → 0.12.4

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## 0.12.0
 
+## 0.12.4
+
+### Patch Changes
+
+- InMemoryWorkflowService now implements WorkflowRunService interface (listRuns, getRunSteps, getDistinctWorkflowNames, deleteRun)
+
 ## 0.12.3
 
 ### Patch Changes

package/dist/services/in-memory-workflow-service.d.ts

@@ -1,6 +1,6 @@
 import { PikkuWorkflowService } from '../wirings/workflow/pikku-workflow-service.js';
 import type { SerializedError } from '../types/core.types.js';
-import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
+import type { WorkflowRun, WorkflowRunService, WorkflowRunWire, StepState, WorkflowStatus, WorkflowVersionStatus, WorkflowStepOptions } from '../wirings/workflow/workflow.types.js';
 /**
  * In-memory implementation of WorkflowService for inline-only execution
  *
@@ -16,7 +16,7 @@ import type { WorkflowRun, WorkflowRunWire, StepState, WorkflowStatus, WorkflowV
  * await workflowService.startWorkflow('myWorkflow', input, { type: 'cli' }, rpc, { inline: true })
  * ```
  */
-export declare class InMemoryWorkflowService extends PikkuWorkflowService {
+export declare class InMemoryWorkflowService extends PikkuWorkflowService implements WorkflowRunService {
     private runs;
     private steps;
     private stepData;
@@ -37,6 +37,19 @@ export declare class InMemoryWorkflowService extends PikkuWorkflowService {
     setStepResult(stepId: string, result: any): Promise<void>;
     setStepError(stepId: string, error: Error): Promise<void>;
     createRetryAttempt(failedStepId: string, status: 'pending' | 'running'): Promise<StepState>;
+    listRuns(options?: {
+        workflowName?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkflowRun[]>;
+    getRunSteps(runId: string): Promise<Array<StepState & {
+        stepName: string;
+        rpcName?: string;
+        data?: any;
+    }>>;
+    getDistinctWorkflowNames(): Promise<string[]>;
+    deleteRun(id: string): Promise<boolean>;
     withRunLock<T>(_id: string, fn: () => Promise<T>): Promise<T>;
     withStepLock<T>(_runId: string, _stepName: string, fn: () => Promise<T>): Promise<T>;
     close(): Promise<void>;

package/dist/services/in-memory-workflow-service.js

@@ -187,6 +187,55 @@ export class InMemoryWorkflowService extends PikkuWorkflowService {
         this.stepHistory.set(runId, history);
         return newStep;
     }
+    async listRuns(options) {
+        let runs = Array.from(this.runs.values());
+        if (options?.workflowName) {
+            runs = runs.filter((r) => r.workflow === options.workflowName);
+        }
+        if (options?.status) {
+            runs = runs.filter((r) => r.status === options.status);
+        }
+        runs.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+        const offset = options?.offset ?? 0;
+        const limit = options?.limit ?? runs.length;
+        return runs.slice(offset, offset + limit);
+    }
+    async getRunSteps(runId) {
+        const history = this.stepHistory.get(runId) || [];
+        return history.map((step) => {
+            const stepDataEntry = this.stepData.get(step.stepId);
+            return {
+                ...step,
+                rpcName: stepDataEntry?.rpcName ?? undefined,
+                data: stepDataEntry?.data,
+            };
+        });
+    }
+    async getDistinctWorkflowNames() {
+        const names = new Set();
+        for (const run of this.runs.values()) {
+            names.add(run.workflow);
+        }
+        return Array.from(names);
+    }
+    async deleteRun(id) {
+        const existed = this.runs.has(id);
+        this.runs.delete(id);
+        this.stepHistory.delete(id);
+        this.runState.delete(id);
+        const prefix = `${id}:`;
+        for (const key of this.steps.keys()) {
+            if (key.startsWith(prefix)) {
+                const step = this.steps.get(key);
+                if (step) {
+                    this.stepData.delete(step.stepId);
+                    this.branchKeys.delete(step.stepId);
+                }
+                this.steps.delete(key);
+            }
+        }
+        return existed;
+    }
     async withRunLock(_id, fn) {
         // In-memory service doesn't need locking for inline execution
         return fn();