@mastra/convex 1.0.11 → 1.1.0-alpha.0

package/dist/chunk-EEELVBWO.cjs

@@ -0,0 +1,893 @@
+'use strict';
+
+var server = require('convex/server');
+var constants = require('@mastra/core/storage/constants');
+var values = require('convex/values');
+
+// src/server/cache.ts
+var CACHE_TABLE = "mastra_cache";
+var CACHE_LIST_TABLE = "mastra_cache_list_items";
+var CACHE_MUTATION_BATCH_SIZE = 25;
+function encodeValue(value) {
+  return JSON.stringify(value === void 0 ? null : value);
+}
+function decodeValue(value) {
+  return JSON.parse(value);
+}
+function isExpired(doc, now) {
+  return doc.expiresAt !== null && doc.expiresAt <= now;
+}
+function normalizeListRange(from, to, length) {
+  const normalizedFrom = from < 0 ? Math.max(length + from, 0) : from;
+  const normalizedTo = to < 0 ? length + to : to;
+  if (normalizedTo < normalizedFrom || normalizedFrom >= length) return null;
+  return { from: normalizedFrom, to: normalizedTo };
+}
+async function findCacheDoc(ctx, key) {
+  return await ctx.db.query(CACHE_TABLE).withIndex("by_key", (q) => q.eq("key", key)).first();
+}
+async function deleteCacheKey(ctx, key) {
+  const [doc, listItems] = await Promise.all([
+    findCacheDoc(ctx, key),
+    ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => q.eq("key", key)).take(CACHE_MUTATION_BATCH_SIZE + 1)
+  ]);
+  if (doc && doc.kind !== "deleted") {
+    await ctx.db.patch(doc._id, { kind: "deleted" });
+  }
+  for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
+    await ctx.db.delete(item._id);
+  }
+  const hasMore = listItems.length > CACHE_MUTATION_BATCH_SIZE;
+  if (doc && !hasMore) {
+    await ctx.db.delete(doc._id);
+  }
+  return {
+    hasMore
+  };
+}
+async function getLiveCacheDoc(ctx, key, now) {
+  const doc = await findCacheDoc(ctx, key);
+  if (!doc) return { doc: null, hasMore: false };
+  if (doc.kind === "deleted") {
+    const cleanup2 = await deleteCacheKey(ctx, key);
+    return { doc: null, hasMore: cleanup2.hasMore };
+  }
+  if (!isExpired(doc, now)) return { doc, hasMore: false };
+  const cleanup = await deleteCacheKey(ctx, key);
+  return { doc: null, hasMore: cleanup.hasMore };
+}
+async function writeCacheDoc(ctx, key, existing, patch) {
+  if (existing) {
+    await ctx.db.patch(existing._id, patch);
+    return { ...existing, ...patch };
+  }
+  const _id = await ctx.db.insert(CACHE_TABLE, { key, ...patch });
+  return { _id, key, ...patch };
+}
+async function clearPrefix(ctx, keyPrefix) {
+  const [docs, orphanListItems] = await Promise.all([
+    ctx.db.query(CACHE_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(CACHE_MUTATION_BATCH_SIZE + 1),
+    ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(1)
+  ]);
+  if (docs.length > 0) {
+    for (const doc of docs.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
+      if (doc.kind === "list" || doc.kind === "deleted") {
+        const cleanup = await deleteCacheKey(ctx, doc.key);
+        return cleanup.hasMore || docs.length > 1 || orphanListItems.length > 0;
+      }
+      await ctx.db.delete(doc._id);
+    }
+    return docs.length > CACHE_MUTATION_BATCH_SIZE || orphanListItems.length > 0;
+  }
+  const listItems = await ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_prefix", (q) => q.eq("keyPrefix", keyPrefix)).take(CACHE_MUTATION_BATCH_SIZE + 1);
+  for (const item of listItems.slice(0, CACHE_MUTATION_BATCH_SIZE)) {
+    await ctx.db.delete(item._id);
+  }
+  return listItems.length > CACHE_MUTATION_BATCH_SIZE;
+}
+async function handleCacheOperation(ctx, request) {
+  const now = Date.now();
+  switch (request.op) {
+    case "get": {
+      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+      if (hasMore) return { ok: true, result: null, hasMore: true };
+      if (!doc || doc.kind !== "value") return { ok: true, result: null };
+      return { ok: true, result: decodeValue(doc.value ?? "null") };
+    }
+    case "set": {
+      let existing = await findCacheDoc(ctx, request.key);
+      if (existing && (isExpired(existing, now) || existing.kind !== "value")) {
+        const cleanup = await deleteCacheKey(ctx, request.key);
+        if (cleanup.hasMore) {
+          return { ok: true, hasMore: true };
+        }
+        existing = null;
+      }
+      await writeCacheDoc(ctx, request.key, existing, {
+        keyPrefix: request.keyPrefix,
+        kind: "value",
+        value: encodeValue(request.value),
+        expiresAt: request.expiresAt
+      });
+      return { ok: true };
+    }
+    case "listLength": {
+      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+      if (hasMore) return { ok: true, result: 0, hasMore: true };
+      if (!doc) return { ok: true, result: 0 };
+      if (doc.kind !== "list") return { ok: false, error: `${request.key} exists but is not an array` };
+      return { ok: true, result: doc.counter ?? 0 };
+    }
+    case "listPush": {
+      let existing = await findCacheDoc(ctx, request.key);
+      if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
+        const cleanup = await deleteCacheKey(ctx, request.key);
+        if (cleanup.hasMore) {
+          return { ok: true, hasMore: true };
+        }
+        existing = null;
+      }
+      if (existing && existing.kind !== "list") {
+        return { ok: false, error: `${request.key} exists but is not an array` };
+      }
+      const doc = existing ? await writeCacheDoc(ctx, request.key, existing, {
+        kind: "list",
+        keyPrefix: request.keyPrefix,
+        counter: (existing.counter ?? 0) + 1,
+        expiresAt: request.expiresAt
+      }) : await writeCacheDoc(ctx, request.key, null, {
+        kind: "list",
+        keyPrefix: request.keyPrefix,
+        counter: 1,
+        expiresAt: request.expiresAt
+      });
+      await ctx.db.insert(CACHE_LIST_TABLE, {
+        key: request.key,
+        keyPrefix: request.keyPrefix,
+        index: (doc.counter ?? 1) - 1,
+        value: encodeValue(request.value)
+      });
+      return { ok: true };
+    }
+    case "listFromTo": {
+      const { doc, hasMore } = await getLiveCacheDoc(ctx, request.key, now);
+      if (hasMore) return { ok: true, result: [], hasMore: true };
+      if (!doc || doc.kind !== "list") return { ok: true, result: [] };
+      const range = normalizeListRange(request.from, request.to, doc.counter ?? 0);
+      if (!range) return { ok: true, result: [] };
+      const query = ctx.db.query(CACHE_LIST_TABLE).withIndex("by_key_index", (q) => {
+        return q.eq("key", request.key).gte("index", range.from).lte("index", range.to);
+      });
+      const items = await query.collect();
+      return { ok: true, result: items.map((item) => decodeValue(item.value)) };
+    }
+    case "delete": {
+      const cleanup = await deleteCacheKey(ctx, request.key);
+      return { ok: true, hasMore: cleanup.hasMore };
+    }
+    case "clear": {
+      const hasMore = await clearPrefix(ctx, request.keyPrefix);
+      return { ok: true, hasMore };
+    }
+    case "increment": {
+      let existing = await findCacheDoc(ctx, request.key);
+      if (existing && (isExpired(existing, now) || existing.kind === "deleted")) {
+        const cleanup = await deleteCacheKey(ctx, request.key);
+        if (cleanup.hasMore) {
+          return { ok: true, hasMore: true };
+        }
+        existing = null;
+      }
+      if (existing && existing.kind !== "counter") {
+        return { ok: false, error: `${request.key} exists but is not a number` };
+      }
+      const nextCounter = (existing?.counter ?? 0) + 1;
+      await writeCacheDoc(ctx, request.key, existing, {
+        kind: "counter",
+        keyPrefix: request.keyPrefix,
+        counter: nextCounter,
+        expiresAt: request.expiresAt
+      });
+      return { ok: true, result: nextCounter };
+    }
+  }
+  return { ok: false, error: `Unsupported operation ${request.op}` };
+}
+var mastraCache = server.mutationGeneric(
+  async (ctx, request) => handleCacheOperation(ctx, request)
+);
+
+// src/server/index-map.ts
+var TABLE_INDEX_MAP = {
+  mastra_messages: [
+    { name: "by_thread_created", fields: ["thread_id", "createdAt"] },
+    { name: "by_thread", fields: ["thread_id"] },
+    { name: "by_resource", fields: ["resourceId"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_threads: [
+    { name: "by_resource", fields: ["resourceId"] },
+    { name: "by_created", fields: ["createdAt"] },
+    { name: "by_updated", fields: ["updatedAt"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_resources: [
+    { name: "by_updated", fields: ["updatedAt"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_workflow_snapshots: [
+    { name: "by_workflow_run", fields: ["workflow_name", "run_id"] },
+    { name: "by_workflow", fields: ["workflow_name"] },
+    { name: "by_resource", fields: ["resourceId"] },
+    { name: "by_created", fields: ["createdAt"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_scorers: [
+    { name: "by_entity", fields: ["entityId", "entityType"] },
+    { name: "by_scorer", fields: ["scorerId"] },
+    { name: "by_run", fields: ["runId"] },
+    { name: "by_created", fields: ["createdAt"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_vector_indexes: [
+    { name: "by_name", fields: ["indexName"] },
+    { name: "by_record_id", fields: ["id"] }
+  ]
+};
+function findBestIndex(convexTable, filters) {
+  const indexes = TABLE_INDEX_MAP[convexTable];
+  if (!indexes || filters.length === 0) return null;
+  const filtersByField = /* @__PURE__ */ new Map();
+  for (const f of filters) {
+    filtersByField.set(f.field, f);
+  }
+  let best = null;
+  for (const index of indexes) {
+    let prefixLength = 0;
+    const indexedFilters = [];
+    for (const field of index.fields) {
+      const filter = filtersByField.get(field);
+      if (filter) {
+        prefixLength++;
+        indexedFilters.push(filter);
+      } else {
+        break;
+      }
+    }
+    if (prefixLength > 0 && (!best || prefixLength > best.prefixLength)) {
+      best = { indexName: index.name, indexedFilters, prefixLength };
+    }
+  }
+  return best ? { indexName: best.indexName, indexedFilters: best.indexedFilters } : null;
+}
+
+// src/server/storage.ts
+var TABLE_VECTOR_INDEXES = "mastra_vector_indexes";
+var VECTOR_TABLE_PREFIX = "mastra_vector_";
+var CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
+var STORAGE_MUTATION_BATCH_SIZE = 25;
+async function mapInBatches(inputs, batchSize, mapper) {
+  const results = [];
+  for (let index = 0; index < inputs.length; index += batchSize) {
+    results.push(...await Promise.all(inputs.slice(index, index + batchSize).map(mapper)));
+  }
+  return results;
+}
+async function deleteDocs(ctx, docs) {
+  await mapInBatches(docs, STORAGE_MUTATION_BATCH_SIZE, (doc) => ctx.db.delete(doc._id));
+}
+async function findExistingDocsByIds(ids, findDoc) {
+  const docs = await mapInBatches([...new Set(ids)], STORAGE_MUTATION_BATCH_SIZE, findDoc);
+  return docs.filter((doc) => Boolean(doc));
+}
+function coalesceTypedRecordsForBatchInsert(records) {
+  const recordsById = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const id = record.id;
+    if (!id) continue;
+    const key = String(id);
+    recordsById.set(key, { ...recordsById.get(key) ?? {}, ...record });
+  }
+  return [...recordsById.values()];
+}
+function coalesceLastRecordById(records) {
+  const recordsById = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    const id = record.id;
+    if (!id) continue;
+    recordsById.set(String(id), record);
+  }
+  return [...recordsById.values()];
+}
+function resolveTable(tableName) {
+  switch (tableName) {
+    case constants.TABLE_THREADS:
+      return { convexTable: "mastra_threads", isTyped: true };
+    case constants.TABLE_MESSAGES:
+      return { convexTable: "mastra_messages", isTyped: true };
+    case constants.TABLE_RESOURCES:
+      return { convexTable: "mastra_resources", isTyped: true };
+    case constants.TABLE_WORKFLOW_SNAPSHOT:
+      return { convexTable: CONVEX_TABLE_WORKFLOW_SNAPSHOTS, isTyped: true };
+    case constants.TABLE_SCORERS:
+      return { convexTable: "mastra_scorers", isTyped: true };
+    case TABLE_VECTOR_INDEXES:
+      return { convexTable: "mastra_vector_indexes", isTyped: true };
+    default:
+      if (tableName.startsWith(VECTOR_TABLE_PREFIX)) {
+        return { convexTable: "mastra_vectors", isTyped: true };
+      }
+      return { convexTable: "mastra_documents", isTyped: false };
+  }
+}
+var mastraStorage = server.mutationGeneric(async (ctx, request) => {
+  try {
+    const { convexTable, isTyped } = resolveTable(request.tableName);
+    if (request.tableName.startsWith(VECTOR_TABLE_PREFIX) && request.tableName !== TABLE_VECTOR_INDEXES) {
+      return handleVectorOperation(ctx, request);
+    }
+    if (isTyped) {
+      return handleTypedOperation(ctx, convexTable, request);
+    }
+    return handleGenericOperation(ctx, request);
+  } catch (error) {
+    const err = error;
+    return {
+      ok: false,
+      error: err.message
+    };
+  }
+});
+async function handleTypedOperation(ctx, convexTable, request) {
+  switch (request.op) {
+    case "insert": {
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Record is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+      if (existing) {
+        const { id: _, ...updateData } = record;
+        await ctx.db.patch(existing._id, updateData);
+      } else {
+        await ctx.db.insert(convexTable, record);
+      }
+      return { ok: true };
+    }
+    case "batchInsert": {
+      const records = coalesceTypedRecordsForBatchInsert(request.records);
+      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+        const id = record.id;
+        const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+        if (existing) {
+          const { id: _, ...updateData } = record;
+          await ctx.db.patch(existing._id, updateData);
+        } else {
+          await ctx.db.insert(convexTable, record);
+        }
+      });
+      return { ok: true };
+    }
+    case "load": {
+      const keys = request.keys;
+      if (keys.id) {
+        const doc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", keys.id)).unique();
+        return { ok: true, result: doc || null };
+      }
+      if (convexTable === CONVEX_TABLE_WORKFLOW_SNAPSHOTS && typeof keys.workflow_name === "string" && typeof keys.run_id === "string") {
+        const doc = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", keys.workflow_name).eq("run_id", keys.run_id)).unique();
+        return { ok: true, result: doc || null };
+      }
+      const docs = await ctx.db.query(convexTable).take(1e4);
+      const match = docs.find((doc) => Object.entries(keys).every(([key, value]) => doc[key] === value));
+      return { ok: true, result: match || null };
+    }
+    case "queryTable": {
+      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+      let docs;
+      if (request.indexHint) {
+        const hint = request.indexHint;
+        if (hint.index === "by_workflow") {
+          docs = await ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName)).take(maxDocs);
+        } else if (hint.index === "by_workflow_run") {
+          docs = await ctx.db.query(convexTable).withIndex("by_workflow_run", (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId)).take(maxDocs);
+        } else {
+          docs = await ctx.db.query(convexTable).take(maxDocs);
+        }
+      } else if (request.filters && request.filters.length > 0) {
+        const match = findBestIndex(convexTable, request.filters);
+        if (match) {
+          docs = await ctx.db.query(convexTable).withIndex(match.indexName, (q) => {
+            let builder = q;
+            for (const filter of match.indexedFilters) {
+              builder = builder.eq(filter.field, filter.value);
+            }
+            return builder;
+          }).take(maxDocs);
+        } else {
+          docs = await ctx.db.query(convexTable).take(maxDocs);
+        }
+      } else {
+        docs = await ctx.db.query(convexTable).take(maxDocs);
+      }
+      if (request.filters && request.filters.length > 0) {
+        docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+      }
+      if (request.limit) {
+        docs = docs.slice(0, request.limit);
+      }
+      return { ok: true, result: docs };
+    }
+    case "clearTable":
+    case "dropTable": {
+      const docs = await ctx.db.query(convexTable).take(STORAGE_MUTATION_BATCH_SIZE + 1);
+      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true, hasMore };
+    }
+    case "deleteMany": {
+      const docsToDelete = await findExistingDocsByIds(
+        request.ids,
+        (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()
+      );
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true };
+    }
+    default:
+      return { ok: false, error: `Unsupported operation ${request.op}` };
+  }
+}
+async function handleVectorOperation(ctx, request) {
+  const indexName = request.tableName.replace(VECTOR_TABLE_PREFIX, "");
+  const convexTable = "mastra_vectors";
+  switch (request.op) {
+    case "insert": {
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Vector record is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
+      if (existing) {
+        await ctx.db.patch(existing._id, {
+          embedding: record.embedding,
+          metadata: record.metadata
+        });
+      } else {
+        await ctx.db.insert(convexTable, {
+          id,
+          indexName,
+          embedding: record.embedding,
+          metadata: record.metadata
+        });
+      }
+      return { ok: true };
+    }
+    case "batchInsert": {
+      const records = coalesceLastRecordById(request.records);
+      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+        const id = record.id;
+        const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique();
+        if (existing) {
+          await ctx.db.patch(existing._id, {
+            embedding: record.embedding,
+            metadata: record.metadata
+          });
+        } else {
+          await ctx.db.insert(convexTable, {
+            id,
+            indexName,
+            embedding: record.embedding,
+            metadata: record.metadata
+          });
+        }
+      });
+      return { ok: true };
+    }
+    case "load": {
+      const keys = request.keys;
+      if (keys.id) {
+        const doc = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", keys.id)).unique();
+        return { ok: true, result: doc || null };
+      }
+      return { ok: true, result: null };
+    }
+    case "queryTable": {
+      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+      let docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(maxDocs);
+      if (request.filters && request.filters.length > 0) {
+        docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+      }
+      if (request.limit) {
+        docs = docs.slice(0, request.limit);
+      }
+      return { ok: true, result: docs };
+    }
+    case "clearTable":
+    case "dropTable": {
+      const docs = await ctx.db.query(convexTable).withIndex("by_index", (q) => q.eq("indexName", indexName)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
+      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true, hasMore };
+    }
+    case "deleteMany": {
+      const docsToDelete = await findExistingDocsByIds(
+        request.ids,
+        (id) => (
+          // Use composite key (indexName, id) to scope deletion per index
+          ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", id)).unique()
+        )
+      );
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true };
+    }
+    default:
+      return { ok: false, error: `Unsupported operation ${request.op}` };
+  }
+}
+async function handleGenericOperation(ctx, request) {
+  const tableName = request.tableName;
+  const convexTable = "mastra_documents";
+  switch (request.op) {
+    case "insert": {
+      const record = request.record;
+      if (!record.id) {
+        throw new Error(`Record for table ${tableName} is missing an id`);
+      }
+      const primaryKey = String(record.id);
+      const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
+      if (existing) {
+        await ctx.db.patch(existing._id, { record });
+      } else {
+        await ctx.db.insert(convexTable, {
+          table: tableName,
+          primaryKey,
+          record
+        });
+      }
+      return { ok: true };
+    }
+    case "batchInsert": {
+      const records = coalesceLastRecordById(request.records);
+      await mapInBatches(records, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+        const primaryKey = String(record.id);
+        const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", primaryKey)).unique();
+        if (existing) {
+          await ctx.db.patch(existing._id, { record });
+        } else {
+          await ctx.db.insert(convexTable, {
+            table: tableName,
+            primaryKey,
+            record
+          });
+        }
+      });
+      return { ok: true };
+    }
+    case "load": {
+      const keys = request.keys;
+      if (keys.id) {
+        const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(keys.id))).unique();
+        return { ok: true, result: existing ? existing.record : null };
+      }
+      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(1e4);
+      const match = docs.find((doc) => Object.entries(keys).every(([key, value]) => doc.record?.[key] === value));
+      return { ok: true, result: match ? match.record : null };
+    }
+    case "queryTable": {
+      const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
+      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(maxDocs);
+      let records = docs.map((doc) => doc.record);
+      if (request.filters && request.filters.length > 0) {
+        records = records.filter(
+          (record) => request.filters.every((filter) => record?.[filter.field] === filter.value)
+        );
+      }
+      if (request.limit) {
+        records = records.slice(0, request.limit);
+      }
+      return { ok: true, result: records };
+    }
+    case "clearTable":
+    case "dropTable": {
+      const docs = await ctx.db.query(convexTable).withIndex("by_table", (q) => q.eq("table", tableName)).take(STORAGE_MUTATION_BATCH_SIZE + 1);
+      const hasMore = docs.length > STORAGE_MUTATION_BATCH_SIZE;
+      const docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true, hasMore };
+    }
+    case "deleteMany": {
+      const docsToDelete = await findExistingDocsByIds(
+        request.ids,
+        (id) => ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique()
+      );
+      await deleteDocs(ctx, docsToDelete);
+      return { ok: true };
+    }
+    default:
+      return { ok: false, error: `Unsupported operation ${request.op}` };
+  }
+}
+var DEFAULT_ID_FIELD = "id";
+var DEFAULT_ID_INDEX = "by_record_id";
+var DEFAULT_VECTOR_FIELD = "embedding";
+var DEFAULT_METADATA_FIELD = "metadata";
+var NATIVE_VECTOR_BATCH_SIZE = 25;
+var MAX_CONVEX_VECTOR_RESULTS = 256;
+var nativeVectorFilterValueValidator = values.v.union(values.v.string(), values.v.number(), values.v.boolean(), values.v.null());
+var nativeVectorFilterClauseValidator = values.v.object({
+  field: values.v.string(),
+  value: nativeVectorFilterValueValidator
+});
+var nativeVectorFilterValidator = values.v.union(
+  nativeVectorFilterClauseValidator,
+  values.v.object({ $or: values.v.array(nativeVectorFilterClauseValidator) })
+);
+var nativeVectorIndexConfigValidator = values.v.object({
+  tableName: values.v.string(),
+  vectorIndexName: values.v.string(),
+  dimension: values.v.optional(values.v.number()),
+  idField: values.v.optional(values.v.string()),
+  idIndexName: values.v.optional(values.v.string()),
+  vectorField: values.v.optional(values.v.string()),
+  metadataField: values.v.optional(values.v.string()),
+  filterFields: values.v.optional(values.v.array(values.v.string()))
+});
+function idField(config) {
+  return config.idField ?? DEFAULT_ID_FIELD;
+}
+function idIndexName(config) {
+  return config.idIndexName ?? DEFAULT_ID_INDEX;
+}
+function vectorField(config) {
+  return config.vectorField ?? DEFAULT_VECTOR_FIELD;
+}
+function metadataField(config) {
+  return config.metadataField ?? DEFAULT_METADATA_FIELD;
+}
+function asTableName(tableName) {
+  return tableName;
+}
+function asConvexId(id) {
+  return id;
+}
+function pickFilterFields(metadata, filterFields) {
+  const fields = {};
+  if (!metadata || !filterFields) return fields;
+  for (const field of filterFields) {
+    const value = metadata[field];
+    if (value !== void 0) {
+      fields[field] = value;
+    }
+  }
+  return fields;
+}
+function isMetadataRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateMetadataArray(metadata, idsLength) {
+  if (metadata === void 0) return void 0;
+  if (!Array.isArray(metadata)) {
+    throw new Error("Native vector upsert: metadata must be an array matching ids when provided");
+  }
+  if (metadata.length !== idsLength) {
+    throw new Error(`Native vector upsert: metadata length (${metadata.length}) must match ids length (${idsLength})`);
+  }
+  if (!metadata.every(isMetadataRecord)) {
+    throw new Error("Native vector upsert: metadata entries must be objects when provided");
+  }
+  return metadata;
+}
+function validateMetadataRecord(metadata) {
+  if (metadata === void 0) return void 0;
+  if (!isMetadataRecord(metadata)) {
+    throw new Error("Native vector update: metadata must be an object when provided");
+  }
+  return metadata;
+}
+function clearMissingFilterFields(patch, metadata, filterFields) {
+  if (!filterFields) return;
+  for (const field of filterFields) {
+    if (metadata[field] === void 0) {
+      patch[field] = void 0;
+    }
+  }
+}
+function omitVectorField(doc, config) {
+  const { [vectorField(config)]: _, ...docWithoutVector } = doc;
+  return docWithoutVector;
+}
+function buildRecord({
+  config,
+  id,
+  vector,
+  metadata
+}) {
+  return {
+    [idField(config)]: id,
+    [vectorField(config)]: vector,
+    ...metadata !== void 0 ? { [metadataField(config)]: metadata } : {},
+    ...pickFilterFields(metadata, config.filterFields)
+  };
+}
+async function findByRecordId(ctx, config, id) {
+  return ctx.db.query(asTableName(config.tableName)).withIndex(idIndexName(config), (q) => q.eq(idField(config), id)).unique();
+}
+async function mapInBatches2(inputs, mapper) {
+  const results = [];
+  for (let index = 0; index < inputs.length; index += NATIVE_VECTOR_BATCH_SIZE) {
+    results.push(
+      ...await Promise.all(
+        inputs.slice(index, index + NATIVE_VECTOR_BATCH_SIZE).map((input, batchIndex) => mapper(input, index + batchIndex))
+      )
+    );
+  }
+  return results;
+}
+function buildVectorFilter(q, filter) {
+  if (!filter) return void 0;
+  if ("$or" in filter) {
+    return q.or(...filter.$or.map((clause) => q.eq(clause.field, clause.value)));
+  }
+  return q.eq(filter.field, filter.value);
+}
+var mastraNativeVectorAction = server.actionGeneric({
+  args: {
+    config: nativeVectorIndexConfigValidator,
+    vector: values.v.array(values.v.number()),
+    limit: values.v.optional(values.v.number()),
+    filter: values.v.optional(nativeVectorFilterValidator)
+  },
+  handler: async (ctx, args) => {
+    const config = args.config;
+    const limit = args.limit;
+    const filter = args.filter;
+    if (limit !== void 0 && (!Number.isInteger(limit) || limit < 1 || limit > MAX_CONVEX_VECTOR_RESULTS)) {
+      throw new Error(`Native vector query: limit must be an integer between 1 and ${MAX_CONVEX_VECTOR_RESULTS}`);
+    }
+    const results = await ctx.vectorSearch(asTableName(config.tableName), config.vectorIndexName, {
+      vector: args.vector,
+      ...limit !== void 0 ? { limit } : {},
+      ...filter ? { filter: (q) => buildVectorFilter(q, filter) } : {}
+    });
+    return results.map((result) => ({
+      id: String(result._id),
+      score: result._score
+    }));
+  }
+});
+var mastraNativeVectorQuery = server.queryGeneric({
+  args: {
+    op: values.v.union(values.v.literal("getByConvexIds"), values.v.literal("describe"), values.v.literal("listByIds")),
+    config: nativeVectorIndexConfigValidator,
+    ids: values.v.optional(values.v.array(values.v.string())),
+    includeVector: values.v.optional(values.v.boolean()),
+    countLimit: values.v.optional(values.v.number())
+  },
+  handler: async (ctx, args) => {
+    const config = args.config;
+    switch (args.op) {
+      case "getByConvexIds": {
+        const ids = args.ids;
+        if (!ids) {
+          throw new Error("Native vector query: ids are required");
+        }
+        const includeVector = args.includeVector === true;
+        const docs = await mapInBatches2(ids, (id) => ctx.db.get(asConvexId(id)));
+        return docs.filter((doc) => Boolean(doc)).map((doc) => includeVector ? doc : omitVectorField(doc, config));
+      }
+      case "describe": {
+        const limit = Math.max(1, Math.min(args.countLimit ?? 1e4, 1e4));
+        const docs = await ctx.db.query(asTableName(config.tableName)).take(limit + 1);
+        return {
+          count: Math.min(docs.length, limit),
+          countIsLimited: docs.length > limit
+        };
+      }
+      case "listByIds": {
+        const ids = args.ids;
+        if (!ids) {
+          throw new Error("Native vector query: ids are required");
+        }
+        return mapInBatches2(ids, (id) => findByRecordId(ctx, config, id));
+      }
+      default:
+        throw new Error(`Unsupported native vector query operation: ${args.op}`);
+    }
+  }
+});
+var mastraNativeVectorMutation = server.mutationGeneric({
+  args: {
+    op: values.v.union(values.v.literal("upsert"), values.v.literal("updateById"), values.v.literal("deleteByIds")),
+    config: nativeVectorIndexConfigValidator,
+    ids: values.v.optional(values.v.array(values.v.string())),
+    vectors: values.v.optional(values.v.array(values.v.array(values.v.number()))),
+    metadata: values.v.optional(values.v.any()),
+    id: values.v.optional(values.v.string()),
+    vector: values.v.optional(values.v.array(values.v.number()))
+  },
+  handler: async (ctx, args) => {
+    const config = args.config;
+    switch (args.op) {
+      case "upsert": {
+        const ids = args.ids;
+        const vectors = args.vectors;
+        if (!ids || !vectors) {
+          throw new Error("Native vector upsert: ids and vectors are required");
+        }
+        if (vectors.length !== ids.length) {
+          throw new Error(
+            `Native vector upsert: vectors length (${vectors.length}) must match ids length (${ids.length})`
+          );
+        }
+        const metadata = validateMetadataArray(args.metadata, ids.length);
+        if (new Set(ids).size !== ids.length) {
+          throw new Error("Native vector upsert: ids must be unique");
+        }
+        await mapInBatches2(ids, async (id, index) => {
+          const record = buildRecord({
+            config,
+            id,
+            vector: vectors[index],
+            metadata: metadata?.[index]
+          });
+          const existing = await findByRecordId(ctx, config, id);
+          if (existing?._id) {
+            const { _id: _, _creationTime: __, ...patch } = record;
+            if (metadata?.[index] !== void 0) {
+              clearMissingFilterFields(patch, metadata[index], config.filterFields);
+            }
+            await ctx.db.patch(existing._id, patch);
+          } else {
+            await ctx.db.insert(asTableName(config.tableName), record);
+          }
+        });
+        return { ok: true };
+      }
+      case "updateById": {
+        if (!args.id) {
+          throw new Error("Native vector update: id is required");
+        }
+        const existing = await findByRecordId(ctx, config, args.id);
+        if (!existing?._id) return { ok: true };
+        const patch = {};
+        if (args.vector) patch[vectorField(config)] = args.vector;
+        const metadata = validateMetadataRecord(args.metadata);
+        if (metadata !== void 0) {
+          const existingMetadata = isMetadataRecord(existing[metadataField(config)]) ? existing[metadataField(config)] : {};
+          patch[metadataField(config)] = { ...existingMetadata, ...metadata };
+          Object.assign(patch, pickFilterFields(patch[metadataField(config)], config.filterFields));
+        }
+        if (Object.keys(patch).length > 0) {
+          await ctx.db.patch(existing._id, patch);
+        }
+        return { ok: true };
+      }
+      case "deleteByIds": {
+        const ids = args.ids;
+        if (!ids) {
+          throw new Error("Native vector deleteByIds: ids are required");
+        }
+        const docs = await mapInBatches2(ids, (id) => findByRecordId(ctx, config, id));
+        await mapInBatches2(
+          docs.filter((doc) => Boolean(doc?._id)),
+          (doc) => ctx.db.delete(doc._id)
+        );
+        return { ok: true };
+      }
+      default:
+        throw new Error(`Unsupported native vector mutation operation: ${args.op}`);
+    }
+  }
+});
+
+exports.mastraCache = mastraCache;
+exports.mastraNativeVectorAction = mastraNativeVectorAction;
+exports.mastraNativeVectorMutation = mastraNativeVectorMutation;
+exports.mastraNativeVectorQuery = mastraNativeVectorQuery;
+exports.mastraStorage = mastraStorage;
+//# sourceMappingURL=chunk-EEELVBWO.cjs.map
+//# sourceMappingURL=chunk-EEELVBWO.cjs.map