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

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @mastra/upstash
 
+## 0.1.0-alpha.11
+
+### Patch Changes
+
+- 4f1d1a1: Enforce types ann cleanup package.json
+- Updated dependencies [66a03ec]
+- Updated dependencies [4f1d1a1]
+  - @mastra/core@0.2.0-alpha.101
+
 ## 0.1.0-alpha.10
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/upstash",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.11",
   "description": "Upstash provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -17,11 +17,11 @@
   "dependencies": {
     "@upstash/redis": "^1.28.3",
     "@upstash/vector": "^1.1.7",
-    "@mastra/core": "^0.2.0-alpha.100"
+    "@mastra/core": "^0.2.0-alpha.101"
   },
   "devDependencies": {
-    "@tsconfig/recommended": "^1.0.7",
-    "@types/node": "^22.9.0",
+    "@microsoft/api-extractor": "^7.49.2",
+    "@types/node": "^22.13.1",
     "tsup": "^8.0.1",
     "vitest": "^3.0.4"
   },
@@ -29,7 +29,7 @@
     "pretest": "docker compose up -d",
     "test": "vitest run",
     "posttest": "docker compose down",
-    "build": "tsup src/index.ts --format esm --dts --clean --treeshake",
+    "build": "tsup src/index.ts --format esm --experimental-dts --clean --treeshake",
     "build:watch": "pnpm build --watch"
   }
 }

package/src/vector/filter.ts

@@ -1,4 +1,4 @@
-import { BaseFilterTranslator, Filter, FieldCondition, OperatorSupport } from '@mastra/core/filter';
+import { BaseFilterTranslator, type Filter, type FieldCondition, type OperatorSupport } from '@mastra/core/filter';
 
 export class UpstashFilterTranslator extends BaseFilterTranslator {
   protected override getSupportedOperators(): OperatorSupport {

package/dist/index.d.ts

@@ -1,88 +0,0 @@
-import { StorageThreadType, MessageType } from '@mastra/core/memory';
-import { MastraStorage, TABLE_NAMES, StorageColumn, StorageGetMessagesArg } from '@mastra/core/storage';
-import { WorkflowRunState } from '@mastra/core/workflows';
-import { Filter } from '@mastra/core/filter';
-import { MastraVector, QueryResult } from '@mastra/core/vector';
-
-interface UpstashConfig {
-    url: string;
-    token: string;
-}
-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>;
-}
-
-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 { type UpstashConfig, UpstashStore, UpstashVector };

package/dist/index.js

@@ -1,466 +0,0 @@
-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 };