@mastra/clickhouse 0.0.0-switch-to-core-20250424015131 → 0.0.0-vector-query-sources-20250516172905

package/dist/index.js

@@ -136,7 +136,9 @@ var ClickhouseStore = class extends MastraStorage {
     page,
     perPage,
     attributes,
-    filters
+    filters,
+    fromDate,
+    toDate
   }) {
     const limit = perPage;
     const offset = page * perPage;
@@ -164,6 +166,14 @@ var ClickhouseStore = class extends MastraStorage {
         args[`var_col_${key}`] = value;
       });
     }
+    if (fromDate) {
+      conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
+      args.var_from_date = fromDate.getTime() / 1e3;
+    }
+    if (toDate) {
+      conditions.push(`createdAt <= {var_to_date:DateTime64(3)}`);
+      args.var_to_date = toDate.getTime() / 1e3;
+    }
     const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
     const result = await this.db.query({
       query: `SELECT *, toDateTime64(createdAt, 3) as createdAt FROM ${TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
@@ -225,7 +235,6 @@ var ClickhouseStore = class extends MastraStorage {
           ${["id String"].concat(columns)}
         )
         ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
         PRIMARY KEY (createdAt, run_id, workflow_name)
         ORDER BY (createdAt, run_id, workflow_name)
         ${rowTtl ? `TTL toDateTime(${rowTtl.ttlKey ?? "createdAt"}) + INTERVAL ${rowTtl.interval} ${rowTtl.unit}` : ""}
@@ -235,7 +244,6 @@ var ClickhouseStore = class extends MastraStorage {
           ${columns}
         )
         ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
         PRIMARY KEY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
         ORDER BY (createdAt, ${tableName === TABLE_EVALS ? "run_id" : "id"})
         ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ""}
@@ -480,7 +488,7 @@ var ClickhouseStore = class extends MastraStorage {
   async deleteThread({ threadId }) {
     try {
       await this.db.command({
-        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = '${threadId}';`,
+        query: `DELETE FROM "${TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
         query_params: { var_thread_id: threadId },
         clickhouse_settings: {
           output_format_json_quote_64bit_integers: 0
@@ -694,12 +702,31 @@ var ClickhouseStore = class extends MastraStorage {
       throw error;
     }
   }
+  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: new Date(row.createdAt),
+      updatedAt: new Date(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
   async getWorkflowRuns({
     workflowName,
     fromDate,
     toDate,
     limit,
-    offset
+    offset,
+    resourceId
   } = {}) {
     try {
       const conditions = [];
@@ -708,6 +735,15 @@ var ClickhouseStore = class extends MastraStorage {
         conditions.push(`workflow_name = {var_workflow_name:String}`);
         values.var_workflow_name = workflowName;
       }
+      if (resourceId) {
+        const hasResourceId = await this.hasColumn(TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        if (hasResourceId) {
+          conditions.push(`resourceId = {var_resourceId:String}`);
+          values.var_resourceId = resourceId;
+        } else {
+          console.warn(`[${TABLE_WORKFLOW_SNAPSHOT}] resourceId column not found. Skipping resourceId filter.`);
+        }
+      }
       if (fromDate) {
         conditions.push(`createdAt >= {var_from_date:DateTime64(3)}`);
         values.var_from_date = fromDate.getTime() / 1e3;
@@ -736,7 +772,8 @@ var ClickhouseStore = class extends MastraStorage {
             run_id,
             snapshot,
             toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt
+            toDateTime64(updatedAt, 3) as updatedAt,
+            resourceId
           FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
           ${whereClause}
           ORDER BY createdAt DESC
@@ -749,21 +786,7 @@ var ClickhouseStore = class extends MastraStorage {
       const resultJson = await result.json();
       const rows = resultJson;
       const runs = rows.map((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: new Date(row.createdAt),
-          updatedAt: new Date(row.updatedAt)
-        };
+        return this.parseWorkflowRun(row);
       });
       return { runs, total: total || runs.length };
     } catch (error) {
@@ -771,6 +794,55 @@ var ClickhouseStore = class extends MastraStorage {
       throw error;
     }
   }
+  async getWorkflowRunById({
+    runId,
+    workflowName
+  }) {
+    try {
+      const conditions = [];
+      const values = {};
+      if (runId) {
+        conditions.push(`run_id = {var_runId:String}`);
+        values.var_runId = runId;
+      }
+      if (workflowName) {
+        conditions.push(`workflow_name = {var_workflow_name:String}`);
+        values.var_workflow_name = workflowName;
+      }
+      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const result = await this.db.query({
+        query: `
+          SELECT 
+            workflow_name,
+            run_id,
+            snapshot,
+            toDateTime64(createdAt, 3) as createdAt,
+            toDateTime64(updatedAt, 3) as updatedAt,
+            resourceId
+          FROM ${TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
+          ${whereClause}
+        `,
+        query_params: values,
+        format: "JSONEachRow"
+      });
+      const resultJson = await result.json();
+      if (!Array.isArray(resultJson) || resultJson.length === 0) {
+        return null;
+      }
+      return this.parseWorkflowRun(resultJson[0]);
+    } catch (error) {
+      console.error("Error getting workflow run by ID:", error);
+      throw error;
+    }
+  }
+  async hasColumn(table, column) {
+    const result = await this.db.query({
+      query: `DESCRIBE TABLE ${table}`,
+      format: "JSONEachRow"
+    });
+    const columns = await result.json();
+    return columns.some((c) => c.name === column);
+  }
   async close() {
     await this.db.close();
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/clickhouse",
-  "version": "0.0.0-switch-to-core-20250424015131",
+  "version": "0.0.0-vector-query-sources-20250516172905",
   "description": "Clickhouse provider for Mastra - includes db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -21,16 +21,16 @@
   "license": "MIT",
   "dependencies": {
     "@clickhouse/client": "^1.11.0",
-    "@mastra/core": "0.0.0-switch-to-core-20250424015131"
+    "@mastra/core": "0.0.0-vector-query-sources-20250516172905"
   },
   "devDependencies": {
-    "@microsoft/api-extractor": "^7.52.1",
+    "@microsoft/api-extractor": "^7.52.5",
     "@types/node": "^20.17.27",
     "eslint": "^9.23.0",
     "tsup": "^8.4.0",
     "typescript": "^5.8.2",
-    "vitest": "^3.0.9",
-    "@internal/lint": "0.0.2"
+    "vitest": "^3.1.2",
+    "@internal/lint": "0.0.0-vector-query-sources-20250516172905"
   },
   "scripts": {
     "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting",

package/src/storage/index.test.ts

@@ -1,11 +1,14 @@
 import { randomUUID } from 'crypto';
+import type { WorkflowRunState } from '@mastra/core';
+import type { MessageType } from '@mastra/core/memory';
 import { TABLE_THREADS, TABLE_MESSAGES, TABLE_WORKFLOW_SNAPSHOT } from '@mastra/core/storage';
-import type { WorkflowRunState } from '@mastra/core/workflows';
-import { describe, it, expect, beforeAll, beforeEach, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, beforeEach, afterAll, vi, afterEach } from 'vitest';
 
 import { ClickhouseStore } from '.';
 import type { ClickhouseConfig } from '.';
 
+vi.setConfig({ testTimeout: 60_000, hookTimeout: 60_000 });
+
 const TEST_CONFIG: ClickhouseConfig = {
   url: process.env.CLICKHOUSE_URL || 'http://localhost:8123',
   username: process.env.CLICKHOUSE_USERNAME || 'default',
@@ -32,15 +35,15 @@ const createSampleThread = () => ({
   metadata: { key: 'value' },
 });
 
-const createSampleMessage = (threadId: string, createdAt: Date = new Date()) =>
-  ({
-    id: `msg-${randomUUID()}`,
-    role: 'user',
-    type: 'text',
-    threadId,
-    content: [{ type: 'text', text: 'Hello' }],
-    createdAt,
-  }) as any;
+const createSampleMessage = (threadId: string, createdAt: Date = new Date()): MessageType => ({
+  id: `msg-${randomUUID()}`,
+  resourceId: `resource-${randomUUID()}`,
+  role: 'user',
+  type: 'text',
+  threadId,
+  content: [{ type: 'text', text: 'Hello' }] as MessageType['content'],
+  createdAt,
+});
 
 const createSampleTrace = () => ({
   id: `trace-${randomUUID()}`,
@@ -57,7 +60,10 @@ const createSampleEval = () => ({
   createdAt: new Date(),
 });
 
-const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
+const createSampleWorkflowSnapshot = (
+  status: WorkflowRunState['context']['steps'][string]['status'],
+  createdAt?: Date,
+) => {
   const runId = `run-${randomUUID()}`;
   const stepId = `step-${randomUUID()}`;
   const timestamp = createdAt || new Date();
@@ -76,12 +82,20 @@ const createSampleWorkflowSnapshot = (status: string, createdAt?: Date) => {
       attempts: {},
     },
     activePaths: [],
+    suspendedPaths: {},
     runId,
     timestamp: timestamp.getTime(),
-  } as WorkflowRunState;
+  };
   return { snapshot, runId, stepId };
 };
 
+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('ClickhouseStore', () => {
   let store: ClickhouseStore;
 
@@ -185,7 +199,11 @@ describe('ClickhouseStore', () => {
       // Retrieve messages
       const retrievedMessages = await store.getMessages({ threadId: thread.id });
       expect(retrievedMessages).toHaveLength(2);
-      expect(retrievedMessages).toEqual(expect.arrayContaining(messages));
+      const checkMessages = messages.map(m => {
+        const { resourceId, ...rest } = m;
+        return rest;
+      });
+      expect(retrievedMessages).toEqual(expect.arrayContaining(checkMessages));
     }, 10e3);
 
     it('should handle empty message array', async () => {
@@ -197,7 +215,7 @@ describe('ClickhouseStore', () => {
       const thread = createSampleThread();
       await store.saveThread({ thread });
 
-      const messages = [
+      const messages: MessageType[] = [
         {
           ...createSampleMessage(thread.id, new Date(Date.now() - 1000 * 3)),
           content: [{ type: 'text', text: 'First' }],
@@ -214,11 +232,12 @@ describe('ClickhouseStore', () => {
 
       await store.saveMessages({ messages });
 
-      const retrievedMessages = await store.getMessages({ threadId: thread.id });
+      const retrievedMessages = await store.getMessages<MessageType>({ threadId: thread.id });
       expect(retrievedMessages).toHaveLength(3);
 
       // Verify order is maintained
       retrievedMessages.forEach((msg, idx) => {
+        // @ts-expect-error
         expect(msg.content[0].text).toBe(messages[idx].content[0].text);
       });
     }, 10e3);
@@ -352,11 +371,17 @@ describe('ClickhouseStore', () => {
       const snapshot = {
         status: 'running',
         context: {
+          steps: {},
           stepResults: {},
           attempts: {},
           triggerData: { type: 'manual' },
         },
-      } as any;
+        value: {},
+        activePaths: [],
+        suspendedPaths: {},
+        runId,
+        timestamp: new Date().getTime(),
+      };
 
       await store.persistWorkflowSnapshot({
         workflowName,
@@ -387,28 +412,40 @@ describe('ClickhouseStore', () => {
       const initialSnapshot = {
         status: 'running',
         context: {
+          steps: {},
           stepResults: {},
           attempts: {},
           triggerData: { type: 'manual' },
         },
+        value: {},
+        activePaths: [],
+        suspendedPaths: {},
+        runId,
+        timestamp: new Date().getTime(),
       };
 
       await store.persistWorkflowSnapshot({
         workflowName,
         runId,
-        snapshot: initialSnapshot as any,
+        snapshot: initialSnapshot,
       });
 
       const updatedSnapshot = {
         status: 'completed',
         context: {
+          steps: {},
           stepResults: {
             'step-1': { status: 'success', result: { data: 'test' } },
           },
           attempts: { 'step-1': 1 },
           triggerData: { type: 'manual' },
         },
-      } as any;
+        value: {},
+        activePaths: [],
+        suspendedPaths: {},
+        runId,
+        timestamp: new Date().getTime(),
+      };
 
       await store.persistWorkflowSnapshot({
         workflowName,
@@ -446,6 +483,7 @@ describe('ClickhouseStore', () => {
               dependencies: ['step-3', 'step-4'],
             },
           },
+          steps: {},
           attempts: { 'step-1': 1, 'step-2': 0 },
           triggerData: {
             type: 'scheduled',
@@ -467,6 +505,7 @@ describe('ClickhouseStore', () => {
             status: 'waiting',
           },
         ],
+        suspendedPaths: {},
         runId: runId,
         timestamp: Date.now(),
       };
@@ -474,7 +513,7 @@ describe('ClickhouseStore', () => {
       await store.persistWorkflowSnapshot({
         workflowName,
         runId,
-        snapshot: complexSnapshot as WorkflowRunState,
+        snapshot: complexSnapshot,
       });
 
       const loadedSnapshot = await store.loadWorkflowSnapshot({
@@ -500,8 +539,8 @@ describe('ClickhouseStore', () => {
       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({
         workflowName: workflowName1,
@@ -520,17 +559,17 @@ describe('ClickhouseStore', () => {
       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({
@@ -551,8 +590,8 @@ describe('ClickhouseStore', () => {
       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;
+      checkWorkflowSnapshot(snapshot, stepId1, 'success');
     });
 
     it('filters by date range', async () => {
@@ -563,9 +602,9 @@ describe('ClickhouseStore', () => {
       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,
@@ -606,10 +645,10 @@ describe('ClickhouseStore', () => {
       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 () => {
@@ -617,9 +656,9 @@ describe('ClickhouseStore', () => {
       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({
         workflowName: workflowName1,
@@ -648,10 +687,10 @@ describe('ClickhouseStore', () => {
       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({
@@ -661,10 +700,155 @@ describe('ClickhouseStore', () => {
       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');
     }, 10e3);
   });
+  describe('getWorkflowRunById', () => {
+    const workflowName = 'workflow-id-test';
+    let runId: string;
+    let stepId: string;
+
+    beforeEach(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: {
+          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({
+        runId,
+        workflowName,
+      });
+      expect(found).not.toBeNull();
+      expect(found?.runId).toBe(runId);
+      checkWorkflowSnapshot(found?.snapshot!, stepId, 'success');
+    });
+
+    it('should return null for non-existent workflow run ID', async () => {
+      const notFound = await store.getWorkflowRunById({
+        runId: 'non-existent-id',
+        workflowName,
+      });
+      expect(notFound).toBeNull();
+    });
+  });
+  describe('getWorkflowRuns with resourceId', () => {
+    const workflowName = 'workflow-id-test';
+    let resourceId: string;
+    let runIds: string[] = [];
+
+    beforeEach(async () => {
+      // Insert multiple workflow runs for the same resourceId
+      resourceId = 'resource-shared';
+      for (const status of ['completed', 'running']) {
+        const sample = createSampleWorkflowSnapshot(status as WorkflowRunState['context']['steps'][string]['status']);
+        runIds.push(sample.runId);
+        await store.insert({
+          tableName: TABLE_WORKFLOW_SNAPSHOT,
+          record: {
+            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: {
+          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({
+        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({
+        resourceId: 'non-existent-resource',
+        workflowName,
+      });
+      expect(Array.isArray(runs)).toBe(true);
+      expect(runs.length).toBe(0);
+    });
+  });
+
+  describe('hasColumn', () => {
+    const tempTable = 'temp_test_table';
+
+    beforeEach(async () => {
+      // Always try to drop the table before each test, ignore errors if it doesn't exist
+      try {
+        await store['db'].query({ query: `DROP TABLE IF EXISTS ${tempTable}` });
+      } catch {
+        /* ignore */
+      }
+    });
+
+    it('returns true if the column exists', async () => {
+      await store['db'].query({
+        query: `CREATE TABLE temp_test_table (
+          id UInt64,
+          resourceId String
+        ) ENGINE = MergeTree()
+        ORDER BY id
+        `,
+      });
+      expect(await store['hasColumn'](tempTable, 'resourceId')).toBe(true);
+    });
+
+    it('returns false if the column does not exist', async () => {
+      await store['db'].query({
+        query: `CREATE TABLE temp_test_table (
+          id UInt64,
+        ) ENGINE = MergeTree()
+        ORDER BY id
+        `,
+      });
+      expect(await store['hasColumn'](tempTable, 'resourceId')).toBe(false);
+    });
+
+    afterEach(async () => {
+      // Clean up after each test
+      try {
+        await store['db'].query({ query: `DROP TABLE IF EXISTS ${tempTable}` });
+      } catch {
+        /* ignore */
+      }
+    });
+  });
 
   afterAll(async () => {
     await store.close();