@mastra/upstash 0.3.1-alpha.3 → 0.3.1-alpha.4

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/upstash@0.3.1-alpha.3 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.3.1-alpha.4 build /home/runner/work/mastra/mastra/stores/upstash
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.4.0
 TSC Build start
-TSC ⚡️ Build success in 10479ms
+TSC ⚡️ Build success in 9760ms
 DTS Build start
 CLI Target: es2022
-Analysis will use the bundled TypeScript version 5.8.2
+Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.ts
-Analysis will use the bundled TypeScript version 5.8.2
+Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 12075ms
+DTS ⚡️ Build success in 12363ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 24.02 KB
-ESM ⚡️ Build success in 1157ms
-CJS dist/index.cjs 24.11 KB
-CJS ⚡️ Build success in 1162ms
+ESM dist/index.js 25.43 KB
+ESM ⚡️ Build success in 1277ms
+CJS dist/index.cjs 25.55 KB
+CJS ⚡️ Build success in 1278ms

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/upstash
 
+## 0.3.1-alpha.4
+
+### Patch Changes
+
+- 479f490: [MASTRA-3131] Add getWorkflowRunByID and add resourceId as filter for getWorkflowRuns
+- Updated dependencies [e4943b8]
+- Updated dependencies [479f490]
+  - @mastra/core@0.9.1-alpha.4
+
 ## 0.3.1-alpha.3
 
 ### Patch Changes

package/dist/_tsup-dts-rollup.d.cts

@@ -14,6 +14,8 @@ import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
+import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 
 declare interface UpstashConfig {
@@ -107,23 +109,21 @@ declare class UpstashStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, }?: {
+    private parseWorkflowRun;
+    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         namespace: string;
         workflowName?: string;
         fromDate?: Date;
         toDate?: Date;
         limit?: number;
         offset?: number;
-    }): Promise<{
-        runs: Array<{
-            workflowName: string;
-            runId: string;
-            snapshot: WorkflowRunState | string;
-            createdAt: Date;
-            updatedAt: Date;
-        }>;
-        total: number;
-    }>;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ namespace, runId, workflowName, }: {
+        namespace: string;
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
     close(): Promise<void>;
 }
 export { UpstashStore }

package/dist/_tsup-dts-rollup.d.ts

@@ -14,6 +14,8 @@ import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
+import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 
 declare interface UpstashConfig {
@@ -107,23 +109,21 @@ declare class UpstashStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, }?: {
+    private parseWorkflowRun;
+    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         namespace: string;
         workflowName?: string;
         fromDate?: Date;
         toDate?: Date;
         limit?: number;
         offset?: number;
-    }): Promise<{
-        runs: Array<{
-            workflowName: string;
-            runId: string;
-            snapshot: WorkflowRunState | string;
-            createdAt: Date;
-            updatedAt: Date;
-        }>;
-        total: number;
-    }>;
+        resourceId?: string;
+    }): Promise<WorkflowRuns>;
+    getWorkflowRunById({ namespace, runId, workflowName, }: {
+        namespace: string;
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
     close(): Promise<void>;
 }
 export { UpstashStore }

package/dist/index.cjs

@@ -207,7 +207,8 @@ var UpstashStore = class extends storage.MastraStorage {
       key = this.getKey(tableName, {
         namespace: record.namespace || "workflows",
         workflow_name: record.workflow_name,
-        run_id: record.run_id
+        run_id: record.run_id,
+        ...record.resourceId ? { resourceId: record.resourceId } : {}
       });
     } else if (tableName === storage.TABLE_EVALS) {
       key = this.getKey(tableName, { id: record.run_id });
@@ -372,48 +373,90 @@ var UpstashStore = class extends storage.MastraStorage {
     if (!data) return null;
     return data.snapshot;
   }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
   async getWorkflowRuns({
     namespace,
     workflowName,
     fromDate,
     toDate,
     limit,
-    offset
+    offset,
+    resourceId
   } = { namespace: "workflows" }) {
-    const pattern = workflowName ? this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*" : this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
-    const keys = await this.redis.keys(pattern);
-    const workflows = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data;
-      })
-    );
-    let runs = workflows.filter((w) => w !== null).map((w) => {
-      let parsedSnapshot = w.snapshot;
-      if (typeof parsedSnapshot === "string") {
-        try {
-          parsedSnapshot = JSON.parse(w.snapshot);
-        } catch {
-          console.warn(`Failed to parse snapshot for workflow ${w.workflow_name}:`);
-        }
+    try {
+      let pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
+      if (workflowName && resourceId) {
+        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, {
+          namespace,
+          workflow_name: workflowName,
+          run_id: "*",
+          resourceId
+        });
+      } else if (workflowName) {
+        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*";
+      } else if (resourceId) {
+        pattern = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: "*", run_id: "*", resourceId });
       }
-      return {
-        workflowName: w.workflow_name,
-        runId: w.run_id,
-        snapshot: parsedSnapshot,
-        createdAt: this.ensureDate(w.createdAt),
-        updatedAt: this.ensureDate(w.updatedAt)
-      };
-    }).filter((w) => {
-      if (fromDate && w.createdAt < fromDate) return false;
-      if (toDate && w.createdAt > toDate) return false;
-      return true;
-    }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    const total = runs.length;
-    if (limit !== void 0 && offset !== void 0) {
-      runs = runs.slice(offset, offset + limit);
-    }
-    return { runs, total };
+      const keys = await this.redis.keys(pattern);
+      const workflows = await Promise.all(
+        keys.map(async (key) => {
+          const data = await this.redis.get(key);
+          return data;
+        })
+      );
+      let runs = workflows.filter((w) => w !== null).map((w) => this.parseWorkflowRun(w)).filter((w) => {
+        if (fromDate && w.createdAt < fromDate) return false;
+        if (toDate && w.createdAt > toDate) return false;
+        return true;
+      }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      const total = runs.length;
+      if (limit !== void 0 && offset !== void 0) {
+        runs = runs.slice(offset, offset + limit);
+      }
+      return { runs, total };
+    } catch (error) {
+      console.error("Error getting workflow runs:", error);
+      throw error;
+    }
+  }
+  async getWorkflowRunById({
+    namespace = "workflows",
+    runId,
+    workflowName
+  }) {
+    try {
+      const key = this.getKey(storage.TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId }) + "*";
+      const keys = await this.redis.keys(key);
+      const workflows = await Promise.all(
+        keys.map(async (key2) => {
+          const data2 = await this.redis.get(key2);
+          return data2;
+        })
+      );
+      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
+      if (!data) return null;
+      return this.parseWorkflowRun(data);
+    } catch (error) {
+      console.error("Error getting workflow run by ID:", error);
+      throw error;
+    }
   }
   async close() {
   }

package/dist/index.js

@@ -205,7 +205,8 @@ var UpstashStore = class extends MastraStorage {
       key = this.getKey(tableName, {
         namespace: record.namespace || "workflows",
         workflow_name: record.workflow_name,
-        run_id: record.run_id
+        run_id: record.run_id,
+        ...record.resourceId ? { resourceId: record.resourceId } : {}
       });
     } else if (tableName === TABLE_EVALS) {
       key = this.getKey(tableName, { id: record.run_id });
@@ -370,48 +371,90 @@ var UpstashStore = class extends MastraStorage {
     if (!data) return null;
     return data.snapshot;
   }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: this.ensureDate(row.createdAt),
+      updatedAt: this.ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
   async getWorkflowRuns({
     namespace,
     workflowName,
     fromDate,
     toDate,
     limit,
-    offset
+    offset,
+    resourceId
   } = { namespace: "workflows" }) {
-    const pattern = workflowName ? this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*" : this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
-    const keys = await this.redis.keys(pattern);
-    const workflows = await Promise.all(
-      keys.map(async (key) => {
-        const data = await this.redis.get(key);
-        return data;
-      })
-    );
-    let runs = workflows.filter((w) => w !== null).map((w) => {
-      let parsedSnapshot = w.snapshot;
-      if (typeof parsedSnapshot === "string") {
-        try {
-          parsedSnapshot = JSON.parse(w.snapshot);
-        } catch {
-          console.warn(`Failed to parse snapshot for workflow ${w.workflow_name}:`);
-        }
+    try {
+      let pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ":*";
+      if (workflowName && resourceId) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, {
+          namespace,
+          workflow_name: workflowName,
+          run_id: "*",
+          resourceId
+        });
+      } else if (workflowName) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ":*";
+      } else if (resourceId) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: "*", run_id: "*", resourceId });
       }
-      return {
-        workflowName: w.workflow_name,
-        runId: w.run_id,
-        snapshot: parsedSnapshot,
-        createdAt: this.ensureDate(w.createdAt),
-        updatedAt: this.ensureDate(w.updatedAt)
-      };
-    }).filter((w) => {
-      if (fromDate && w.createdAt < fromDate) return false;
-      if (toDate && w.createdAt > toDate) return false;
-      return true;
-    }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-    const total = runs.length;
-    if (limit !== void 0 && offset !== void 0) {
-      runs = runs.slice(offset, offset + limit);
-    }
-    return { runs, total };
+      const keys = await this.redis.keys(pattern);
+      const workflows = await Promise.all(
+        keys.map(async (key) => {
+          const data = await this.redis.get(key);
+          return data;
+        })
+      );
+      let runs = workflows.filter((w) => w !== null).map((w) => this.parseWorkflowRun(w)).filter((w) => {
+        if (fromDate && w.createdAt < fromDate) return false;
+        if (toDate && w.createdAt > toDate) return false;
+        return true;
+      }).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+      const total = runs.length;
+      if (limit !== void 0 && offset !== void 0) {
+        runs = runs.slice(offset, offset + limit);
+      }
+      return { runs, total };
+    } catch (error) {
+      console.error("Error getting workflow runs:", error);
+      throw error;
+    }
+  }
+  async getWorkflowRunById({
+    namespace = "workflows",
+    runId,
+    workflowName
+  }) {
+    try {
+      const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId }) + "*";
+      const keys = await this.redis.keys(key);
+      const workflows = await Promise.all(
+        keys.map(async (key2) => {
+          const data2 = await this.redis.get(key2);
+          return data2;
+        })
+      );
+      const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
+      if (!data) return null;
+      return this.parseWorkflowRun(data);
+    } catch (error) {
+      console.error("Error getting workflow run by ID:", error);
+      throw error;
+    }
   }
   async close() {
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.3.1-alpha.3",
+  "version": "0.3.1-alpha.4",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -22,16 +22,16 @@
   "dependencies": {
     "@upstash/redis": "^1.34.5",
     "@upstash/vector": "^1.2.1",
-    "@mastra/core": "^0.9.1-alpha.3"
+    "@mastra/core": "^0.9.1-alpha.4"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.1",
+    "@microsoft/api-extractor": "^7.52.5",
     "@types/node": "^20.17.27",
     "dotenv": "^16.4.7",
     "eslint": "^9.23.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.0.9",
+    "vitest": "^3.1.2",
     "@internal/lint": "0.0.2"
   },
   "scripts": {

package/src/storage/index.ts

@@ -8,7 +8,14 @@ import {
   TABLE_EVALS,
   TABLE_TRACES,
 } from '@mastra/core/storage';
-import type { TABLE_NAMES, StorageColumn, StorageGetMessagesArg, EvalRow } from '@mastra/core/storage';
+import type {
+  TABLE_NAMES,
+  StorageColumn,
+  StorageGetMessagesArg,
+  EvalRow,
+  WorkflowRuns,
+  WorkflowRun,
+} from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 import { Redis } from '@upstash/redis';
 
@@ -298,6 +305,7 @@ export class UpstashStore extends MastraStorage {
         namespace: record.namespace || 'workflows',
         workflow_name: record.workflow_name,
         run_id: record.run_id,
+        ...(record.resourceId ? { resourceId: record.resourceId } : {}),
       });
     } else if (tableName === TABLE_EVALS) {
       key = this.getKey(tableName, { id: record.run_id });
@@ -531,6 +539,27 @@ export class UpstashStore extends MastraStorage {
     return data.snapshot;
   }
 
+  private parseWorkflowRun(row: any): WorkflowRun {
+    let parsedSnapshot: WorkflowRunState | string = row.snapshot as string;
+    if (typeof parsedSnapshot === 'string') {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot as string) as WorkflowRunState;
+      } catch (e) {
+        // If parsing fails, return the raw snapshot string
+        console.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: this.ensureDate(row.createdAt)!,
+      updatedAt: this.ensureDate(row.updatedAt)!,
+      resourceId: row.resourceId,
+    };
+  }
+
   async getWorkflowRuns(
     {
       namespace,
@@ -539,6 +568,7 @@ export class UpstashStore extends MastraStorage {
       toDate,
       limit,
       offset,
+      resourceId,
     }: {
       namespace: string;
       workflowName?: string;
@@ -546,74 +576,98 @@ export class UpstashStore extends MastraStorage {
       toDate?: Date;
       limit?: number;
       offset?: number;
+      resourceId?: string;
     } = { namespace: 'workflows' },
-  ): Promise<{
-    runs: Array<{
-      workflowName: string;
-      runId: string;
-      snapshot: WorkflowRunState | string;
-      createdAt: Date;
-      updatedAt: Date;
-    }>;
-    total: number;
-  }> {
-    // Get all workflow keys
-    const pattern = workflowName
-      ? this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ':*'
-      : this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ':*';
+  ): Promise<WorkflowRuns> {
+    try {
+      // Get all workflow keys
+      let pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace }) + ':*';
+      if (workflowName && resourceId) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, {
+          namespace,
+          workflow_name: workflowName,
+          run_id: '*',
+          resourceId,
+        });
+      } else if (workflowName) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName }) + ':*';
+      } else if (resourceId) {
+        pattern = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: '*', run_id: '*', resourceId });
+      }
+      const keys = await this.redis.keys(pattern);
 
-    const keys = await this.redis.keys(pattern);
+      // Get all workflow data
+      const workflows = await Promise.all(
+        keys.map(async key => {
+          const data = await this.redis.get<{
+            workflow_name: string;
+            run_id: string;
+            snapshot: WorkflowRunState | string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+            resourceId: string;
+          }>(key);
+          return data;
+        }),
+      );
 
-    // Get all workflow data
-    const workflows = await Promise.all(
-      keys.map(async key => {
-        const data = await this.redis.get<{
-          workflow_name: string;
-          run_id: string;
-          snapshot: WorkflowRunState | string;
-          createdAt: string | Date;
-          updatedAt: string | Date;
-        }>(key);
-        return data;
-      }),
-    );
+      // Filter and transform results
+      let runs = workflows
+        .filter(w => w !== null)
+        .map(w => this.parseWorkflowRun(w!))
+        .filter(w => {
+          if (fromDate && w.createdAt < fromDate) return false;
+          if (toDate && w.createdAt > toDate) return false;
+          return true;
+        })
+        .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+
+      const total = runs.length;
+
+      // Apply pagination if requested
+      if (limit !== undefined && offset !== undefined) {
+        runs = runs.slice(offset, offset + limit);
+      }
 
-    // Filter and transform results
-    let runs = workflows
-      .filter(w => w !== null)
-      .map(w => {
-        let parsedSnapshot: WorkflowRunState | string = w!.snapshot as string;
-        if (typeof parsedSnapshot === 'string') {
-          try {
-            parsedSnapshot = JSON.parse(w!.snapshot as string) as WorkflowRunState;
-          } catch {
-            // If parsing fails, return the raw snapshot string
-            console.warn(`Failed to parse snapshot for workflow ${w!.workflow_name}:`);
-          }
-        }
-        return {
-          workflowName: w!.workflow_name,
-          runId: w!.run_id,
-          snapshot: parsedSnapshot,
-          createdAt: this.ensureDate(w!.createdAt)!,
-          updatedAt: this.ensureDate(w!.updatedAt)!,
-        };
-      })
-      .filter(w => {
-        if (fromDate && w.createdAt < fromDate) return false;
-        if (toDate && w.createdAt > toDate) return false;
-        return true;
-      })
-      .sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
-
-    const total = runs.length;
-
-    // Apply pagination if requested
-    if (limit !== undefined && offset !== undefined) {
-      runs = runs.slice(offset, offset + limit);
+      return { runs, total };
+    } catch (error) {
+      console.error('Error getting workflow runs:', error);
+      throw error;
     }
+  }
 
-    return { runs, total };
+  async getWorkflowRunById({
+    namespace = 'workflows',
+    runId,
+    workflowName,
+  }: {
+    namespace: string;
+    runId: string;
+    workflowName?: string;
+  }): Promise<WorkflowRun | null> {
+    try {
+      const key = this.getKey(TABLE_WORKFLOW_SNAPSHOT, { namespace, workflow_name: workflowName, run_id: runId }) + '*';
+      const keys = await this.redis.keys(key);
+      const workflows = await Promise.all(
+        keys.map(async key => {
+          const data = await this.redis.get<{
+            workflow_name: string;
+            run_id: string;
+            snapshot: WorkflowRunState | string;
+            createdAt: string | Date;
+            updatedAt: string | Date;
+            resourceId: string;
+          }>(key);
+          return data;
+        }),
+      );
+      const data = workflows.find(w => w?.run_id === runId && w?.workflow_name === workflowName) as WorkflowRun | null;
+      if (!data) return null;
+      return this.parseWorkflowRun(data);
+    } catch (error) {
+      console.error('Error getting workflow run by ID:', error);
+      throw error;
+    }
   }
 
   async close(): Promise<void> {

package/src/storage/upstash.test.ts

@@ -25,27 +25,26 @@ const createSampleThread = (date?: Date) => ({
   metadata: { key: 'value' },
 });
 
-const createSampleMessage = (threadId: string, content: string = 'Hello') =>
-  ({
-    id: `msg-${randomUUID()}`,
-    role: 'user',
-    type: 'text',
-    threadId,
-    content: [{ type: 'text', text: content }],
-    createdAt: new Date(),
-  }) as any;
+const createSampleMessage = (threadId: string, content: string = 'Hello'): MessageType => ({
+  id: `msg-${randomUUID()}`,
+  role: 'user',
+  type: 'text',
+  threadId,
+  content: [{ type: 'text', text: content }],
+  createdAt: new Date(),
+  resourceId: `resource-${randomUUID()}`,
+});
 
 const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
   const runId = `run-${randomUUID()}`;
   const stepId = `step-${randomUUID()}`;
   const timestamp = createdAt || new Date();
-  const snapshot = {
-    result: { success: true },
+  const snapshot: WorkflowRunState = {
     value: {},
     context: {
       steps: {
         [stepId]: {
-          status,
+          status: status as WorkflowRunState['context']['steps'][string]['status'],
           payload: {},
           error: undefined,
         },
@@ -54,9 +53,10 @@ const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
       attempts: {},
     },
     activePaths: [],
+    suspendedPaths: {},
     runId,
     timestamp: timestamp.getTime(),
-  } as WorkflowRunState;
+  };
   return { snapshot, runId, stepId };
 };
 
@@ -94,6 +94,13 @@ const createSampleEval = (agentName: string, isTest = false) => {
   };
 };
 
+const checkWorkflowSnapshot = (snapshot: WorkflowRunState | string, stepId: string, status: string) => {
+  if (typeof snapshot === 'string') {
+    throw new Error('Expected WorkflowRunState, got string');
+  }
+  expect(snapshot.context?.steps[stepId]?.status).toBe(status);
+};
+
 describe('UpstashStore', () => {
   let store: UpstashStore;
   const testTableName = 'test_table';
@@ -303,17 +310,17 @@ describe('UpstashStore', () => {
     });
 
     it('should save and retrieve messages in order', async () => {
-      const messages = [
+      const messages: MessageType[] = [
         createSampleMessage(threadId, 'First'),
         createSampleMessage(threadId, 'Second'),
         createSampleMessage(threadId, 'Third'),
       ];
 
-      await store.saveMessages({ messages: messages as MessageType[] });
+      await store.saveMessages({ messages: messages });
 
-      const retrievedMessages = await store.getMessages({ threadId });
+      const retrievedMessages = await store.getMessages<MessageType[]>({ threadId });
       expect(retrievedMessages).toHaveLength(3);
-      expect(retrievedMessages.map(m => m.content[0].text)).toEqual(['First', 'Second', 'Third']);
+      expect(retrievedMessages.map((m: any) => m.content[0].text)).toEqual(['First', 'Second', 'Third']);
     });
 
     it('should handle empty message array', async () => {
@@ -335,11 +342,11 @@ describe('UpstashStore', () => {
           ],
           createdAt: new Date(),
         },
-      ];
+      ] as MessageType[];
 
-      await store.saveMessages({ messages: messages as MessageType[] });
+      await store.saveMessages({ messages });
 
-      const retrievedMessages = await store.getMessages({ threadId });
+      const retrievedMessages = await store.getMessages<MessageType>({ threadId });
       expect(retrievedMessages[0].content).toEqual(messages[0].content);
     });
   });
@@ -451,13 +458,15 @@ describe('UpstashStore', () => {
           stepResults: {
             step1: { status: 'success', payload: { result: 'done' } },
           },
+          steps: {},
           attempts: {},
           triggerData: {},
         },
         runId: testRunId,
         activePaths: [],
+        suspendedPaths: {},
         timestamp: Date.now(),
-      } as unknown as WorkflowRunState;
+      };
 
       await store.persistWorkflowSnapshot({
         namespace: testNamespace,
@@ -556,8 +565,8 @@ describe('UpstashStore', () => {
       const workflowName1 = 'default_test_1';
       const workflowName2 = 'default_test_2';
 
-      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
-      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('success');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('waiting');
 
       await store.persistWorkflowSnapshot({
         namespace: testNamespace,
@@ -578,17 +587,17 @@ describe('UpstashStore', () => {
       expect(total).toBe(2);
       expect(runs[0]!.workflowName).toBe(workflowName2); // Most recent first
       expect(runs[1]!.workflowName).toBe(workflowName1);
-      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
-      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
-      expect(firstSnapshot.context?.steps[stepId2]?.status).toBe('running');
-      expect(secondSnapshot.context?.steps[stepId1]?.status).toBe('completed');
+      const firstSnapshot = runs[0]!.snapshot;
+      const secondSnapshot = runs[1]!.snapshot;
+      checkWorkflowSnapshot(firstSnapshot, stepId2, 'waiting');
+      checkWorkflowSnapshot(secondSnapshot, stepId1, 'success');
     });
 
     it('filters by workflow name', async () => {
       const workflowName1 = 'filter_test_1';
       const workflowName2 = 'filter_test_2';
 
-      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('success');
       const { snapshot: workflow2, runId: runId2 } = createSampleWorkflowSnapshot('failed');
 
       await store.persistWorkflowSnapshot({
@@ -609,8 +618,11 @@ describe('UpstashStore', () => {
       expect(runs).toHaveLength(1);
       expect(total).toBe(1);
       expect(runs[0]!.workflowName).toBe(workflowName1);
-      const snapshot = runs[0]!.snapshot as WorkflowRunState;
-      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+      const snapshot = runs[0]!.snapshot;
+      if (typeof snapshot === 'string') {
+        throw new Error('Expected WorkflowRunState, got string');
+      }
+      expect(snapshot.context?.steps[stepId1]?.status).toBe('success');
     });
 
     it('filters by date range', async () => {
@@ -621,9 +633,9 @@ describe('UpstashStore', () => {
       const workflowName2 = 'date_test_2';
       const workflowName3 = 'date_test_3';
 
-      const { snapshot: workflow1, runId: runId1 } = createSampleWorkflowSnapshot('completed');
-      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
-      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+      const { snapshot: workflow1, runId: runId1 } = createSampleWorkflowSnapshot('success');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('waiting');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('skipped');
 
       await store.insert({
         tableName: TABLE_WORKFLOW_SNAPSHOT,
@@ -668,10 +680,10 @@ describe('UpstashStore', () => {
       expect(runs).toHaveLength(2);
       expect(runs[0]!.workflowName).toBe(workflowName3);
       expect(runs[1]!.workflowName).toBe(workflowName2);
-      const firstSnapshot = runs[0]!.snapshot as WorkflowRunState;
-      const secondSnapshot = runs[1]!.snapshot as WorkflowRunState;
-      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
-      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+      const firstSnapshot = runs[0]!.snapshot;
+      const secondSnapshot = runs[1]!.snapshot;
+      checkWorkflowSnapshot(firstSnapshot, stepId3, 'skipped');
+      checkWorkflowSnapshot(secondSnapshot, stepId2, 'waiting');
     });
 
     it('handles pagination', async () => {
@@ -679,9 +691,9 @@ describe('UpstashStore', () => {
       const workflowName2 = 'page_test_2';
       const workflowName3 = 'page_test_3';
 
-      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('completed');
-      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('running');
-      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('waiting');
+      const { snapshot: workflow1, runId: runId1, stepId: stepId1 } = createSampleWorkflowSnapshot('success');
+      const { snapshot: workflow2, runId: runId2, stepId: stepId2 } = createSampleWorkflowSnapshot('waiting');
+      const { snapshot: workflow3, runId: runId3, stepId: stepId3 } = createSampleWorkflowSnapshot('skipped');
 
       await store.persistWorkflowSnapshot({
         namespace: testNamespace,
@@ -714,10 +726,10 @@ describe('UpstashStore', () => {
       expect(page1.total).toBe(3); // Total count of all records
       expect(page1.runs[0]!.workflowName).toBe(workflowName3);
       expect(page1.runs[1]!.workflowName).toBe(workflowName2);
-      const firstSnapshot = page1.runs[0]!.snapshot as WorkflowRunState;
-      const secondSnapshot = page1.runs[1]!.snapshot as WorkflowRunState;
-      expect(firstSnapshot.context?.steps[stepId3]?.status).toBe('waiting');
-      expect(secondSnapshot.context?.steps[stepId2]?.status).toBe('running');
+      const firstSnapshot = page1.runs[0]!.snapshot;
+      const secondSnapshot = page1.runs[1]!.snapshot;
+      checkWorkflowSnapshot(firstSnapshot, stepId3, 'skipped');
+      checkWorkflowSnapshot(secondSnapshot, stepId2, 'waiting');
 
       // Get second page
       const page2 = await store.getWorkflowRuns({
@@ -728,8 +740,118 @@ describe('UpstashStore', () => {
       expect(page2.runs).toHaveLength(1);
       expect(page2.total).toBe(3);
       expect(page2.runs[0]!.workflowName).toBe(workflowName1);
-      const snapshot = page2.runs[0]!.snapshot as WorkflowRunState;
-      expect(snapshot.context?.steps[stepId1]?.status).toBe('completed');
+      const snapshot = page2.runs[0]!.snapshot;
+      checkWorkflowSnapshot(snapshot, stepId1, 'success');
+    });
+  });
+  describe('getWorkflowRunById', () => {
+    const testNamespace = 'test-workflows-id';
+    const workflowName = 'workflow-id-test';
+    let runId: string;
+    let stepId: string;
+
+    beforeAll(async () => {
+      // Insert a workflow run for positive test
+      const sample = createSampleWorkflowSnapshot('success');
+      runId = sample.runId;
+      stepId = sample.stepId;
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace: testNamespace,
+          workflow_name: workflowName,
+          run_id: runId,
+          resourceId: 'resource-abc',
+          snapshot: sample.snapshot,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      });
+    });
+
+    it('should retrieve a workflow run by ID', async () => {
+      const found = await store.getWorkflowRunById({
+        namespace: testNamespace,
+        runId,
+        workflowName,
+      });
+      expect(found).not.toBeNull();
+      expect(found?.runId).toBe(runId);
+      const snapshot = found?.snapshot;
+      checkWorkflowSnapshot(snapshot!, stepId, 'success');
+    });
+
+    it('should return null for non-existent workflow run ID', async () => {
+      const notFound = await store.getWorkflowRunById({
+        namespace: testNamespace,
+        runId: 'non-existent-id',
+        workflowName,
+      });
+      expect(notFound).toBeNull();
+    });
+  });
+  describe('getWorkflowRuns with resourceId', () => {
+    const testNamespace = 'test-workflows-id';
+    const workflowName = 'workflow-id-test';
+    let resourceId: string;
+    let runIds: string[] = [];
+
+    beforeAll(async () => {
+      // Insert multiple workflow runs for the same resourceId
+      resourceId = 'resource-shared';
+      for (const status of ['success', 'waiting']) {
+        const sample = createSampleWorkflowSnapshot(status);
+        runIds.push(sample.runId);
+        await store.insert({
+          tableName: TABLE_WORKFLOW_SNAPSHOT,
+          record: {
+            namespace: testNamespace,
+            workflow_name: workflowName,
+            run_id: sample.runId,
+            resourceId,
+            snapshot: sample.snapshot,
+            createdAt: new Date(),
+            updatedAt: new Date(),
+          },
+        });
+      }
+      // Insert a run with a different resourceId
+      const other = createSampleWorkflowSnapshot('waiting');
+      await store.insert({
+        tableName: TABLE_WORKFLOW_SNAPSHOT,
+        record: {
+          namespace: testNamespace,
+          workflow_name: workflowName,
+          run_id: other.runId,
+          resourceId: 'resource-other',
+          snapshot: other.snapshot,
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      });
+    });
+
+    it('should retrieve all workflow runs by resourceId', async () => {
+      const { runs } = await store.getWorkflowRuns({
+        namespace: testNamespace,
+        resourceId,
+        workflowName,
+      });
+      expect(Array.isArray(runs)).toBe(true);
+      expect(runs.length).toBeGreaterThanOrEqual(2);
+      for (const run of runs) {
+        expect(run.resourceId).toBe(resourceId);
+      }
+    });
+
+    it('should return an empty array if no workflow runs match resourceId', async () => {
+      const { runs } = await store.getWorkflowRuns({
+        namespace: testNamespace,
+        resourceId: 'non-existent-resource',
+        workflowName,
+      });
+      expect(Array.isArray(runs)).toBe(true);
+      expect(runs.length).toBe(0);
     });
   });
 });