@mastra/convex 1.1.0 → 1.2.0-alpha.0

package/dist/{chunk-EEELVBWO.cjs → chunk-ORSDZTO4.cjs}

@@ -229,6 +229,41 @@ var TABLE_INDEX_MAP = {
     { name: "by_created", fields: ["createdAt"] },
     { name: "by_record_id", fields: ["id"] }
   ],
+  mastra_schedules: [
+    { name: "by_workflow_status", fields: ["workflow_id", "status"] },
+    { name: "by_workflow_id", fields: ["workflow_id"] },
+    { name: "by_owner", fields: ["owner_type", "owner_id"] },
+    { name: "by_owner_id", fields: ["owner_id"] },
+    { name: "by_status_next_fire_at", fields: ["status", "next_fire_at"] },
+    { name: "by_created", fields: ["created_at"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_schedule_triggers: [
+    { name: "by_schedule_actual", fields: ["schedule_id", "actual_fire_at"] },
+    { name: "by_parent_trigger", fields: ["parent_trigger_id"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_channel_installations: [
+    { name: "by_platform_agent", fields: ["platform", "agentId"] },
+    { name: "by_webhook", fields: ["webhookId"] },
+    { name: "by_platform", fields: ["platform"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_channel_config: [
+    { name: "by_platform", fields: ["platform"] },
+    { name: "by_record_id", fields: ["id"] }
+  ],
+  mastra_background_tasks: [
+    { name: "by_agent_status", fields: ["agent_id", "status"] },
+    { name: "by_status_created", fields: ["status", "createdAt"] },
+    { name: "by_run", fields: ["run_id"] },
+    { name: "by_tool_call", fields: ["tool_call_id"] },
+    { name: "by_thread", fields: ["thread_id"] },
+    { name: "by_resource", fields: ["resource_id"] },
+    { name: "by_tool", fields: ["tool_name"] },
+    { 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"] }
@@ -265,7 +300,44 @@ function findBestIndex(convexTable, filters) {
 var TABLE_VECTOR_INDEXES = "mastra_vector_indexes";
 var VECTOR_TABLE_PREFIX = "mastra_vector_";
 var CONVEX_TABLE_WORKFLOW_SNAPSHOTS = "mastra_workflow_snapshots";
+var CONVEX_TABLE_BACKGROUND_TASKS = "mastra_background_tasks";
+var CONVEX_TABLE_DOCUMENTS = "mastra_documents";
 var STORAGE_MUTATION_BATCH_SIZE = 25;
+var DEFAULT_SCHEDULE_QUERY_LIMIT = 100;
+var BACKGROUND_TASK_FIELD_ALIASES = {
+  tool_call_id: "toolCallId",
+  toolCallId: "tool_call_id",
+  tool_name: "toolName",
+  toolName: "tool_name",
+  agent_id: "agentId",
+  agentId: "agent_id",
+  run_id: "runId",
+  runId: "run_id",
+  thread_id: "threadId",
+  threadId: "thread_id",
+  resource_id: "resourceId",
+  resourceId: "resource_id",
+  suspend_payload: "suspendPayload",
+  suspendPayload: "suspend_payload",
+  retry_count: "retryCount",
+  retryCount: "retry_count",
+  max_retries: "maxRetries",
+  maxRetries: "max_retries",
+  timeout_ms: "timeoutMs",
+  timeoutMs: "timeout_ms"
+};
+function normalizeScheduleQueryLimit(limit) {
+  if (limit == null || !Number.isFinite(limit)) return DEFAULT_SCHEDULE_QUERY_LIMIT;
+  return Math.max(0, Math.floor(limit));
+}
+function applyConvexEqualityFilters(query, filters, indexedFields = /* @__PURE__ */ new Set()) {
+  const remainingFilters = filters?.filter((filter) => !indexedFields.has(filter.field));
+  if (!remainingFilters?.length) return query;
+  return query.filter((q) => {
+    const predicates = remainingFilters.map((filter) => q.eq(q.field(filter.field), filter.value));
+    return predicates.length === 1 ? predicates[0] : q.and(...predicates);
+  });
+}
 async function mapInBatches(inputs, batchSize, mapper) {
   const results = [];
   for (let index = 0; index < inputs.length; index += batchSize) {
@@ -280,6 +352,58 @@ async function findExistingDocsByIds(ids, findDoc) {
   const docs = await mapInBatches([...new Set(ids)], STORAGE_MUTATION_BATCH_SIZE, findDoc);
   return docs.filter((doc) => Boolean(doc));
 }
+function isBackgroundTasksTable(convexTable, request) {
+  return convexTable === CONVEX_TABLE_BACKGROUND_TASKS && request.tableName === constants.TABLE_BACKGROUND_TASKS;
+}
+function matchesFilters(record, filters) {
+  return filters.every((filter) => {
+    if (record[filter.field] === filter.value) return true;
+    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[filter.field];
+    return alternateField ? record[alternateField] === filter.value : false;
+  });
+}
+function mergeLegacyRecord(record, patch) {
+  const merged = { ...record };
+  for (const [field, value] of Object.entries(patch)) {
+    const alternateField = BACKGROUND_TASK_FIELD_ALIASES[field];
+    if (alternateField) delete merged[alternateField];
+    merged[field] = value;
+  }
+  return merged;
+}
+function stripPatchKeys(record, keys) {
+  const stripped = { ...record };
+  for (const key of keys) delete stripped[key];
+  return stripped;
+}
+function dedupeByRecordId(records) {
+  const seen = /* @__PURE__ */ new Set();
+  return records.filter((record) => {
+    if (record?.id == null) return true;
+    const id = String(record.id);
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+function isMissingBackgroundTaskSchemaError(error) {
+  const message = error instanceof Error ? error.message.toLowerCase() : String(error).toLowerCase();
+  return message.includes(CONVEX_TABLE_BACKGROUND_TASKS) && (message.includes("does not exist") || message.includes("not found") || message.includes("not defined") || message.includes("no such"));
+}
+async function findGenericDocumentById(ctx, tableName, id) {
+  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(id))).unique();
+}
+async function findGenericDocumentsByTable(ctx, tableName, limit) {
+  return await ctx.db.query(CONVEX_TABLE_DOCUMENTS).withIndex("by_table", (q) => q.eq("table", tableName)).take(limit);
+}
+async function filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords) {
+  const records = await mapInBatches(legacyRecords, STORAGE_MUTATION_BATCH_SIZE, async (record) => {
+    if (record.id == null) return record;
+    const typedDoc = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", String(record.id))).unique();
+    return typedDoc ? null : record;
+  });
+  return records.filter((record) => Boolean(record));
+}
 function coalesceTypedRecordsForBatchInsert(records) {
   const recordsById = /* @__PURE__ */ new Map();
   for (const record of records) {
@@ -311,6 +435,16 @@ function resolveTable(tableName) {
       return { convexTable: CONVEX_TABLE_WORKFLOW_SNAPSHOTS, isTyped: true };
     case constants.TABLE_SCORERS:
       return { convexTable: "mastra_scorers", isTyped: true };
+    case constants.TABLE_SCHEDULES:
+      return { convexTable: "mastra_schedules", isTyped: true };
+    case constants.TABLE_SCHEDULE_TRIGGERS:
+      return { convexTable: "mastra_schedule_triggers", isTyped: true };
+    case constants.TABLE_CHANNEL_INSTALLATIONS:
+      return { convexTable: "mastra_channel_installations", isTyped: true };
+    case constants.TABLE_CHANNEL_CONFIG:
+      return { convexTable: "mastra_channel_config", isTyped: true };
+    case constants.TABLE_BACKGROUND_TASKS:
+      return { convexTable: CONVEX_TABLE_BACKGROUND_TASKS, isTyped: true };
     case TABLE_VECTOR_INDEXES:
       return { convexTable: "mastra_vector_indexes", isTyped: true };
     default:
@@ -327,6 +461,14 @@ var mastraStorage = server.mutationGeneric(async (ctx, request) => {
       return handleVectorOperation(ctx, request);
     }
     if (isTyped) {
+      if (isBackgroundTasksTable(convexTable, request)) {
+        try {
+          return await handleTypedOperation(ctx, convexTable, request);
+        } catch (error) {
+          if (!isMissingBackgroundTaskSchemaError(error)) throw error;
+          return handleGenericOperation(ctx, request);
+        }
+      }
       return handleTypedOperation(ctx, convexTable, request);
     }
     return handleGenericOperation(ctx, request);
@@ -340,6 +482,100 @@ var mastraStorage = server.mutationGeneric(async (ctx, request) => {
 });
 async function handleTypedOperation(ctx, convexTable, request) {
   switch (request.op) {
+    case "createSchedule": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`createSchedule is only supported for mastra_schedules`);
+      }
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Schedule is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+      if (existing) {
+        throw new Error(`Schedule with id "${id}" already exists`);
+      }
+      await ctx.db.insert(convexTable, record);
+      return { ok: true };
+    }
+    case "recordScheduleTrigger": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`recordScheduleTrigger is only supported for mastra_schedule_triggers`);
+      }
+      const record = request.record;
+      const id = record.id;
+      if (!id) {
+        throw new Error(`Schedule trigger is missing an id`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique();
+      if (existing) {
+        throw new Error(`Schedule trigger with id "${id}" already exists`);
+      }
+      await ctx.db.insert(convexTable, record);
+      return { ok: true };
+    }
+    case "listDueSchedules": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`listDueSchedules is only supported for mastra_schedules`);
+      }
+      const query = ctx.db.query(convexTable).withIndex("by_status_next_fire_at", (q) => q.eq("status", "active").lte("next_fire_at", request.now));
+      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
+      return { ok: true, result: docs };
+    }
+    case "updateScheduleNextFire": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`updateScheduleNextFire is only supported for mastra_schedules`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing || existing.status !== "active" || existing.next_fire_at !== request.expectedNextFireAt) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, {
+        next_fire_at: request.newNextFireAt,
+        last_fire_at: request.lastFireAt,
+        last_run_id: request.lastRunId,
+        updated_at: Date.now()
+      });
+      return { ok: true, result: true };
+    }
+    case "updateSchedule": {
+      if (convexTable !== "mastra_schedules") {
+        throw new Error(`updateSchedule is only supported for mastra_schedules`);
+      }
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing) {
+        throw new Error(`Schedule ${request.id} not found`);
+      }
+      await ctx.db.patch(existing._id, request.patch);
+      return { ok: true, result: { ...existing, ...request.patch } };
+    }
+    case "listScheduleTriggers": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`listScheduleTriggers is only supported for mastra_schedule_triggers`);
+      }
+      const query = ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => {
+        let builder = q.eq("schedule_id", request.scheduleId);
+        if (request.fromActualFireAt != null) {
+          builder = builder.gte("actual_fire_at", request.fromActualFireAt);
+        }
+        if (request.toActualFireAt != null) {
+          builder = builder.lt("actual_fire_at", request.toActualFireAt);
+        }
+        return builder;
+      }).order("desc");
+      const docs = await query.take(normalizeScheduleQueryLimit(request.limit));
+      return { ok: true, result: docs };
+    }
+    case "deleteScheduleTriggers": {
+      if (convexTable !== "mastra_schedule_triggers") {
+        throw new Error(`deleteScheduleTriggers is only supported for mastra_schedule_triggers`);
+      }
+      const docs = await ctx.db.query(convexTable).withIndex("by_schedule_actual", (q) => q.eq("schedule_id", request.scheduleId)).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 "insert": {
       const record = request.record;
       const id = record.id;
@@ -369,10 +605,36 @@ async function handleTypedOperation(ctx, convexTable, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", request.id)).unique();
+      if (!existing) {
+        if (isBackgroundTasksTable(convexTable, request)) {
+          const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+          if (legacy) {
+            await ctx.db.patch(legacy._id, { record: mergeLegacyRecord(legacy.record, patchRecord) });
+            return { ok: true, result: true };
+          }
+        }
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, patchRecord);
+      if (isBackgroundTasksTable(convexTable, request)) {
+        const legacy = await findGenericDocumentById(ctx, request.tableName, request.id);
+        if (legacy) {
+          await ctx.db.delete(legacy._id);
+        }
+      }
+      return { ok: true, result: 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();
+        if (!doc && isBackgroundTasksTable(convexTable, request)) {
+          const legacy = await findGenericDocumentById(ctx, request.tableName, String(keys.id));
+          return { ok: true, result: legacy?.record ?? null };
+        }
         return { ok: true, result: doc || null };
       }
       if (convexTable === CONVEX_TABLE_WORKFLOW_SNAPSHOTS && typeof keys.workflow_name === "string" && typeof keys.run_id === "string") {
@@ -385,34 +647,47 @@ async function handleTypedOperation(ctx, convexTable, request) {
     }
     case "queryTable": {
       const maxDocs = request.limit ? Math.min(request.limit * 2, 1e4) : 1e4;
-      let docs;
+      let query;
+      let indexedFields = /* @__PURE__ */ new Set();
       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);
+          query = ctx.db.query(convexTable).withIndex("by_workflow", (q) => q.eq("workflow_name", hint.workflowName));
         } 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);
+          query = ctx.db.query(convexTable).withIndex(
+            "by_workflow_run",
+            (q) => q.eq("workflow_name", hint.workflowName).eq("run_id", hint.runId)
+          );
         } else {
-          docs = await ctx.db.query(convexTable).take(maxDocs);
+          query = ctx.db.query(convexTable);
         }
       } 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) => {
+          query = 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);
+          });
+          indexedFields = new Set(match.indexedFilters.map((filter) => filter.field));
         } else {
-          docs = await ctx.db.query(convexTable).take(maxDocs);
+          query = ctx.db.query(convexTable);
         }
       } else {
-        docs = await ctx.db.query(convexTable).take(maxDocs);
+        query = ctx.db.query(convexTable);
       }
-      if (request.filters && request.filters.length > 0) {
-        docs = docs.filter((doc) => request.filters.every((filter) => doc[filter.field] === filter.value));
+      let docs = await applyConvexEqualityFilters(query, request.filters, indexedFields).take(maxDocs);
+      if (isBackgroundTasksTable(convexTable, request)) {
+        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, maxDocs);
+        let legacyRecords = legacyDocs.map((doc) => doc.record);
+        if (request.filters && request.filters.length > 0) {
+          legacyRecords = legacyRecords.filter((record) => matchesFilters(record, request.filters));
+        }
+        legacyRecords = await filterLegacyRecordsWithoutTypedCopy(ctx, convexTable, legacyRecords);
+        docs.push(...legacyRecords);
+        docs = dedupeByRecordId(docs);
       }
       if (request.limit) {
         docs = docs.slice(0, request.limit);
@@ -423,15 +698,27 @@ async function handleTypedOperation(ctx, convexTable, request) {
     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;
+      let docsToDelete = hasMore ? docs.slice(0, STORAGE_MUTATION_BATCH_SIZE) : docs;
+      let legacyHasMore = false;
+      if (!hasMore && docsToDelete.length < STORAGE_MUTATION_BATCH_SIZE && isBackgroundTasksTable(convexTable, request)) {
+        const remainingBatchSize = STORAGE_MUTATION_BATCH_SIZE - docsToDelete.length;
+        const legacyDocs = await findGenericDocumentsByTable(ctx, request.tableName, remainingBatchSize + 1);
+        legacyHasMore = legacyDocs.length > remainingBatchSize;
+        docsToDelete = docsToDelete.concat(legacyHasMore ? legacyDocs.slice(0, remainingBatchSize) : legacyDocs);
+      }
       await deleteDocs(ctx, docsToDelete);
-      return { ok: true, hasMore };
+      return { ok: true, hasMore: hasMore || legacyHasMore };
     }
     case "deleteMany": {
       const docsToDelete = await findExistingDocsByIds(
         request.ids,
         (id) => ctx.db.query(convexTable).withIndex("by_record_id", (q) => q.eq("id", id)).unique()
       );
+      if (isBackgroundTasksTable(convexTable, request)) {
+        docsToDelete.push(
+          ...await findExistingDocsByIds(request.ids, (id) => findGenericDocumentById(ctx, request.tableName, id))
+        );
+      }
       await deleteDocs(ctx, docsToDelete);
       return { ok: true };
     }
@@ -486,6 +773,15 @@ async function handleVectorOperation(ctx, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id", "indexName"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_index_id", (q) => q.eq("indexName", indexName).eq("id", request.id)).unique();
+      if (!existing) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, patchRecord);
+      return { ok: true, result: true };
+    }
     case "load": {
       const keys = request.keys;
       if (keys.id) {
@@ -567,6 +863,17 @@ async function handleGenericOperation(ctx, request) {
       });
       return { ok: true };
     }
+    case "patch": {
+      const patchRecord = stripPatchKeys(request.record, ["id"]);
+      const existing = await ctx.db.query(convexTable).withIndex("by_table_primary", (q) => q.eq("table", tableName).eq("primaryKey", String(request.id))).unique();
+      if (!existing) {
+        return { ok: true, result: false };
+      }
+      await ctx.db.patch(existing._id, {
+        record: tableName === constants.TABLE_BACKGROUND_TASKS ? mergeLegacyRecord(existing.record, patchRecord) : { ...existing.record, ...patchRecord }
+      });
+      return { ok: true, result: true };
+    }
     case "load": {
       const keys = request.keys;
       if (keys.id) {
@@ -583,7 +890,7 @@ async function handleGenericOperation(ctx, request) {
       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)
+          (record) => tableName === constants.TABLE_BACKGROUND_TASKS ? matchesFilters(record, request.filters) : request.filters.every((filter) => record?.[filter.field] === filter.value)
         );
       }
       if (request.limit) {
@@ -889,5 +1196,5 @@ exports.mastraNativeVectorAction = mastraNativeVectorAction;
 exports.mastraNativeVectorMutation = mastraNativeVectorMutation;
 exports.mastraNativeVectorQuery = mastraNativeVectorQuery;
 exports.mastraStorage = mastraStorage;
-//# sourceMappingURL=chunk-EEELVBWO.cjs.map
-//# sourceMappingURL=chunk-EEELVBWO.cjs.map
+//# sourceMappingURL=chunk-ORSDZTO4.cjs.map
+//# sourceMappingURL=chunk-ORSDZTO4.cjs.map