@mastra/upstash 1.0.0-beta.8 → 1.0.0

package/dist/index.js

@@ -1,4 +1,4 @@
-import { MastraStorage, createVectorErrorId, ScoresStorage, TABLE_SCORERS, createStorageErrorId, normalizePerPage, calculatePagination, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, transformScoreRow as transformScoreRow$1, serializeDate } from '@mastra/core/storage';
+import { MemoryStorage, TABLE_THREADS, TABLE_MESSAGES, TABLE_RESOURCES, ensureDate, createStorageErrorId, normalizePerPage, calculatePagination, filterByDateRange, ScoresStorage, TABLE_SCORERS, WorkflowsStorage, TABLE_WORKFLOW_SNAPSHOT, MastraCompositeStore, createVectorErrorId, serializeDate, transformScoreRow as transformScoreRow$1 } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MessageList } from '@mastra/core/agent';
 import { MastraError, ErrorCategory, ErrorDomain } from '@mastra/core/error';
@@ -190,19 +190,34 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       );
     }
   }
-  async listThreadsByResourceId(args) {
-    const { resourceId, page = 0, perPage: perPageInput, orderBy } = args;
+  async listThreads(args) {
+    const { page = 0, perPage: perPageInput, orderBy, filter } = args;
     const { field, direction } = this.parseOrderBy(orderBy);
+    try {
+      this.validatePaginationInput(page, perPageInput ?? 100);
+    } catch (error) {
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "LIST_THREADS", "INVALID_PAGE"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.USER,
+          details: { page, ...perPageInput !== void 0 && { perPage: perPageInput } }
+        },
+        error instanceof Error ? error : new Error("Invalid pagination parameters")
+      );
+    }
     const perPage = normalizePerPage(perPageInput, 100);
-    if (page < 0) {
+    try {
+      this.validateMetadataKeys(filter?.metadata);
+    } catch (error) {
       throw new MastraError(
         {
-          id: createStorageErrorId("UPSTASH", "LIST_THREADS_BY_RESOURCE_ID", "INVALID_PAGE"),
+          id: createStorageErrorId("UPSTASH", "LIST_THREADS", "INVALID_METADATA_KEY"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.USER,
-          details: { page }
+          details: { metadataKeys: filter?.metadata ? Object.keys(filter.metadata).join(", ") : "" }
         },
-        new Error("page must be >= 0")
+        error instanceof Error ? error : new Error("Invalid metadata key")
       );
     }
     const { offset, perPage: perPageForResponse } = calculatePagination(page, perPageInput, perPage);
@@ -210,19 +225,35 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       let allThreads = [];
       const pattern = `${TABLE_THREADS}:*`;
       const keys = await this.#db.scanKeys(pattern);
+      if (keys.length === 0) {
+        return {
+          threads: [],
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
       const pipeline = this.client.pipeline();
       keys.forEach((key) => pipeline.get(key));
       const results = await pipeline.exec();
       for (let i = 0; i < results.length; i++) {
         const thread = results[i];
-        if (thread && thread.resourceId === resourceId) {
-          allThreads.push({
-            ...thread,
-            createdAt: ensureDate(thread.createdAt),
-            updatedAt: ensureDate(thread.updatedAt),
-            metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
-          });
+        if (!thread) continue;
+        if (filter?.resourceId && thread.resourceId !== filter.resourceId) {
+          continue;
         }
+        if (filter?.metadata && Object.keys(filter.metadata).length > 0) {
+          const threadMetadata = typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata;
+          const matches = Object.entries(filter.metadata).every(([key, value]) => threadMetadata?.[key] === value);
+          if (!matches) continue;
+        }
+        allThreads.push({
+          ...thread,
+          createdAt: ensureDate(thread.createdAt),
+          updatedAt: ensureDate(thread.updatedAt),
+          metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+        });
       }
       const sortedThreads = this.sortThreads(allThreads, field, direction);
       const total = sortedThreads.length;
@@ -239,11 +270,12 @@ var StoreMemoryUpstash = class extends MemoryStorage {
     } catch (error) {
       const mastraError = new MastraError(
         {
-          id: createStorageErrorId("UPSTASH", "LIST_THREADS_BY_RESOURCE_ID", "FAILED"),
+          id: createStorageErrorId("UPSTASH", "LIST_THREADS", "FAILED"),
           domain: ErrorDomain.STORAGE,
           category: ErrorCategory.THIRD_PARTY,
           details: {
-            resourceId,
+            ...filter?.resourceId && { resourceId: filter.resourceId },
+            hasMetadataFilter: !!filter?.metadata,
             page,
             perPage
           }
@@ -635,15 +667,11 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       if (resourceId) {
         messagesData = messagesData.filter((msg) => msg.resourceId === resourceId);
       }
-      const dateRange = filter?.dateRange;
-      if (dateRange?.start) {
-        const fromDate = dateRange.start;
-        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() >= fromDate.getTime());
-      }
-      if (dateRange?.end) {
-        const toDate = dateRange.end;
-        messagesData = messagesData.filter((msg) => new Date(msg.createdAt).getTime() <= toDate.getTime());
-      }
+      messagesData = filterByDateRange(
+        messagesData,
+        (msg) => new Date(msg.createdAt),
+        filter?.dateRange
+      );
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
       const getFieldValue = (msg) => {
         if (field === "createdAt") {
@@ -991,6 +1019,118 @@ var StoreMemoryUpstash = class extends MemoryStorage {
       }
     });
   }
+  async cloneThread(args) {
+    const { sourceThreadId, newThreadId: providedThreadId, resourceId, title, metadata, options } = args;
+    const sourceThread = await this.getThreadById({ threadId: sourceThreadId });
+    if (!sourceThread) {
+      throw new MastraError({
+        id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "SOURCE_NOT_FOUND"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Source thread with id ${sourceThreadId} not found`,
+        details: { sourceThreadId }
+      });
+    }
+    const newThreadId = providedThreadId || crypto.randomUUID();
+    const existingThread = await this.getThreadById({ threadId: newThreadId });
+    if (existingThread) {
+      throw new MastraError({
+        id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "THREAD_EXISTS"),
+        domain: ErrorDomain.STORAGE,
+        category: ErrorCategory.USER,
+        text: `Thread with id ${newThreadId} already exists`,
+        details: { newThreadId }
+      });
+    }
+    try {
+      const threadMessagesKey = getThreadMessagesKey(sourceThreadId);
+      const messageIds = await this.client.zrange(threadMessagesKey, 0, -1);
+      const pipeline = this.client.pipeline();
+      for (const mid of messageIds) {
+        pipeline.get(getMessageKey(sourceThreadId, mid));
+      }
+      const results = await pipeline.exec();
+      let sourceMessages = results.filter((msg) => msg !== null).map((msg) => ({
+        ...msg,
+        createdAt: new Date(msg.createdAt)
+      }));
+      if (options?.messageFilter?.startDate || options?.messageFilter?.endDate) {
+        sourceMessages = filterByDateRange(sourceMessages, (msg) => new Date(msg.createdAt), {
+          start: options.messageFilter?.startDate,
+          end: options.messageFilter?.endDate
+        });
+      }
+      if (options?.messageFilter?.messageIds && options.messageFilter.messageIds.length > 0) {
+        const messageIdSet = new Set(options.messageFilter.messageIds);
+        sourceMessages = sourceMessages.filter((msg) => messageIdSet.has(msg.id));
+      }
+      sourceMessages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+      if (options?.messageLimit && options.messageLimit > 0 && sourceMessages.length > options.messageLimit) {
+        sourceMessages = sourceMessages.slice(-options.messageLimit);
+      }
+      const now = /* @__PURE__ */ new Date();
+      const lastMessageId = sourceMessages.length > 0 ? sourceMessages[sourceMessages.length - 1].id : void 0;
+      const cloneMetadata = {
+        sourceThreadId,
+        clonedAt: now,
+        ...lastMessageId && { lastMessageId }
+      };
+      const newThread = {
+        id: newThreadId,
+        resourceId: resourceId || sourceThread.resourceId,
+        title: title || (sourceThread.title ? `Clone of ${sourceThread.title}` : void 0),
+        metadata: {
+          ...metadata,
+          clone: cloneMetadata
+        },
+        createdAt: now,
+        updatedAt: now
+      };
+      const writePipeline = this.client.pipeline();
+      const threadKey = getKey(TABLE_THREADS, { id: newThreadId });
+      writePipeline.set(threadKey, processRecord(TABLE_THREADS, newThread).processedRecord);
+      const clonedMessages = [];
+      const targetResourceId = resourceId || sourceThread.resourceId;
+      const newThreadMessagesKey = getThreadMessagesKey(newThreadId);
+      for (let i = 0; i < sourceMessages.length; i++) {
+        const sourceMsg = sourceMessages[i];
+        const newMessageId = crypto.randomUUID();
+        const { _index, ...restMsg } = sourceMsg;
+        const newMessage = {
+          ...restMsg,
+          id: newMessageId,
+          threadId: newThreadId,
+          resourceId: targetResourceId
+        };
+        const messageKey = getMessageKey(newThreadId, newMessageId);
+        writePipeline.set(messageKey, newMessage);
+        writePipeline.set(getMessageIndexKey(newMessageId), newThreadId);
+        writePipeline.zadd(newThreadMessagesKey, {
+          score: i,
+          member: newMessageId
+        });
+        clonedMessages.push(newMessage);
+      }
+      await writePipeline.exec();
+      return {
+        thread: newThread,
+        clonedMessages
+      };
+    } catch (error) {
+      if (error instanceof MastraError) {
+        throw error;
+      }
+      throw new MastraError(
+        {
+          id: createStorageErrorId("UPSTASH", "CLONE_THREAD", "FAILED"),
+          domain: ErrorDomain.STORAGE,
+          category: ErrorCategory.THIRD_PARTY,
+          details: { sourceThreadId, newThreadId }
+        },
+        error
+      );
+    }
+  }
 };
 function transformScoreRow(row) {
   return transformScoreRow$1(row);
@@ -1271,24 +1411,6 @@ var ScoresUpstash = class extends ScoresStorage {
     };
   }
 };
-function 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: ensureDate(row.createdAt),
-    updatedAt: ensureDate(row.updatedAt),
-    resourceId: row.resourceId
-  };
-}
 var WorkflowsUpstash = class extends WorkflowsStorage {
   client;
   #db;
@@ -1298,6 +1420,24 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
     this.client = client;
     this.#db = new UpstashDB({ client });
   }
+  parseWorkflowRun(row) {
+    let parsedSnapshot = row.snapshot;
+    if (typeof parsedSnapshot === "string") {
+      try {
+        parsedSnapshot = JSON.parse(row.snapshot);
+      } catch (e) {
+        this.logger.warn(`Failed to parse snapshot for workflow ${row.workflow_name}: ${e}`);
+      }
+    }
+    return {
+      workflowName: row.workflow_name,
+      runId: row.run_id,
+      snapshot: parsedSnapshot,
+      createdAt: ensureDate(row.createdAt),
+      updatedAt: ensureDate(row.updatedAt),
+      resourceId: row.resourceId
+    };
+  }
   async dangerouslyClearAll() {
     await this.#db.deleteData({ tableName: TABLE_WORKFLOW_SNAPSHOT });
   }
@@ -1463,7 +1603,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       );
       const data = workflows.find((w) => w?.run_id === runId && w?.workflow_name === workflowName);
       if (!data) return null;
-      return parseWorkflowRun(data);
+      return this.parseWorkflowRun(data);
     } catch (error) {
       throw new MastraError(
         {
@@ -1548,7 +1688,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
       const results = await pipeline.exec();
       let runs = results.map((result) => result).filter(
         (record) => record !== null && record !== void 0 && typeof record === "object" && "workflow_name" in record
-      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => parseWorkflowRun(w)).filter((w) => {
+      ).filter((record) => !workflowName || record.workflow_name === workflowName).map((w) => this.parseWorkflowRun(w)).filter((w) => {
         if (fromDate && w.createdAt < fromDate) return false;
         if (toDate && w.createdAt > toDate) return false;
         if (status) {
@@ -1557,7 +1697,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
             try {
               snapshot = JSON.parse(snapshot);
             } catch (e) {
-              console.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
+              this.logger.warn(`Failed to parse snapshot for workflow ${w.workflowName}: ${e}`);
               return false;
             }
           }
@@ -1595,7 +1735,7 @@ var WorkflowsUpstash = class extends WorkflowsStorage {
 var isClientConfig = (config) => {
   return "client" in config;
 };
-var UpstashStore = class extends MastraStorage {
+var UpstashStore = class extends MastraCompositeStore {
   redis;
   stores;
   constructor(config) {
@@ -1623,19 +1763,6 @@ var UpstashStore = class extends MastraStorage {
       memory
     };
   }
-  get supports() {
-    return {
-      selectByIncludeResourceScope: true,
-      resourceWorkingMemory: true,
-      hasColumn: false,
-      createTable: false,
-      deleteMessages: true,
-      observability: false,
-      indexManagement: false,
-      listScoresBySpan: true,
-      agents: false
-    };
-  }
   async close() {
   }
 };
@@ -2330,6 +2457,6 @@ Example Complex Query:
   ]
 }`;
 
-export { UPSTASH_PROMPT, UpstashStore, UpstashVector };
+export { ScoresUpstash, StoreMemoryUpstash, UPSTASH_PROMPT, UpstashStore, UpstashVector, WorkflowsUpstash };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map