@mastra/cloudflare-d1 1.0.1 → 1.0.2

package/dist/index.js

@@ -285,6 +285,8 @@ var D1DB = class extends MastraBase {
   client;
   binding;
   tablePrefix;
+  /** Cache of actual table columns: tableName -> Promise<Set<columnName>> (stores in-flight promise to coalesce concurrent calls) */
+  tableColumnsCache = /* @__PURE__ */ new Map();
   constructor(config) {
     super({
       component: "STORAGE",
@@ -393,6 +395,38 @@ var D1DB = class extends MastraBase {
       throw new Error("Neither binding nor client is configured");
     }
   }
+  /**
+   * Gets the set of column names that actually exist in the database table.
+   * Results are cached; the cache is invalidated when alterTable() adds new columns.
+   */
+  async getKnownColumnNames(tableName) {
+    const cached = this.tableColumnsCache.get(tableName);
+    if (cached) return cached;
+    const promise = this.getTableColumns(tableName).then((columns) => {
+      const names = new Set(columns.map((c) => c.name));
+      if (names.size === 0) {
+        this.tableColumnsCache.delete(tableName);
+      }
+      return names;
+    });
+    this.tableColumnsCache.set(tableName, promise);
+    return promise;
+  }
+  /**
+   * Filters a record to only include columns that exist in the actual database table.
+   * Unknown columns are silently dropped to ensure forward compatibility.
+   */
+  async filterRecordToKnownColumns(tableName, record) {
+    const knownColumns = await this.getKnownColumnNames(tableName);
+    if (knownColumns.size === 0) return record;
+    const filtered = {};
+    for (const [key, value] of Object.entries(record)) {
+      if (knownColumns.has(key)) {
+        filtered[key] = value;
+      }
+    }
+    return filtered;
+  }
   async getTableColumns(tableName) {
     try {
       const sql = `PRAGMA table_info(${tableName})`;
@@ -459,6 +493,7 @@ var D1DB = class extends MastraBase {
       const { sql, params } = query.build();
       await this.executeQuery({ sql, params });
       this.logger.debug(`Created table ${fullTableName}`);
+      this.tableColumnsCache.delete(fullTableName);
     } catch (error) {
       throw new MastraError(
         {
@@ -491,8 +526,8 @@ var D1DB = class extends MastraBase {
     }
   }
   async dropTable({ tableName }) {
+    const fullTableName = this.getTableName(tableName);
     try {
-      const fullTableName = this.getTableName(tableName);
       const sql = `DROP TABLE IF EXISTS ${fullTableName}`;
       await this.executeQuery({ sql });
       this.logger.debug(`Dropped table ${fullTableName}`);
@@ -506,11 +541,13 @@ var D1DB = class extends MastraBase {
         },
         error
       );
+    } finally {
+      this.tableColumnsCache.delete(fullTableName);
     }
   }
   async alterTable(args) {
+    const fullTableName = this.getTableName(args.tableName);
     try {
-      const fullTableName = this.getTableName(args.tableName);
       const existingColumns = await this.getTableColumns(fullTableName);
       const existingColumnNames = new Set(existingColumns.map((col) => col.name));
       for (const [columnName, column] of Object.entries(args.schema)) {
@@ -532,14 +569,18 @@ var D1DB = class extends MastraBase {
         },
         error
       );
+    } finally {
+      this.tableColumnsCache.delete(fullTableName);
     }
   }
   async insert({ tableName, record }) {
     try {
       const fullTableName = this.getTableName(tableName);
       const processedRecord = await this.processRecord(record);
-      const columns = Object.keys(processedRecord);
-      const values = Object.values(processedRecord);
+      const filteredRecord = await this.filterRecordToKnownColumns(fullTableName, processedRecord);
+      const columns = Object.keys(filteredRecord);
+      if (columns.length === 0) return;
+      const values = Object.values(filteredRecord);
       const query = createSqlBuilder().insert(fullTableName, columns, values);
       const { sql, params } = query.build();
       await this.executeQuery({ sql, params });
@@ -560,8 +601,12 @@ var D1DB = class extends MastraBase {
       if (records.length === 0) return;
       const fullTableName = this.getTableName(tableName);
       const processedRecords = await Promise.all(records.map((record) => this.processRecord(record)));
-      const columns = Object.keys(processedRecords[0] || {});
-      for (const record of processedRecords) {
+      const filteredRecords = await Promise.all(
+        processedRecords.map((r) => this.filterRecordToKnownColumns(fullTableName, r))
+      );
+      for (const record of filteredRecords) {
+        const columns = Object.keys(record);
+        if (columns.length === 0) continue;
         const values = Object.values(record);
         const query = createSqlBuilder().insert(fullTableName, columns, values);
         const { sql, params } = query.build();
@@ -637,12 +682,14 @@ var D1DB = class extends MastraBase {
         const batch = records.slice(i, i + batchSize);
         const recordsToInsert = batch;
         if (recordsToInsert.length > 0) {
-          const firstRecord = recordsToInsert[0];
-          const columns = Object.keys(firstRecord || {});
-          for (const record of recordsToInsert) {
+          const filteredRecords = await Promise.all(
+            recordsToInsert.map((r) => this.filterRecordToKnownColumns(fullTableName, r || {}))
+          );
+          for (const record of filteredRecords) {
+            const columns = Object.keys(record);
+            if (columns.length === 0) continue;
             const values = columns.map((col) => {
-              if (!record) return null;
-              const value = typeof col === "string" ? record[col] : null;
+              const value = record[col];
               return this.serializeValue(value);
             });
             const recordToUpsert = columns.reduce(
@@ -1128,56 +1175,79 @@ var MemoryStorageD1 = class extends MemoryStorage {
       );
     }
   }
+  _sortMessages(messages, field, direction) {
+    return messages.sort((a, b) => {
+      const isDateField = field === "createdAt" || field === "updatedAt";
+      const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
+      const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
+      if (aValue === bValue) {
+        return a.id.localeCompare(b.id);
+      }
+      if (typeof aValue === "number" && typeof bValue === "number") {
+        return direction === "ASC" ? aValue - bValue : bValue - aValue;
+      }
+      return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
+    });
+  }
   async _getIncludedMessages(include) {
     if (!include || include.length === 0) return null;
+    const tableName = this.#db.getTableName(TABLE_MESSAGES);
+    const targetIds = include.map((inc) => inc.id).filter(Boolean);
+    if (targetIds.length === 0) return null;
+    const idPlaceholders = targetIds.map(() => "?").join(", ");
+    const targetResult = await this.#db.executeQuery({
+      sql: `SELECT id, thread_id, createdAt FROM ${tableName} WHERE id IN (${idPlaceholders})`,
+      params: targetIds
+    });
+    if (!Array.isArray(targetResult) || targetResult.length === 0) return null;
+    const targetMap = new Map(
+      targetResult.map((r) => [r.id, { threadId: r.thread_id, createdAt: r.createdAt }])
+    );
     const unionQueries = [];
     const params = [];
-    let paramIdx = 1;
-    const tableName = this.#db.getTableName(TABLE_MESSAGES);
     for (const inc of include) {
       const { id, withPreviousMessages = 0, withNextMessages = 0 } = inc;
-      unionQueries.push(`
-                SELECT * FROM (
-                  WITH target_thread AS (
-                    SELECT thread_id FROM ${tableName} WHERE id = ?
-                  ),
-                  ordered_messages AS (
-                    SELECT
-                      *,
-                      ROW_NUMBER() OVER (ORDER BY createdAt ASC) AS row_num
-                    FROM ${tableName}
-                    WHERE thread_id = (SELECT thread_id FROM target_thread)
-                  )
-                  SELECT
-                    m.id,
-                    m.content,
-                    m.role,
-                    m.type,
-                    m.createdAt,
-                    m.thread_id AS threadId,
-                    m.resourceId
-                  FROM ordered_messages m
-                  WHERE m.id = ?
-                  OR EXISTS (
-                    SELECT 1 FROM ordered_messages target
-                    WHERE target.id = ?
-                    AND (
-                      (m.row_num <= target.row_num + ? AND m.row_num > target.row_num)
-                      OR
-                      (m.row_num >= target.row_num - ? AND m.row_num < target.row_num)
-                    )
-                  )
-                ) AS query_${paramIdx}
-            `);
-      params.push(id, id, id, withNextMessages, withPreviousMessages);
-      paramIdx++;
-    }
-    const finalQuery = unionQueries.join(" UNION ALL ") + " ORDER BY createdAt ASC";
+      const target = targetMap.get(id);
+      if (!target) continue;
+      unionQueries.push(`SELECT * FROM (
+        SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+        FROM ${tableName}
+        WHERE thread_id = ?
+          AND createdAt <= ?
+        ORDER BY createdAt DESC, id DESC
+        LIMIT ?
+      )`);
+      params.push(target.threadId, target.createdAt, withPreviousMessages + 1);
+      if (withNextMessages > 0) {
+        unionQueries.push(`SELECT * FROM (
+          SELECT id, content, role, type, createdAt, thread_id AS threadId, resourceId
+          FROM ${tableName}
+          WHERE thread_id = ?
+            AND createdAt > ?
+          ORDER BY createdAt ASC, id ASC
+          LIMIT ?
+        )`);
+        params.push(target.threadId, target.createdAt, withNextMessages);
+      }
+    }
+    if (unionQueries.length === 0) return null;
+    let finalQuery;
+    if (unionQueries.length === 1) {
+      finalQuery = unionQueries[0];
+    } else {
+      finalQuery = `${unionQueries.join(" UNION ALL ")} ORDER BY createdAt ASC, id ASC`;
+    }
     const messages = await this.#db.executeQuery({ sql: finalQuery, params });
     if (!Array.isArray(messages)) {
       return [];
     }
-    const processedMessages = messages.map((message) => {
+    const seen = /* @__PURE__ */ new Set();
+    const processedMessages = messages.filter((message) => {
+      const id = message.id;
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    }).map((message) => {
       const processedMsg = {};
       for (const [key, value] of Object.entries(message)) {
         if (key === `type` && value === `v2`) continue;
@@ -1277,6 +1347,23 @@ var MemoryStorageD1 = class extends MemoryStorage {
         queryParams.push(endDate);
       }
       const { field, direction } = this.parseOrderBy(orderBy, "ASC");
+      if (perPage === 0 && (!include || include.length === 0)) {
+        return { messages: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
+      }
+      if (perPage === 0 && include && include.length > 0) {
+        const includeResult = await this._getIncludedMessages(include);
+        if (!Array.isArray(includeResult) || includeResult.length === 0) {
+          return { messages: [], total: 0, page, perPage: perPageForResponse, hasMore: false };
+        }
+        const list2 = new MessageList().add(includeResult, "memory");
+        return {
+          messages: this._sortMessages(list2.get.all.db(), field, direction),
+          total: 0,
+          page,
+          perPage: perPageForResponse,
+          hasMore: false
+        };
+      }
       query += ` ORDER BY "${field}" ${direction}`;
       if (perPage !== Number.MAX_SAFE_INTEGER) {
         query += ` LIMIT ? OFFSET ?`;
@@ -1336,19 +1423,7 @@ var MemoryStorageD1 = class extends MemoryStorage {
         }
       }
       const list = new MessageList().add(paginatedMessages, "memory");
-      let finalMessages = list.get.all.db();
-      finalMessages = finalMessages.sort((a, b) => {
-        const isDateField = field === "createdAt" || field === "updatedAt";
-        const aValue = isDateField ? new Date(a[field]).getTime() : a[field];
-        const bValue = isDateField ? new Date(b[field]).getTime() : b[field];
-        if (aValue === bValue) {
-          return a.id.localeCompare(b.id);
-        }
-        if (typeof aValue === "number" && typeof bValue === "number") {
-          return direction === "ASC" ? aValue - bValue : bValue - aValue;
-        }
-        return direction === "ASC" ? String(aValue).localeCompare(String(bValue)) : String(bValue).localeCompare(String(aValue));
-      });
+      const finalMessages = this._sortMessages(list.get.all.db(), field, direction);
       const returnedThreadMessageIds = new Set(finalMessages.filter((m) => m.threadId === threadId).map((m) => m.id));
       const allThreadMessagesReturned = returnedThreadMessageIds.size >= total;
       const hasMore = perPageInput === false ? false : allThreadMessagesReturned ? false : offset + paginatedCount < total;