@mastra/upstash 0.12.1 → 0.12.2-alpha.0

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/upstash@0.12.1-alpha.0 build /home/runner/work/mastra/mastra/stores/upstash
+> @mastra/upstash@0.12.2-alpha.0 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.5.0
 TSC Build start
-TSC ⚡️ Build success in 10259ms
+TSC ⚡️ Build success in 11238ms
 DTS Build start
 CLI Target: es2022
 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.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/upstash/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 11533ms
+DTS ⚡️ Build success in 13538ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-CJS dist/index.cjs 58.93 KB
-CJS ⚡️ Build success in 1501ms
-ESM dist/index.js 58.11 KB
-ESM ⚡️ Build success in 1502ms
+CJS dist/index.cjs 74.17 KB
+CJS ⚡️ Build success in 1946ms
+ESM dist/index.js 73.33 KB
+ESM ⚡️ Build success in 1947ms

package/CHANGELOG.md

@@ -1,5 +1,30 @@
 # @mastra/upstash
 
+## 0.12.2-alpha.0
+
+### Patch Changes
+
+- 7ba91fa: Throw mastra errors methods not implemented yet
+- Updated dependencies [f248d53]
+- Updated dependencies [2affc57]
+- Updated dependencies [66e13e3]
+- Updated dependencies [edd9482]
+- Updated dependencies [18344d7]
+- Updated dependencies [9d372c2]
+- Updated dependencies [40c2525]
+- Updated dependencies [e473f27]
+- Updated dependencies [032cb66]
+- Updated dependencies [703ac71]
+- Updated dependencies [a723d69]
+- Updated dependencies [5889a31]
+- Updated dependencies [65e3395]
+- Updated dependencies [4933192]
+- Updated dependencies [d1c77a4]
+- Updated dependencies [bea9dd1]
+- Updated dependencies [dcd4802]
+- Updated dependencies [7ba91fa]
+  - @mastra/core@0.11.0-alpha.2
+
 ## 0.12.1
 
 ### Patch Changes

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

@@ -5,29 +5,282 @@ import type { DeleteVectorParams } from '@mastra/core/vector';
 import type { DescribeIndexParams } from '@mastra/core/vector';
 import type { EvalRow } from '@mastra/core/storage';
 import type { IndexStats } from '@mastra/core/vector';
+import { LegacyEvalsStorage } from '@mastra/core/storage';
 import type { MastraMessageContentV2 } from '@mastra/core/agent';
 import type { MastraMessageV1 } from '@mastra/core/memory';
 import type { MastraMessageV2 } from '@mastra/core/agent';
+import type { MastraMessageV2 as MastraMessageV2_2 } from '@mastra/core/memory';
 import { MastraStorage } from '@mastra/core/storage';
 import { MastraVector } from '@mastra/core/vector';
+import { MemoryStorage } from '@mastra/core/storage';
 import type { OperatorSupport } from '@mastra/core/vector/filter';
 import type { OperatorValueMap } from '@mastra/core/vector/filter';
 import type { PaginationArgs } from '@mastra/core/storage';
 import type { PaginationInfo } from '@mastra/core/storage';
 import type { QueryResult } from '@mastra/core/vector';
 import type { QueryVectorParams } from '@mastra/core/vector';
+import type { Redis } from '@upstash/redis';
+import type { ScoreRowData } from '@mastra/core/scores';
+import { ScoresStorage } from '@mastra/core/storage';
 import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageDomains } from '@mastra/core/storage';
 import type { StorageGetMessagesArg } from '@mastra/core/storage';
 import type { StorageGetTracesArg } from '@mastra/core/storage';
+import type { StoragePagination } from '@mastra/core/storage';
 import type { StorageResourceType } from '@mastra/core/storage';
 import type { StorageThreadType } from '@mastra/core/memory';
+import { StoreOperations } from '@mastra/core/storage';
 import type { TABLE_NAMES } from '@mastra/core/storage';
+import { TracesStorage } from '@mastra/core/storage';
 import type { UpdateVectorParams } from '@mastra/core/vector';
 import type { UpsertVectorParams } from '@mastra/core/vector';
 import type { VectorFilter } from '@mastra/core/vector/filter';
 import type { WorkflowRun } from '@mastra/core/storage';
+import type { WorkflowRun as WorkflowRun_2 } from '@mastra/core';
 import type { WorkflowRuns } from '@mastra/core/storage';
+import type { WorkflowRuns as WorkflowRuns_2 } from '@mastra/core';
 import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+import { WorkflowsStorage } from '@mastra/core/storage';
+
+export declare function ensureDate(value: any): Date | null;
+
+export declare function getKey(tableName: TABLE_NAMES, keys: Record<string, any>): string;
+
+export declare function parseJSON(value: any): any;
+
+export declare function processRecord(tableName: TABLE_NAMES, record: Record<string, any>): {
+    key: string;
+    processedRecord: {
+        createdAt: string | undefined;
+        updatedAt: string | undefined;
+    };
+};
+
+export declare class ScoresUpstash extends ScoresStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Redis;
+        operations: StoreOperationsUpstash;
+    });
+    getScoreById({ id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination?: {
+            page: number;
+            perPage: number;
+        };
+    }): Promise<{
+        scores: ScoreRowData[];
+        pagination: {
+            total: number;
+            page: number;
+            perPage: number;
+            hasMore: boolean;
+        };
+    }>;
+    saveScore(score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination?: {
+            page: number;
+            perPage: number;
+        };
+    }): Promise<{
+        scores: ScoreRowData[];
+        pagination: {
+            total: number;
+            page: number;
+            perPage: number;
+            hasMore: boolean;
+        };
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        entityId: string;
+        entityType?: string;
+        pagination?: {
+            page: number;
+            perPage: number;
+        };
+    }): Promise<{
+        scores: ScoreRowData[];
+        pagination: {
+            total: number;
+            page: number;
+            perPage: number;
+            hasMore: boolean;
+        };
+    }>;
+}
+
+export declare class StoreLegacyEvalsUpstash extends LegacyEvalsStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Redis;
+        operations: StoreOperationsUpstash;
+    });
+    /**
+     * @deprecated Use getEvals instead
+     */
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    /**
+     * Get all evaluations with pagination and total count
+     * @param options Pagination and filtering options
+     * @returns Object with evals array and total count
+     */
+    getEvals(options?: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
+}
+
+export declare class StoreMemoryUpstash extends MemoryStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Redis;
+        operations: StoreOperationsUpstash;
+    });
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    /**
+     * @deprecated use getThreadsByResourceIdPaginated instead
+     */
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    getThreadsByResourceIdPaginated(args: {
+        resourceId: string;
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
+        threads: StorageThreadType[];
+    }>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    saveMessages(args: {
+        messages: MastraMessageV1[];
+        format?: undefined | 'v1';
+    }): Promise<MastraMessageV1[]>;
+    saveMessages(args: {
+        messages: MastraMessageV2_2[];
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    private _getIncludedMessages;
+    /**
+     * @deprecated use getMessagesPaginated instead
+     */
+    getMessages(args: StorageGetMessagesArg & {
+        format?: 'v1';
+    }): Promise<MastraMessageV1[]>;
+    getMessages(args: StorageGetMessagesArg & {
+        format: 'v2';
+    }): Promise<MastraMessageV2_2[]>;
+    getMessagesPaginated(args: StorageGetMessagesArg & {
+        format?: 'v1' | 'v2';
+    }): Promise<PaginationInfo & {
+        messages: MastraMessageV1[] | MastraMessageV2_2[];
+    }>;
+    getResourceById({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageResourceType | null>;
+    saveResource({ resource }: {
+        resource: StorageResourceType;
+    }): Promise<StorageResourceType>;
+    updateResource({ resourceId, workingMemory, metadata, }: {
+        resourceId: string;
+        workingMemory?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<StorageResourceType>;
+    updateMessages(args: {
+        messages: (Partial<Omit<MastraMessageV2_2, 'createdAt'>> & {
+            id: string;
+            content?: {
+                metadata?: MastraMessageContentV2['metadata'];
+                content?: MastraMessageContentV2['content'];
+            };
+        })[];
+    }): Promise<MastraMessageV2_2[]>;
+}
+
+export declare class StoreOperationsUpstash extends StoreOperations {
+    private client;
+    constructor({ client }: {
+        client: Redis;
+    });
+    createTable({ tableName: _tableName, schema: _schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    alterTable({ tableName: _tableName, schema: _schema, ifNotExists: _ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    batchInsert(input: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    hasColumn(_tableName: TABLE_NAMES, _column: string): Promise<boolean>;
+    scanKeys(pattern: string, batchSize?: number): Promise<string[]>;
+    scanAndDelete(pattern: string, batchSize?: number): Promise<number>;
+}
+
+export declare class TracesUpstash extends TracesStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Redis;
+        operations: StoreOperationsUpstash;
+    });
+    /**
+     * @deprecated use getTracesPaginated instead
+     */
+    getTraces(args: StorageGetTracesArg): Promise<any[]>;
+    getTracesPaginated(args: {
+        name?: string;
+        scope?: string;
+        attributes?: Record<string, string>;
+        filters?: Record<string, any>;
+    } & PaginationArgs): Promise<PaginationInfo & {
+        traces: any[];
+    }>;
+    batchTraceInsert(args: {
+        records: Record<string, any>[];
+    }): Promise<void>;
+}
 
 /**
  * Vector store specific prompt that details supported operators and examples.
@@ -66,34 +319,29 @@ declare type UpstashQueryVectorParams = QueryVectorParams<UpstashVectorFilter>;
 
 declare class UpstashStore extends MastraStorage {
     private redis;
+    stores: StorageDomains;
     constructor(config: UpstashConfig);
     get supports(): {
         selectByIncludeResourceScope: boolean;
         resourceWorkingMemory: boolean;
+        hasColumn: boolean;
+        createTable: boolean;
     };
-    private transformEvalRecord;
-    private parseJSON;
-    private getKey;
-    /**
-     * Scans for keys matching the given pattern using SCAN and returns them as an array.
-     * @param pattern Redis key pattern, e.g. "table:*"
-     * @param batchSize Number of keys to scan per batch (default: 1000)
-     */
-    private scanKeys;
-    /**
-     * Deletes all keys matching the given pattern using SCAN and DEL in batches.
-     * @param pattern Redis key pattern, e.g. "table:*"
-     * @param batchSize Number of keys to delete per batch (default: 1000)
-     */
-    private scanAndDelete;
-    private getMessageKey;
-    private getThreadMessagesKey;
-    private parseWorkflowRun;
-    private processRecord;
     /**
      * @deprecated Use getEvals instead
      */
     getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    /**
+     * Get all evaluations with pagination and total count
+     * @param options Pagination and filtering options
+     * @returns Object with evals array and total count
+     */
+    getEvals(options: {
+        agentName?: string;
+        type?: 'test' | 'live';
+    } & PaginationArgs): Promise<PaginationInfo & {
+        evals: EvalRow[];
+    }>;
     /**
      * @deprecated use getTracesPaginated instead
      */
@@ -106,6 +354,9 @@ declare class UpstashStore extends MastraStorage {
     } & PaginationArgs): Promise<PaginationInfo & {
         traces: any[];
     }>;
+    batchTraceInsert(args: {
+        records: Record<string, any>[];
+    }): Promise<void>;
     createTable({ tableName, schema, }: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
@@ -116,7 +367,7 @@ declare class UpstashStore extends MastraStorage {
      * @param schema Schema of the table
      * @param ifNotExists Array of column names to add if they don't exist
      */
-    alterTable(_args: {
+    alterTable(args: {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
         ifNotExists: string[];
@@ -124,6 +375,9 @@ declare class UpstashStore extends MastraStorage {
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;
+    dropTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
     insert({ tableName, record }: {
         tableName: TABLE_NAMES;
         record: Record<string, any>;
@@ -147,7 +401,9 @@ declare class UpstashStore extends MastraStorage {
     }): Promise<StorageThreadType[]>;
     getThreadsByResourceIdPaginated(args: {
         resourceId: string;
-    } & PaginationArgs): Promise<PaginationInfo & {
+        page: number;
+        perPage: number;
+    }): Promise<PaginationInfo & {
         threads: StorageThreadType[];
     }>;
     saveThread({ thread }: {
@@ -169,7 +425,6 @@ declare class UpstashStore extends MastraStorage {
         messages: MastraMessageV2[];
         format: 'v2';
     }): Promise<MastraMessageV2[]>;
-    private _getIncludedMessages;
     /**
      * @deprecated use getMessagesPaginated instead
      */
@@ -195,19 +450,7 @@ declare class UpstashStore extends MastraStorage {
         workflowName: string;
         runId: string;
     }): Promise<WorkflowRunState | null>;
-    /**
-     * Get all evaluations with pagination and total count
-     * @param options Pagination and filtering options
-     * @returns Object with evals array and total count
-     */
-    getEvals(options?: {
-        agentName?: string;
-        type?: 'test' | 'live';
-    } & PaginationArgs): Promise<PaginationInfo & {
-        evals: EvalRow[];
-    }>;
-    getWorkflowRuns({ namespace, workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
-        namespace: string;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }?: {
         workflowName?: string;
         fromDate?: Date;
         toDate?: Date;
@@ -215,20 +458,19 @@ declare class UpstashStore extends MastraStorage {
         offset?: number;
         resourceId?: string;
     }): Promise<WorkflowRuns>;
-    getWorkflowRunById({ namespace, runId, workflowName, }: {
-        namespace: string;
+    getWorkflowRunById({ runId, workflowName, }: {
         runId: string;
         workflowName?: string;
     }): Promise<WorkflowRun | null>;
     close(): Promise<void>;
-    updateMessages(_args: {
-        messages: Partial<Omit<MastraMessageV2, 'createdAt'>> & {
+    updateMessages(args: {
+        messages: (Partial<Omit<MastraMessageV2, 'createdAt'>> & {
             id: string;
             content?: {
                 metadata?: MastraMessageContentV2['metadata'];
                 content?: MastraMessageContentV2['content'];
             };
-        }[];
+        })[];
     }): Promise<MastraMessageV2[]>;
     getResourceById({ resourceId }: {
         resourceId: string;
@@ -241,6 +483,34 @@ declare class UpstashStore extends MastraStorage {
         workingMemory?: string;
         metadata?: Record<string, unknown>;
     }): Promise<StorageResourceType>;
+    getScoreById({ id: _id }: {
+        id: string;
+    }): Promise<ScoreRowData | null>;
+    saveScore(score: ScoreRowData): Promise<{
+        score: ScoreRowData;
+    }>;
+    getScoresByRunId({ runId, pagination, }: {
+        runId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByEntityId({ entityId, entityType, pagination, }: {
+        pagination: StoragePagination;
+        entityId: string;
+        entityType: string;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
+    getScoresByScorerId({ scorerId, pagination, }: {
+        scorerId: string;
+        pagination: StoragePagination;
+    }): Promise<{
+        pagination: PaginationInfo;
+        scores: ScoreRowData[];
+    }>;
 }
 export { UpstashStore }
 export { UpstashStore as UpstashStore_alias_1 }
@@ -324,4 +594,36 @@ export { UpstashVector as UpstashVector_alias_1 }
 
 export declare type UpstashVectorFilter = VectorFilter<keyof UpstashOperatorValueMap, UpstashOperatorValueMap>;
 
+export declare class WorkflowsUpstash extends WorkflowsStorage {
+    private client;
+    private operations;
+    constructor({ client, operations }: {
+        client: Redis;
+        operations: StoreOperationsUpstash;
+    });
+    persistWorkflowSnapshot(params: {
+        namespace: string;
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState_2;
+    }): Promise<void>;
+    loadWorkflowSnapshot(params: {
+        namespace: string;
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState_2 | null>;
+    getWorkflowRunById({ runId, workflowName, }: {
+        runId: string;
+        workflowName?: string;
+    }): Promise<WorkflowRun_2 | null>;
+    getWorkflowRuns({ workflowName, fromDate, toDate, limit, offset, resourceId, }: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+        resourceId?: string;
+    }): Promise<WorkflowRuns_2>;
+}
+
 export { }