@mastra/clickhouse 0.0.0-vnextWorkflows-20250422142014 → 0.0.0-workflow-deno-20250616115451

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

@@ -1,12 +1,18 @@
 import type { ClickHouseClient } from '@clickhouse/client';
 import type { EvalRow } from '@mastra/core/storage';
+import type { MastraMessageV1 } from '@mastra/core/memory';
+import type { MastraMessageV2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
-import type { MessageType } from '@mastra/core/memory';
+import type { PaginationInfo } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageGetTracesArg } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
 import type { TABLE_NAMES } from '@mastra/core/storage';
 import { TABLE_SCHEMAS } from '@mastra/core/storage';
+import type { Trace } from '@mastra/core/telemetry';
+import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
 import type { WorkflowRunState } from '@mastra/core/workflows';
 
 declare type ClickhouseConfig = {
@@ -43,13 +49,15 @@ declare class ClickhouseStore extends MastraStorage {
         tableName: TABLE_NAMES;
         records: Record<string, any>[];
     }): Promise<void>;
-    getTraces({ name, scope, page, perPage, attributes, filters, }: {
+    getTraces({ name, scope, page, perPage, attributes, filters, fromDate, toDate, }: {
         name?: string;
         scope?: string;
         page: number;
         perPage: number;
         attributes?: Record<string, string>;
         filters?: Record<string, any>;
+        fromDate?: Date;
+        toDate?: Date;
     }): Promise<any[]>;
     optimizeTable({ tableName }: {
         tableName: TABLE_NAMES;
@@ -61,6 +69,18 @@ declare class ClickhouseStore extends MastraStorage {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
@@ -89,10 +109,20 @@ declare class ClickhouseStore extends MastraStorage {
     deleteThread({ threadId }: {
         threadId: string;
     }): Promise<void>;
-    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T>;
-    saveMessages({ messages }: {
-        messages: MessageType[];
-    }): Promise<MessageType[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2[]>;
     persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
         workflowName: string;
         runId: string;
@@ -102,21 +132,32 @@ declare class ClickhouseStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, }?: {
+    private parseWorkflowRun;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         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({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun | null>;
+    private hasColumn;
+    getTracesPaginated(_args: StorageGetTracesArg): Promise<PaginationInfo & {
+        traces: Trace[];
+    }>;
+    getThreadsByResourceIdPaginated(_args: {
+        resourceId: string;
+        page?: number;
+        perPage?: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    getMessagesPaginated(_args: StorageGetMessagesArg): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2[];
     }>;
     close(): Promise<void>;
 }

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var client = require('@clickhouse/client');
+var agent = require('@mastra/core/agent');
 var storage = require('@mastra/core/storage');
 
 // src/storage/index.ts
@@ -138,7 +139,9 @@ var ClickhouseStore = class extends storage.MastraStorage {
     page,
     perPage,
     attributes,
-    filters
+    filters,
+    fromDate,
+    toDate
   }) {
     const limit = perPage;
     const offset = page * perPage;
@@ -166,6 +169,14 @@ var ClickhouseStore = class extends storage.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 ${storage.TABLE_TRACES} ${whereClause} ORDER BY "createdAt" DESC LIMIT ${limit} OFFSET ${offset}`,
@@ -227,7 +238,6 @@ var ClickhouseStore = class extends storage.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}` : ""}
@@ -237,7 +247,6 @@ var ClickhouseStore = class extends storage.MastraStorage {
           ${columns}
         )
         ENGINE = ${TABLE_ENGINES[tableName]}
-        PARTITION BY "createdAt"
         PRIMARY KEY (createdAt, ${tableName === storage.TABLE_EVALS ? "run_id" : "id"})
         ORDER BY (createdAt, ${tableName === storage.TABLE_EVALS ? "run_id" : "id"})
         ${this.ttl?.[tableName]?.row ? `TTL toDateTime(createdAt) + INTERVAL ${this.ttl[tableName].row.interval} ${this.ttl[tableName].row.unit}` : ""}
@@ -258,6 +267,61 @@ var ClickhouseStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "String";
+      case "timestamp":
+        return "DateTime64(3)";
+      case "integer":
+      case "bigint":
+        return "Int64";
+      case "jsonb":
+        return "String";
+      default:
+        return super.getSqlType(type);
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    try {
+      const describeSql = `DESCRIBE TABLE ${tableName}`;
+      const result = await this.db.query({
+        query: describeSql
+      });
+      const rows = await result.json();
+      const existingColumnNames = new Set(rows.data.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          let sqlType = this.getSqlType(columnDef.type);
+          if (columnDef.nullable !== false) {
+            sqlType = `Nullable(${sqlType})`;
+          }
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${tableName} ADD COLUMN IF NOT EXISTS "${columnName}" ${sqlType} ${defaultValue}`.trim();
+          await this.db.query({
+            query: alterSql
+          });
+          this.logger?.debug?.(`Added column ${columnName} to table ${tableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
   async clearTable({ tableName }) {
     try {
       await this.db.query({
@@ -459,15 +523,18 @@ var ClickhouseStore = class extends storage.MastraStorage {
       };
       await this.db.insert({
         table: storage.TABLE_THREADS,
+        format: "JSONEachRow",
         values: [
           {
-            ...updatedThread,
+            id: updatedThread.id,
+            resourceId: updatedThread.resourceId,
+            title: updatedThread.title,
+            metadata: updatedThread.metadata,
+            createdAt: updatedThread.createdAt,
             updatedAt: updatedThread.updatedAt.toISOString()
           }
         ],
-        format: "JSONEachRow",
         clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
           date_time_input_format: "best_effort",
           use_client_time_zone: 1,
           output_format_json_quote_64bit_integers: 0
@@ -482,7 +549,7 @@ var ClickhouseStore = class extends storage.MastraStorage {
   async deleteThread({ threadId }) {
     try {
       await this.db.command({
-        query: `DELETE FROM "${storage.TABLE_MESSAGES}" WHERE thread_id = '${threadId}';`,
+        query: `DELETE FROM "${storage.TABLE_MESSAGES}" WHERE thread_id = {var_thread_id:String};`,
         query_params: { var_thread_id: threadId },
         clickhouse_settings: {
           output_format_json_quote_64bit_integers: 0
@@ -500,7 +567,12 @@ var ClickhouseStore = class extends storage.MastraStorage {
       throw error;
     }
   }
-  async getMessages({ threadId, selectBy }) {
+  async getMessages({
+    threadId,
+    resourceId,
+    selectBy,
+    format
+  }) {
     try {
       const messages = [];
       const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
@@ -596,16 +668,20 @@ var ClickhouseStore = class extends storage.MastraStorage {
           }
         }
       });
-      return messages;
+      const list = new agent.MessageList({ threadId, resourceId }).add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       console.error("Error getting messages:", error);
       throw error;
     }
   }
-  async saveMessages({ messages }) {
+  async saveMessages(args) {
+    const { messages, format = "v1" } = args;
     if (messages.length === 0) return messages;
     try {
       const threadId = messages[0]?.threadId;
+      const resourceId = messages[0]?.resourceId;
       if (!threadId) {
         throw new Error("Thread ID is required");
       }
@@ -613,25 +689,50 @@ var ClickhouseStore = class extends storage.MastraStorage {
       if (!thread) {
         throw new Error(`Thread ${threadId} not found`);
       }
-      await this.db.insert({
-        table: storage.TABLE_MESSAGES,
-        format: "JSONEachRow",
-        values: messages.map((message) => ({
-          id: message.id,
-          thread_id: threadId,
-          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
-          createdAt: message.createdAt.toISOString(),
-          role: message.role,
-          type: message.type
-        })),
-        clickhouse_settings: {
-          // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
-          date_time_input_format: "best_effort",
-          use_client_time_zone: 1,
-          output_format_json_quote_64bit_integers: 0
-        }
-      });
-      return messages;
+      await Promise.all([
+        // Insert messages
+        this.db.insert({
+          table: storage.TABLE_MESSAGES,
+          format: "JSONEachRow",
+          values: messages.map((message) => ({
+            id: message.id,
+            thread_id: threadId,
+            content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+            createdAt: message.createdAt.toISOString(),
+            role: message.role,
+            type: message.type || "v2"
+          })),
+          clickhouse_settings: {
+            // Allows to insert serialized JS Dates (such as '2023-12-06T10:54:48.000Z')
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        }),
+        // Update thread's updatedAt timestamp
+        this.db.insert({
+          table: storage.TABLE_THREADS,
+          format: "JSONEachRow",
+          values: [
+            {
+              id: thread.id,
+              resourceId: thread.resourceId,
+              title: thread.title,
+              metadata: thread.metadata,
+              createdAt: thread.createdAt,
+              updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+            }
+          ],
+          clickhouse_settings: {
+            date_time_input_format: "best_effort",
+            use_client_time_zone: 1,
+            output_format_json_quote_64bit_integers: 0
+          }
+        })
+      ]);
+      const list = new agent.MessageList({ threadId, resourceId }).add(messages, "memory");
+      if (format === `v2`) return list.get.all.v2();
+      return list.get.all.v1();
     } catch (error) {
       console.error("Error saving messages:", error);
       throw error;
@@ -696,12 +797,31 @@ var ClickhouseStore = class extends storage.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 = [];
@@ -710,6 +830,15 @@ var ClickhouseStore = class extends storage.MastraStorage {
         conditions.push(`workflow_name = {var_workflow_name:String}`);
         values.var_workflow_name = workflowName;
       }
+      if (resourceId) {
+        const hasResourceId = await this.hasColumn(storage.TABLE_WORKFLOW_SNAPSHOT, "resourceId");
+        if (hasResourceId) {
+          conditions.push(`resourceId = {var_resourceId:String}`);
+          values.var_resourceId = resourceId;
+        } else {
+          console.warn(`[${storage.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;
@@ -738,7 +867,8 @@ var ClickhouseStore = class extends storage.MastraStorage {
             run_id,
             snapshot,
             toDateTime64(createdAt, 3) as createdAt,
-            toDateTime64(updatedAt, 3) as updatedAt
+            toDateTime64(updatedAt, 3) as updatedAt,
+            resourceId
           FROM ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.TABLE_WORKFLOW_SNAPSHOT].startsWith("ReplacingMergeTree") ? "FINAL" : ""}
           ${whereClause}
           ORDER BY createdAt DESC
@@ -751,21 +881,7 @@ var ClickhouseStore = class extends storage.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) {
@@ -773,6 +889,64 @@ var ClickhouseStore = class extends storage.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 ${storage.TABLE_WORKFLOW_SNAPSHOT} ${TABLE_ENGINES[storage.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 getTracesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getThreadsByResourceIdPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
+  async getMessagesPaginated(_args) {
+    throw new Error("Method not implemented.");
+  }
   async close() {
     await this.db.close();
   }