@mastra/convex 1.0.7 → 1.0.8

package/dist/index.js

@@ -1,10 +1,10 @@
 export { mastraStorage } from './chunk-SDTI6G3V.js';
 export { TABLE_MESSAGES, TABLE_RESOURCES, TABLE_SCORERS, TABLE_THREADS, TABLE_WORKFLOW_SNAPSHOT, mastraDocumentsTable, mastraMessagesTable, mastraResourcesTable, mastraScoresTable, mastraThreadsTable, mastraVectorIndexesTable, mastraVectorsTable, mastraWorkflowSnapshotsTable } from './chunk-G5FLGAPE.js';
-import { MastraCompositeStore, createVectorErrorId, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, safelyParseJSON, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS } from '@mastra/core/storage';
-import { MessageList } from '@mastra/core/agent';
-import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
+import { MastraCompositeStore, createVectorErrorId, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, safelyParseJSON, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, ScoresStorage, TABLE_SCORERS, BackgroundTasksStorage, TABLE_BACKGROUND_TASKS } from '@mastra/core/storage';
 import crypto from 'crypto';
 import { MastraBase } from '@mastra/core/base';
+import { MessageList } from '@mastra/core/agent';
+import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
 import { MastraVector } from '@mastra/core/vector';
 
 // src/storage/client.ts
@@ -81,6 +81,7 @@ var ConvexDB = class extends MastraBase {
     super({ name: "convex-db" });
     this.client = client;
   }
+  client;
   async hasColumn(_table, _column) {
     return true;
   }
@@ -175,7 +176,134 @@ var ConvexDB = class extends MastraBase {
   }
 };
 
-// src/storage/domains/memory/index.ts
+// src/storage/domains/background-tasks/index.ts
+function serializeJson(v) {
+  if (typeof v === "object" && v != null) return JSON.stringify(v);
+  return v ?? void 0;
+}
+function toStored(task) {
+  return {
+    ...task,
+    args: serializeJson(task.args),
+    result: serializeJson(task.result),
+    error: serializeJson(task.error),
+    createdAt: task.createdAt.toISOString(),
+    startedAt: task.startedAt?.toISOString(),
+    completedAt: task.completedAt?.toISOString()
+  };
+}
+function fromStored(stored) {
+  const parseJson = (val) => {
+    if (!val) return void 0;
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  };
+  return {
+    id: stored.id,
+    status: stored.status,
+    toolName: stored.toolName,
+    toolCallId: stored.toolCallId,
+    args: parseJson(stored.args) ?? {},
+    agentId: stored.agentId,
+    threadId: stored.threadId,
+    resourceId: stored.resourceId,
+    runId: stored.runId,
+    result: parseJson(stored.result),
+    error: parseJson(stored.error),
+    retryCount: stored.retryCount,
+    maxRetries: stored.maxRetries,
+    timeoutMs: stored.timeoutMs,
+    createdAt: new Date(stored.createdAt),
+    startedAt: stored.startedAt ? new Date(stored.startedAt) : void 0,
+    completedAt: stored.completedAt ? new Date(stored.completedAt) : void 0
+  };
+}
+var BackgroundTasksConvex = class extends BackgroundTasksStorage {
+  #db;
+  constructor(config) {
+    super();
+    const client = resolveConvexConfig(config);
+    this.#db = new ConvexDB(client);
+  }
+  async dangerouslyClearAll() {
+    await this.#db.clearTable({ tableName: TABLE_BACKGROUND_TASKS });
+  }
+  async createTask(task) {
+    await this.#db.insert({ tableName: TABLE_BACKGROUND_TASKS, record: toStored(task) });
+  }
+  async updateTask(taskId, update) {
+    const existing = await this.getTask(taskId);
+    if (!existing) return;
+    const merged = { ...existing };
+    if ("status" in update) merged.status = update.status;
+    if ("result" in update) merged.result = update.result;
+    if ("error" in update) merged.error = update.error;
+    if ("retryCount" in update) merged.retryCount = update.retryCount;
+    if ("startedAt" in update) merged.startedAt = update.startedAt;
+    if ("completedAt" in update) merged.completedAt = update.completedAt;
+    await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, [taskId]);
+    await this.#db.insert({ tableName: TABLE_BACKGROUND_TASKS, record: toStored(merged) });
+  }
+  async getTask(taskId) {
+    const data = await this.#db.load({ tableName: TABLE_BACKGROUND_TASKS, keys: { id: taskId } });
+    return data ? fromStored(data) : null;
+  }
+  async listTasks(filter) {
+    const all = await this.#db.queryTable(TABLE_BACKGROUND_TASKS);
+    let tasks = all.map(fromStored);
+    if (filter.status) {
+      const s = Array.isArray(filter.status) ? filter.status : [filter.status];
+      tasks = tasks.filter((t) => s.includes(t.status));
+    }
+    if (filter.agentId) tasks = tasks.filter((t) => t.agentId === filter.agentId);
+    if (filter.threadId) tasks = tasks.filter((t) => t.threadId === filter.threadId);
+    if (filter.toolName) tasks = tasks.filter((t) => t.toolName === filter.toolName);
+    if (filter.runId) tasks = tasks.filter((t) => t.runId === filter.runId);
+    const dateCol = filter.dateFilterBy ?? "createdAt";
+    if (filter.fromDate) {
+      tasks = tasks.filter((t) => {
+        const val = t[dateCol];
+        return val != null && val >= filter.fromDate;
+      });
+    }
+    if (filter.toDate) {
+      tasks = tasks.filter((t) => {
+        const val = t[dateCol];
+        return val != null && val < filter.toDate;
+      });
+    }
+    const orderBy = filter.orderBy ?? "createdAt";
+    const dir = filter.orderDirection === "desc" ? -1 : 1;
+    tasks.sort((a, b) => ((a[orderBy]?.getTime() ?? 0) - (b[orderBy]?.getTime() ?? 0)) * dir);
+    const total = tasks.length;
+    if (filter.page != null && filter.perPage != null) {
+      const start = filter.page * filter.perPage;
+      tasks = tasks.slice(start, start + filter.perPage);
+    } else if (filter.perPage != null) {
+      tasks = tasks.slice(0, filter.perPage);
+    }
+    return { tasks, total };
+  }
+  async deleteTask(taskId) {
+    await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, [taskId]);
+  }
+  async deleteTasks(filter) {
+    const { tasks } = await this.listTasks(filter);
+    const taskIds = tasks.map((t) => t.id);
+    await this.#db.deleteMany(TABLE_BACKGROUND_TASKS, taskIds);
+  }
+  async getRunningCount() {
+    const { total } = await this.listTasks({ status: "running" });
+    return total;
+  }
+  async getRunningCountByAgent(agentId) {
+    const { total } = await this.listTasks({ status: "running", agentId });
+    return total;
+  }
+};
 var MemoryConvex = class extends MemoryStorage {
   #db;
   constructor(config) {
@@ -933,7 +1061,8 @@ var ConvexStore = class extends MastraCompositeStore {
     this.stores = {
       memory,
       workflows,
-      scores
+      scores,
+      backgroundTasks: new BackgroundTasksConvex(domainConfig)
     };
   }
 };