@mastra/upstash 0.1.0-alpha.11 → 0.1.0-alpha.12

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @mastra/upstash
 
+## 0.1.0-alpha.12
+
+### Patch Changes
+
+- Updated dependencies [a9345f9]
+  - @mastra/core@0.2.0-alpha.102
+
 ## 0.1.0-alpha.11
 
 ### Patch Changes

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

@@ -0,0 +1,116 @@
+import { BaseFilterTranslator } from '@mastra/core/filter';
+import { Filter } from '@mastra/core/filter';
+import { MastraStorage } from '@mastra/core/storage';
+import { MastraVector } from '@mastra/core/vector';
+import { MessageType } from '@mastra/core/memory';
+import { OperatorSupport } from '@mastra/core/filter';
+import type { QueryResult } from '@mastra/core/vector';
+import { StorageColumn } from '@mastra/core/storage';
+import { StorageGetMessagesArg } from '@mastra/core/storage';
+import { StorageThreadType } from '@mastra/core/memory';
+import { TABLE_NAMES } from '@mastra/core/storage';
+import { WorkflowRunState } from '@mastra/core/workflows';
+
+declare interface UpstashConfig {
+    url: string;
+    token: string;
+}
+export { UpstashConfig }
+export { UpstashConfig as UpstashConfig_alias_1 }
+
+export declare class UpstashFilterTranslator extends BaseFilterTranslator {
+    protected getSupportedOperators(): OperatorSupport;
+    translate(filter?: Filter): string | undefined;
+    private translateNode;
+    private readonly COMPARISON_OPS;
+    private translateOperator;
+    private readonly NEGATED_OPERATORS;
+    private formatNot;
+    private formatValue;
+    private formatArray;
+    private formatComparison;
+    private joinConditions;
+}
+
+declare class UpstashStore extends MastraStorage {
+    private redis;
+    constructor(config: UpstashConfig);
+    private getKey;
+    private ensureDate;
+    private serializeDate;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<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>;
+    private getMessageKey;
+    private getThreadMessagesKey;
+    saveMessages({ messages }: {
+        messages: MessageType[];
+    }): Promise<MessageType[]>;
+    getMessages<T = unknown>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    persistWorkflowSnapshot(params: {
+        namespace: string;
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot(params: {
+        namespace: string;
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    close(): Promise<void>;
+}
+export { UpstashStore }
+export { UpstashStore as UpstashStore_alias_1 }
+
+declare class UpstashVector extends MastraVector {
+    private client;
+    constructor({ url, token }: {
+        url: string;
+        token: string;
+    });
+    upsert(indexName: string, vectors: number[][], metadata?: Record<string, any>[], ids?: string[]): Promise<string[]>;
+    transformFilter(filter?: Filter): string | undefined;
+    createIndex(_indexName: string, _dimension: number, _metric?: 'cosine' | 'euclidean' | 'dotproduct'): Promise<void>;
+    query(indexName: string, queryVector: number[], topK?: number, filter?: Filter, includeVector?: boolean): Promise<QueryResult[]>;
+    listIndexes(): Promise<string[]>;
+    describeIndex(indexName: string): Promise<{
+        dimension: number;
+        count: number;
+        metric: "cosine" | "euclidean" | "dotproduct";
+    }>;
+    deleteIndex(indexName: string): Promise<void>;
+}
+export { UpstashVector }
+export { UpstashVector as UpstashVector_alias_1 }
+
+export { }

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { UpstashConfig } from './_tsup-dts-rollup.js';
+export { UpstashStore } from './_tsup-dts-rollup.js';
+export { UpstashVector } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -0,0 +1,466 @@
+import '@mastra/core/memory';
+import { MastraStorage } from '@mastra/core/storage';
+import '@mastra/core/workflows';
+import { Redis } from '@upstash/redis';
+import { MastraVector } from '@mastra/core/vector';
+import { Index } from '@upstash/vector';
+import { BaseFilterTranslator } from '@mastra/core/filter';
+
+// src/storage/index.ts
+var UpstashStore = class extends MastraStorage {
+  redis;
+  constructor(config) {
+    super({ name: "Upstash" });
+    this.redis = new Redis({
+      url: config.url,
+      token: config.token
+    });
+  }
+  getKey(tableName, keys) {
+    const keyParts = Object.entries(keys).map(([key, value]) => `${key}:${value}`);
+    return `${tableName}:${keyParts.join(":")}`;
+  }
+  ensureDate(date) {
+    if (!date) return undefined;
+    return date instanceof Date ? date : new Date(date);
+  }
+  serializeDate(date) {
+    if (!date) return undefined;
+    const dateObj = this.ensureDate(date);
+    return dateObj?.toISOString();
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    await this.redis.set(`schema:${tableName}`, schema);
+  }
+  async clearTable({ tableName }) {
+    const pattern = `${tableName}:*`;
+    const keys = await this.redis.keys(pattern);
+    if (keys.length > 0) {
+      await this.redis.del(...keys);
+    }
+  }
+  async insert({ tableName, record }) {
+    let key;
+    if (tableName === MastraStorage.TABLE_MESSAGES) {
+      key = this.getKey(tableName, { threadId: record.threadId, id: record.id });
+    } else {
+      key = this.getKey(tableName, { id: record.id });
+    }
+    const processedRecord = {
+      ...record,
+      createdAt: this.serializeDate(record.createdAt),
+      updatedAt: this.serializeDate(record.updatedAt)
+    };
+    await this.redis.set(key, processedRecord);
+  }
+  async load({ tableName, keys }) {
+    const key = this.getKey(tableName, keys);
+    const data = await this.redis.get(key);
+    return data || null;
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.load({
+      tableName: MastraStorage.TABLE_THREADS,
+      keys: { id: threadId }
+    });
+    if (!thread) return null;
+    return {
+      ...thread,
+      createdAt: this.ensureDate(thread.createdAt),
+      updatedAt: this.ensureDate(thread.updatedAt),
+      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+    };
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    const pattern = `${MastraStorage.TABLE_THREADS}:*`;
+    const keys = await this.redis.keys(pattern);
+    const threads = await Promise.all(
+      keys.map(async (key) => {
+        const data = await this.redis.get(key);
+        return data;
+      })
+    );
+    return threads.filter((thread) => thread && thread.resourceId === resourceId).map((thread) => ({
+      ...thread,
+      createdAt: this.ensureDate(thread.createdAt),
+      updatedAt: this.ensureDate(thread.updatedAt),
+      metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata
+    }));
+  }
+  async saveThread({ thread }) {
+    await this.insert({
+      tableName: MastraStorage.TABLE_THREADS,
+      record: thread
+    });
+    return thread;
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const thread = await this.getThreadById({ threadId: id });
+    if (!thread) {
+      throw new Error(`Thread ${id} not found`);
+    }
+    const updatedThread = {
+      ...thread,
+      title,
+      metadata: {
+        ...thread.metadata,
+        ...metadata
+      }
+    };
+    await this.__saveThread({ thread: updatedThread });
+    return updatedThread;
+  }
+  async deleteThread({ threadId }) {
+    const key = this.getKey(MastraStorage.TABLE_THREADS, { id: threadId });
+    await this.redis.del(key);
+  }
+  getMessageKey(threadId, messageId) {
+    return this.getKey(MastraStorage.TABLE_MESSAGES, { threadId, id: messageId });
+  }
+  getThreadMessagesKey(threadId) {
+    return `thread:${threadId}:messages`;
+  }
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return [];
+    const pipeline = this.redis.pipeline();
+    const messagesWithIndex = messages.map((message, index) => ({
+      ...message,
+      _index: index
+    }));
+    for (const message of messagesWithIndex) {
+      const key = this.getMessageKey(message.threadId, message.id);
+      const score = message._index !== undefined ? message._index : new Date(message.createdAt).getTime();
+      pipeline.set(key, message);
+      pipeline.zadd(this.getThreadMessagesKey(message.threadId), {
+        score,
+        member: message.id
+      });
+    }
+    await pipeline.exec();
+    return messages;
+  }
+  async getMessages({ threadId, selectBy }) {
+    const limit = typeof selectBy?.last === `number` ? selectBy.last : 40;
+    const messageIds = /* @__PURE__ */ new Set();
+    const threadMessagesKey = this.getThreadMessagesKey(threadId);
+    if (limit === 0 && !selectBy?.include) {
+      return [];
+    }
+    if (selectBy?.include?.length) {
+      for (const item of selectBy.include) {
+        messageIds.add(item.id);
+        if (item.withPreviousMessages || item.withNextMessages) {
+          const rank = await this.redis.zrank(threadMessagesKey, item.id);
+          if (rank === null) continue;
+          if (item.withPreviousMessages) {
+            const start = Math.max(0, rank - item.withPreviousMessages);
+            const prevIds = rank === 0 ? [] : await this.redis.zrange(threadMessagesKey, start, rank - 1);
+            prevIds.forEach((id) => messageIds.add(id));
+          }
+          if (item.withNextMessages) {
+            const nextIds = await this.redis.zrange(threadMessagesKey, rank + 1, rank + item.withNextMessages);
+            nextIds.forEach((id) => messageIds.add(id));
+          }
+        }
+      }
+    }
+    const latestIds = limit === 0 ? [] : await this.redis.zrange(threadMessagesKey, -limit, -1);
+    latestIds.forEach((id) => messageIds.add(id));
+    const messages = (await Promise.all(
+      Array.from(messageIds).map(
+        async (id) => this.redis.get(this.getMessageKey(threadId, id))
+      )
+    )).filter((msg) => msg !== null);
+    const messageOrder = await this.redis.zrange(threadMessagesKey, 0, -1);
+    messages.sort((a, b) => messageOrder.indexOf(a.id) - messageOrder.indexOf(b.id));
+    return messages.map(({ _index, ...message }) => message);
+  }
+  async persistWorkflowSnapshot(params) {
+    const { namespace, workflowName, runId, snapshot } = params;
+    const key = this.getKey(MastraStorage.TABLE_WORKFLOW_SNAPSHOT, {
+      namespace,
+      workflow_name: workflowName,
+      run_id: runId
+    });
+    await this.redis.set(key, snapshot);
+  }
+  async loadWorkflowSnapshot(params) {
+    const { namespace, workflowName, runId } = params;
+    const key = this.getKey(MastraStorage.TABLE_WORKFLOW_SNAPSHOT, {
+      namespace,
+      workflow_name: workflowName,
+      run_id: runId
+    });
+    const data = await this.redis.get(key);
+    return data || null;
+  }
+  async close() {
+  }
+};
+var UpstashFilterTranslator = class extends BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...BaseFilterTranslator.DEFAULT_OPERATORS,
+      array: ["$in", "$nin", "$all"],
+      regex: ["$regex"],
+      custom: ["$contains"]
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) return undefined;
+    this.validateFilter(filter);
+    return this.translateNode(filter);
+  }
+  translateNode(node, path = "") {
+    if (this.isRegex(node)) {
+      throw new Error("Direct regex pattern format is not supported in Upstash");
+    }
+    if (node === null || node === undefined) {
+      throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+    }
+    if (this.isPrimitive(node)) {
+      if (node === null || node === undefined) {
+        throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+      }
+      return this.formatComparison(path, "=", node);
+    }
+    if (Array.isArray(node)) {
+      if (node.length === 0) {
+        return "(HAS FIELD empty AND HAS NOT FIELD empty)";
+      }
+      return `${path} IN (${this.formatArray(node)})`;
+    }
+    const entries = Object.entries(node);
+    const conditions = [];
+    for (const [key, value] of entries) {
+      const newPath = path ? `${path}.${key}` : key;
+      if (this.isOperator(key)) {
+        conditions.push(this.translateOperator(key, value, path));
+      } else if (typeof value === "object" && value !== null) {
+        conditions.push(this.translateNode(value, newPath));
+      } else if (value === null || value === undefined) {
+        throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+      } else {
+        conditions.push(this.formatComparison(newPath, "=", value));
+      }
+    }
+    return conditions.length > 1 ? `(${conditions.join(" AND ")})` : conditions[0] ?? "";
+  }
+  COMPARISON_OPS = {
+    $eq: "=",
+    $ne: "!=",
+    $gt: ">",
+    $gte: ">=",
+    $lt: "<",
+    $lte: "<="
+  };
+  translateOperator(operator, value, path) {
+    if (this.isBasicOperator(operator) || this.isNumericOperator(operator)) {
+      return this.formatComparison(path, this.COMPARISON_OPS[operator], value);
+    }
+    switch (operator) {
+      case "$in":
+        if (!Array.isArray(value) || value.length === 0) {
+          return "(HAS FIELD empty AND HAS NOT FIELD empty)";
+        }
+        return `${path} IN (${this.formatArray(value)})`;
+      case "$nin":
+        return `${path} NOT IN (${this.formatArray(value)})`;
+      case "$contains":
+        return `${path} CONTAINS ${this.formatValue(value)}`;
+      case "$regex":
+        return `${path} GLOB ${this.formatValue(value)}`;
+      case "$exists":
+        return value ? `HAS FIELD ${path}` : `HAS NOT FIELD ${path}`;
+      case "$and":
+        if (!Array.isArray(value) || value.length === 0) {
+          return "(HAS FIELD empty OR HAS NOT FIELD empty)";
+        }
+        return this.joinConditions(value, "AND");
+      case "$or":
+        if (!Array.isArray(value) || value.length === 0) {
+          return "(HAS FIELD empty AND HAS NOT FIELD empty)";
+        }
+        return this.joinConditions(value, "OR");
+      case "$not":
+        return this.formatNot(path, value);
+      case "$nor":
+        return this.formatNot("", { $or: value });
+      case "$all":
+        return this.translateOperator(
+          "$and",
+          value.map((item) => ({ [path]: { $contains: item } })),
+          ""
+        );
+      default:
+        throw new Error(`Unsupported operator: ${operator}`);
+    }
+  }
+  NEGATED_OPERATORS = {
+    $eq: "$ne",
+    $ne: "$eq",
+    $gt: "$lte",
+    $gte: "$lt",
+    $lt: "$gte",
+    $lte: "$gt",
+    $in: "$nin",
+    $nin: "$in",
+    $exists: "$exists"
+    // Special case - we'll flip the value
+  };
+  formatNot(path, value) {
+    if (typeof value !== "object") {
+      return `${path} != ${this.formatValue(value)}`;
+    }
+    if (!Object.keys(value).some((k) => k.startsWith("$"))) {
+      const [fieldName, fieldValue] = Object.entries(value)[0] ?? [];
+      if (typeof fieldValue === "object" && fieldValue !== null && Object.keys(fieldValue)[0]?.startsWith("$")) {
+        const [op2, val2] = Object.entries(fieldValue)[0] ?? [];
+        const negatedOp = this.NEGATED_OPERATORS[op2];
+        if (!negatedOp) throw new Error(`Unsupported operator in NOT: ${op2}`);
+        if (op2 === "$exists") {
+          return this.translateOperator(op2, !val2, fieldName ?? "");
+        }
+        return this.translateOperator(negatedOp, val2, fieldName ?? "");
+      }
+      return `${fieldName} != ${this.formatValue(fieldValue)}`;
+    }
+    const [op, val] = Object.entries(value)[0] ?? [];
+    if (op === "$lt") return `${path} >= ${this.formatValue(val)}`;
+    if (op === "$lte") return `${path} > ${this.formatValue(val)}`;
+    if (op === "$gt") return `${path} <= ${this.formatValue(val)}`;
+    if (op === "$gte") return `${path} < ${this.formatValue(val)}`;
+    if (op === "$ne") return `${path} = ${this.formatValue(val)}`;
+    if (op === "$eq") return `${path} != ${this.formatValue(val)}`;
+    if (op === "$contains") return `${path} NOT CONTAINS ${this.formatValue(val)}`;
+    if (op === "$regex") return `${path} NOT GLOB ${this.formatValue(val)}`;
+    if (op === "$in") return `${path} NOT IN (${this.formatArray(val)})`;
+    if (op === "$exists") return val ? `HAS NOT FIELD ${path}` : `HAS FIELD ${path}`;
+    if (op === "$and" || op === "$or") {
+      const newOp = op === "$and" ? "$or" : "$and";
+      const conditions = val.map((condition) => {
+        const [fieldName, fieldValue] = Object.entries(condition)[0] ?? [];
+        return { [fieldName]: { $not: fieldValue } };
+      });
+      return this.translateOperator(newOp, conditions, "");
+    }
+    if (op === "$nor") {
+      return this.translateOperator("$or", val, "");
+    }
+    return `${path} != ${this.formatValue(val)}`;
+  }
+  formatValue(value) {
+    if (value === null || value === undefined) {
+      throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+    }
+    if (typeof value === "string") {
+      const hasSingleQuote = /'/g.test(value);
+      const hasDoubleQuote = /"/g.test(value);
+      if (hasSingleQuote && hasDoubleQuote) {
+        return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+      }
+      if (hasSingleQuote) {
+        return `"${value}"`;
+      }
+      return `'${value}'`;
+    }
+    if (typeof value === "number") {
+      if (Math.abs(value) < 1e-6 || Math.abs(value) > 1e6) {
+        return value.toFixed(20).replace(/\.?0+$/, "");
+      }
+      return value.toString();
+    }
+    return String(value);
+  }
+  formatArray(values) {
+    return values.map((value) => {
+      if (value === null || value === undefined) {
+        throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+      }
+      return this.formatValue(value);
+    }).join(", ");
+  }
+  formatComparison(path, op, value) {
+    return `${path} ${op} ${this.formatValue(value)}`;
+  }
+  joinConditions(conditions, operator) {
+    const translated = Array.isArray(conditions) ? conditions.map((c) => this.translateNode(c)) : [this.translateNode(conditions)];
+    return `(${translated.join(` ${operator} `)})`;
+  }
+};
+
+// src/vector/index.ts
+var UpstashVector = class extends MastraVector {
+  client;
+  constructor({ url, token }) {
+    super();
+    this.client = new Index({
+      url,
+      token
+    });
+  }
+  async upsert(indexName, vectors, metadata, ids) {
+    const generatedIds = ids || vectors.map(() => crypto.randomUUID());
+    const points = vectors.map((vector, index) => ({
+      id: generatedIds[index],
+      vector,
+      metadata: metadata?.[index]
+    }));
+    await this.client.upsert(points, {
+      namespace: indexName
+    });
+    return generatedIds;
+  }
+  transformFilter(filter) {
+    const translator = new UpstashFilterTranslator();
+    return translator.translate(filter);
+  }
+  async createIndex(_indexName, _dimension, _metric = "cosine") {
+    console.log("No need to call createIndex for Upstash");
+  }
+  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
+    const ns = this.client.namespace(indexName);
+    const filterString = this.transformFilter(filter);
+    const results = await ns.query({
+      topK,
+      vector: queryVector,
+      includeVectors: includeVector,
+      includeMetadata: true,
+      ...filterString ? { filter: filterString } : {}
+    });
+    return (results || []).map((result) => ({
+      id: `${result.id}`,
+      score: result.score,
+      metadata: result.metadata,
+      ...includeVector && { vector: result.vector || [] }
+    }));
+  }
+  async listIndexes() {
+    const indexes = await this.client.listNamespaces();
+    return indexes.filter(Boolean);
+  }
+  async describeIndex(indexName) {
+    const info = await this.client.info();
+    return {
+      dimension: info.dimension,
+      count: info.namespaces?.[indexName]?.vectorCount || 0,
+      metric: info?.similarityFunction?.toLowerCase()
+    };
+  }
+  async deleteIndex(indexName) {
+    try {
+      await this.client.deleteNamespace(indexName);
+    } catch (error) {
+      console.error("Failed to delete namespace:", error);
+    }
+  }
+};
+
+export { UpstashStore, UpstashVector };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.12",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -17,7 +17,7 @@
   "dependencies": {
     "@upstash/redis": "^1.28.3",
     "@upstash/vector": "^1.1.7",
-    "@mastra/core": "^0.2.0-alpha.101"
+    "@mastra/core": "^0.2.0-alpha.102"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",