@mastra/upstash 0.1.6-alpha.1 → 0.1.6-alpha.3

package/dist/index.cjs

@@ -0,0 +1,480 @@
+'use strict';
+
+var storage = require('@mastra/core/storage');
+var redis = require('@upstash/redis');
+var vector = require('@mastra/core/vector');
+var vector$1 = require('@upstash/vector');
+var filter = require('@mastra/core/vector/filter');
+
+// src/storage/index.ts
+var UpstashStore = class extends storage.MastraStorage {
+  batchInsert(_input) {
+    throw new Error("Method not implemented.");
+  }
+  getEvalsByAgentName(_agentName, _type) {
+    throw new Error("Method not implemented.");
+  }
+  getTraces(_input) {
+    throw new Error("Method not implemented.");
+  }
+  redis;
+  constructor(config) {
+    super({ name: "Upstash" });
+    this.redis = new redis.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 void 0;
+    return date instanceof Date ? date : new Date(date);
+  }
+  serializeDate(date) {
+    if (!date) return void 0;
+    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 === storage.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: storage.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 = `${storage.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: storage.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(storage.MastraStorage.TABLE_THREADS, { id: threadId });
+    await this.redis.del(key);
+  }
+  getMessageKey(threadId, messageId) {
+    return this.getKey(storage.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 !== void 0 ? 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(storage.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(storage.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 filter.BaseFilterTranslator {
+  getSupportedOperators() {
+    return {
+      ...filter.BaseFilterTranslator.DEFAULT_OPERATORS,
+      array: ["$in", "$nin", "$all"],
+      regex: ["$regex"],
+      custom: ["$contains"]
+    };
+  }
+  translate(filter) {
+    if (this.isEmpty(filter)) return void 0;
+    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 === void 0) {
+      throw new Error("Filtering for null/undefined values is not supported by Upstash Vector");
+    }
+    if (this.isPrimitive(node)) {
+      if (node === null || node === void 0) {
+        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 === void 0) {
+        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 === void 0) {
+      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 === void 0) {
+        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 vector.MastraVector {
+  client;
+  constructor({ url, token }) {
+    super();
+    this.client = new vector$1.Index({
+      url,
+      token
+    });
+  }
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
+    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(..._args) {
+    console.log("No need to call createIndex for Upstash");
+  }
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
+    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);
+    }
+  }
+};
+
+exports.UpstashStore = UpstashStore;
+exports.UpstashVector = UpstashVector;

package/dist/index.d.cts

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

package/dist/index.js

@@ -2,7 +2,7 @@ import { MastraStorage } from '@mastra/core/storage';
 import { Redis } from '@upstash/redis';
 import { MastraVector } from '@mastra/core/vector';
 import { Index } from '@upstash/vector';
-import { BaseFilterTranslator } from '@mastra/core/filter';
+import { BaseFilterTranslator } from '@mastra/core/vector/filter';
 
 // src/storage/index.ts
 var UpstashStore = class extends MastraStorage {
@@ -413,7 +413,9 @@ var UpstashVector = class extends MastraVector {
       token
     });
   }
-  async upsert(indexName, vectors, metadata, ids) {
+  async upsert(...args) {
+    const params = this.normalizeArgs("upsert", args);
+    const { indexName, vectors, metadata, ids } = params;
     const generatedIds = ids || vectors.map(() => crypto.randomUUID());
     const points = vectors.map((vector, index) => ({
       id: generatedIds[index],
@@ -429,10 +431,12 @@ var UpstashVector = class extends MastraVector {
     const translator = new UpstashFilterTranslator();
     return translator.translate(filter);
   }
-  async createIndex(_indexName, _dimension, _metric = "cosine") {
+  async createIndex(..._args) {
     console.log("No need to call createIndex for Upstash");
   }
-  async query(indexName, queryVector, topK = 10, filter, includeVector = false) {
+  async query(...args) {
+    const params = this.normalizeArgs("query", args);
+    const { indexName, queryVector, topK = 10, filter, includeVector = false } = params;
     const ns = this.client.namespace(indexName);
     const filterString = this.transformFilter(filter);
     const results = await ns.query({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.1.6-alpha.1",
+  "version": "0.1.6-alpha.3",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -10,6 +10,10 @@
       "import": {
         "types": "./dist/index.d.ts",
         "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       }
     },
     "./package.json": "./package.json"
@@ -17,7 +21,7 @@
   "dependencies": {
     "@upstash/redis": "^1.28.3",
     "@upstash/vector": "^1.1.7",
-    "@mastra/core": "^0.4.3-alpha.1"
+    "@mastra/core": "^0.4.3-alpha.3"
   },
   "devDependencies": {
     "@microsoft/api-extractor": "^7.49.2",
@@ -32,8 +36,8 @@
     "pretest": "docker compose up -d",
     "test": "vitest run",
     "posttest": "docker compose down",
-    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
-    "build:watch": "pnpm build --watch",
-    "lint": "eslint ."
+    "lint": "eslint .",
+    "build": "tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake",
+    "build:watch": "pnpm build --watch"
   }
 }