@mastra/cloudflare-d1 0.1.5-alpha.2

package/dist/index.cjs

@@ -0,0 +1,944 @@
+'use strict';
+
+var storage = require('@mastra/core/storage');
+var Cloudflare = require('cloudflare');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var Cloudflare__default = /*#__PURE__*/_interopDefault(Cloudflare);
+
+// src/storage/index.ts
+
+// src/storage/sql-builder.ts
+var SqlBuilder = class {
+  sql = "";
+  params = [];
+  whereAdded = false;
+  // Basic query building
+  select(columns) {
+    if (!columns || Array.isArray(columns) && columns.length === 0) {
+      this.sql = "SELECT *";
+    } else {
+      this.sql = `SELECT ${Array.isArray(columns) ? columns.join(", ") : columns}`;
+    }
+    return this;
+  }
+  from(table) {
+    this.sql += ` FROM ${table}`;
+    return this;
+  }
+  /**
+   * Add a WHERE clause to the query
+   * @param condition The condition to add
+   * @param params Parameters to bind to the condition
+   */
+  where(condition, ...params) {
+    this.sql += ` WHERE ${condition}`;
+    this.params.push(...params);
+    this.whereAdded = true;
+    return this;
+  }
+  /**
+   * Add a WHERE clause if it hasn't been added yet, otherwise add an AND clause
+   * @param condition The condition to add
+   * @param params Parameters to bind to the condition
+   */
+  whereAnd(condition, ...params) {
+    if (this.whereAdded) {
+      return this.andWhere(condition, ...params);
+    } else {
+      return this.where(condition, ...params);
+    }
+  }
+  andWhere(condition, ...params) {
+    this.sql += ` AND ${condition}`;
+    this.params.push(...params);
+    return this;
+  }
+  orWhere(condition, ...params) {
+    this.sql += ` OR ${condition}`;
+    this.params.push(...params);
+    return this;
+  }
+  orderBy(column, direction = "ASC") {
+    this.sql += ` ORDER BY ${column} ${direction}`;
+    return this;
+  }
+  limit(count) {
+    this.sql += ` LIMIT ?`;
+    this.params.push(count);
+    return this;
+  }
+  offset(count) {
+    this.sql += ` OFFSET ?`;
+    this.params.push(count);
+    return this;
+  }
+  /**
+   * Insert a row, or update specific columns on conflict (upsert).
+   * @param table Table name
+   * @param columns Columns to insert
+   * @param values Values to insert
+   * @param conflictColumns Columns to check for conflict (usually PK or UNIQUE)
+   * @param updateMap Object mapping columns to update to their new value (e.g. { name: 'excluded.name' })
+   */
+  insert(table, columns, values, conflictColumns, updateMap) {
+    const placeholders = columns.map(() => "?").join(", ");
+    if (conflictColumns && updateMap) {
+      const updateClause = Object.entries(updateMap).map(([col, expr]) => `${col} = ${expr}`).join(", ");
+      this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders}) ON CONFLICT(${conflictColumns.join(", ")}) DO UPDATE SET ${updateClause}`;
+      this.params.push(...values);
+      return this;
+    }
+    this.sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+    this.params.push(...values);
+    return this;
+  }
+  // Update operations
+  update(table, columns, values) {
+    const setClause = columns.map((col) => `${col} = ?`).join(", ");
+    this.sql = `UPDATE ${table} SET ${setClause}`;
+    this.params.push(...values);
+    return this;
+  }
+  // Delete operations
+  delete(table) {
+    this.sql = `DELETE FROM ${table}`;
+    return this;
+  }
+  /**
+   * Create a table if it doesn't exist
+   * @param table The table name
+   * @param columnDefinitions The column definitions as an array of strings
+   * @param tableConstraints Optional constraints for the table
+   * @returns The builder instance
+   */
+  createTable(table, columnDefinitions, tableConstraints) {
+    const columns = columnDefinitions.join(", ");
+    const constraints = tableConstraints && tableConstraints.length > 0 ? ", " + tableConstraints.join(", ") : "";
+    this.sql = `CREATE TABLE IF NOT EXISTS ${table} (${columns}${constraints})`;
+    return this;
+  }
+  /**
+   * Check if an index exists in the database
+   * @param indexName The name of the index to check
+   * @param tableName The table the index is on
+   * @returns The builder instance
+   */
+  checkIndexExists(indexName, tableName) {
+    this.sql = `SELECT name FROM sqlite_master WHERE type='index' AND name=? AND tbl_name=?`;
+    this.params.push(indexName, tableName);
+    return this;
+  }
+  /**
+   * Create an index if it doesn't exist
+   * @param indexName The name of the index to create
+   * @param tableName The table to create the index on
+   * @param columnName The column to index
+   * @param indexType Optional index type (e.g., 'UNIQUE')
+   * @returns The builder instance
+   */
+  createIndex(indexName, tableName, columnName, indexType = "") {
+    this.sql = `CREATE ${indexType ? indexType + " " : ""}INDEX IF NOT EXISTS ${indexName} ON ${tableName}(${columnName})`;
+    return this;
+  }
+  // Raw SQL with params
+  raw(sql, ...params) {
+    this.sql = sql;
+    this.params.push(...params);
+    return this;
+  }
+  /**
+   * Add a LIKE condition to the query
+   * @param column The column to check
+   * @param value The value to match (will be wrapped with % for LIKE)
+   * @param exact If true, will not add % wildcards
+   */
+  like(column, value, exact = false) {
+    const likeValue = exact ? value : `%${value}%`;
+    if (this.whereAdded) {
+      this.sql += ` AND ${column} LIKE ?`;
+    } else {
+      this.sql += ` WHERE ${column} LIKE ?`;
+      this.whereAdded = true;
+    }
+    this.params.push(likeValue);
+    return this;
+  }
+  /**
+   * Add a JSON LIKE condition for searching in JSON fields
+   * @param column The JSON column to search in
+   * @param key The JSON key to match
+   * @param value The value to match
+   */
+  jsonLike(column, key, value) {
+    const jsonPattern = `%"${key}":"${value}"%`;
+    if (this.whereAdded) {
+      this.sql += ` AND ${column} LIKE ?`;
+    } else {
+      this.sql += ` WHERE ${column} LIKE ?`;
+      this.whereAdded = true;
+    }
+    this.params.push(jsonPattern);
+    return this;
+  }
+  /**
+   * Get the built query
+   * @returns Object containing the SQL string and parameters array
+   */
+  build() {
+    return {
+      sql: this.sql,
+      params: this.params
+    };
+  }
+  /**
+   * Reset the builder for reuse
+   * @returns The reset builder instance
+   */
+  reset() {
+    this.sql = "";
+    this.params = [];
+    this.whereAdded = false;
+    return this;
+  }
+};
+function createSqlBuilder() {
+  return new SqlBuilder();
+}
+
+// src/storage/index.ts
+function isArrayOfRecords(value) {
+  return value && Array.isArray(value) && value.length > 0;
+}
+var D1Store = class extends storage.MastraStorage {
+  client;
+  accountId;
+  databaseId;
+  binding;
+  // D1Database binding
+  tablePrefix;
+  /**
+   * Creates a new D1Store instance
+   * @param config Configuration for D1 access (either REST API or Workers Binding API)
+   */
+  constructor(config) {
+    super({ name: "D1" });
+    this.tablePrefix = config.tablePrefix || "";
+    if ("binding" in config) {
+      if (!config.binding) {
+        throw new Error("D1 binding is required when using Workers Binding API");
+      }
+      this.binding = config.binding;
+      this.logger.info("Using D1 Workers Binding API");
+    } else {
+      if (!config.accountId || !config.databaseId || !config.apiToken) {
+        throw new Error("accountId, databaseId, and apiToken are required when using REST API");
+      }
+      this.accountId = config.accountId;
+      this.databaseId = config.databaseId;
+      this.client = new Cloudflare__default.default({
+        apiToken: config.apiToken
+      });
+      this.logger.info("Using D1 REST API");
+    }
+  }
+  // Helper method to get the full table name with prefix
+  getTableName(tableName) {
+    return `${this.tablePrefix}${tableName}`;
+  }
+  formatSqlParams(params) {
+    return params.map((p) => p === void 0 || p === null ? null : p);
+  }
+  // Helper method to create SQL indexes for better query performance
+  async createIndexIfNotExists(tableName, columnName, indexType = "") {
+    const fullTableName = this.getTableName(tableName);
+    const indexName = `idx_${tableName}_${columnName}`;
+    try {
+      const checkQuery = createSqlBuilder().checkIndexExists(indexName, fullTableName);
+      const { sql: checkSql, params: checkParams } = checkQuery.build();
+      const indexExists = await this.executeQuery({
+        sql: checkSql,
+        params: checkParams,
+        first: true
+      });
+      if (!indexExists) {
+        const createQuery = createSqlBuilder().createIndex(indexName, fullTableName, columnName, indexType);
+        const { sql: createSql, params: createParams } = createQuery.build();
+        await this.executeQuery({ sql: createSql, params: createParams });
+        this.logger.debug(`Created index ${indexName} on ${fullTableName}(${columnName})`);
+      }
+    } catch (error) {
+      this.logger.error(`Error creating index on ${fullTableName}(${columnName}):`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async executeWorkersBindingQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.binding) {
+      throw new Error("Workers binding is not configured");
+    }
+    try {
+      const statement = this.binding.prepare(sql);
+      const formattedParams = this.formatSqlParams(params);
+      let result;
+      if (formattedParams.length > 0) {
+        if (first) {
+          result = await statement.bind(...formattedParams).first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.bind(...formattedParams).all();
+          const results = result.results || [];
+          if (result.meta) {
+            this.logger.debug("Query metadata", { meta: result.meta });
+          }
+          return results;
+        }
+      } else {
+        if (first) {
+          result = await statement.first();
+          if (!result) return null;
+          return result;
+        } else {
+          result = await statement.all();
+          const results = result.results || [];
+          if (result.meta) {
+            this.logger.debug("Query metadata", { meta: result.meta });
+          }
+          return results;
+        }
+      }
+    } catch (workerError) {
+      this.logger.error("Workers Binding API error", {
+        message: workerError instanceof Error ? workerError.message : String(workerError),
+        sql
+      });
+      throw new Error(`D1 Workers API error: ${workerError.message}`);
+    }
+  }
+  async executeRestQuery({
+    sql,
+    params = [],
+    first = false
+  }) {
+    if (!this.client || !this.accountId || !this.databaseId) {
+      throw new Error("Missing required REST API configuration");
+    }
+    try {
+      const response = await this.client.d1.database.query(this.databaseId, {
+        account_id: this.accountId,
+        sql,
+        params: this.formatSqlParams(params)
+      });
+      const result = response.result || [];
+      const results = result.flatMap((r) => r.results || []);
+      if (first) {
+        const firstResult = isArrayOfRecords(results) && results.length > 0 ? results[0] : null;
+        if (!firstResult) return null;
+        return firstResult;
+      }
+      return results;
+    } catch (restError) {
+      this.logger.error("REST API error", {
+        message: restError instanceof Error ? restError.message : String(restError),
+        sql
+      });
+      throw new Error(`D1 REST API error: ${restError.message}`);
+    }
+  }
+  /**
+   * Execute a SQL query against the D1 database
+   * @param options Query options including SQL, parameters, and whether to return only the first result
+   * @returns Query results as an array or a single object if first=true
+   */
+  async executeQuery(options) {
+    const { sql, params = [], first = false } = options;
+    try {
+      this.logger.debug("Executing SQL query", { sql, params, first });
+      if (this.binding) {
+        return this.executeWorkersBindingQuery({ sql, params, first });
+      } else if (this.client && this.accountId && this.databaseId) {
+        return this.executeRestQuery({ sql, params, first });
+      } else {
+        throw new Error("No valid D1 configuration provided");
+      }
+    } catch (error) {
+      this.logger.error("Error executing SQL query", {
+        message: error instanceof Error ? error.message : String(error),
+        sql,
+        params,
+        first
+      });
+      throw new Error(`D1 query error: ${error.message}`);
+    }
+  }
+  // Helper to convert storage type to SQL type
+  getSqlType(type) {
+    switch (type) {
+      case "text":
+        return "TEXT";
+      case "timestamp":
+        return "TIMESTAMP";
+      case "integer":
+        return "INTEGER";
+      case "bigint":
+        return "INTEGER";
+      // SQLite doesn't have a separate BIGINT type
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return "TEXT";
+    }
+  }
+  ensureDate(date) {
+    if (!date) return void 0;
+    return date instanceof Date ? date : new Date(date);
+  }
+  serializeDate(date) {
+    if (!date) return void 0;
+    const dateObj = this.ensureDate(date);
+    return dateObj?.toISOString();
+  }
+  // Helper to serialize objects to JSON strings
+  serializeValue(value) {
+    if (value === null || value === void 0) return null;
+    if (value instanceof Date) {
+      return this.serializeDate(value);
+    }
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return value;
+  }
+  // Helper to deserialize JSON strings to objects
+  deserializeValue(value, type) {
+    if (value === null || value === void 0) return null;
+    if (type === "date" && typeof value === "string") {
+      return new Date(value);
+    }
+    if (type === "jsonb" && typeof value === "string") {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+      try {
+        return JSON.parse(value);
+      } catch {
+        return value;
+      }
+    }
+    return value;
+  }
+  async createTable({
+    tableName,
+    schema
+  }) {
+    const fullTableName = this.getTableName(tableName);
+    const columnDefinitions = Object.entries(schema).map(([colName, colDef]) => {
+      const type = this.getSqlType(colDef.type);
+      const nullable = colDef.nullable === false ? "NOT NULL" : "";
+      const primaryKey = colDef.primaryKey ? "PRIMARY KEY" : "";
+      return `${colName} ${type} ${nullable} ${primaryKey}`.trim();
+    });
+    const tableConstraints = [];
+    if (tableName === storage.TABLE_WORKFLOW_SNAPSHOT) {
+      tableConstraints.push("UNIQUE (workflow_name, run_id)");
+    }
+    const query = createSqlBuilder().createTable(fullTableName, columnDefinitions, tableConstraints);
+    const { sql, params } = query.build();
+    try {
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Created table ${fullTableName}`);
+    } catch (error) {
+      this.logger.error(`Error creating table ${fullTableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to create table ${fullTableName}: ${error}`);
+    }
+  }
+  async clearTable({ tableName }) {
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const query = createSqlBuilder().delete(fullTableName);
+      const { sql, params } = query.build();
+      await this.executeQuery({ sql, params });
+      this.logger.debug(`Cleared table ${fullTableName}`);
+    } catch (error) {
+      this.logger.error(`Error clearing table ${fullTableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to clear table ${fullTableName}: ${error}`);
+    }
+  }
+  async processRecord(record) {
+    const processedRecord = {};
+    for (const [key, value] of Object.entries(record)) {
+      processedRecord[key] = this.serializeValue(value);
+    }
+    return processedRecord;
+  }
+  async insert({ tableName, record }) {
+    const fullTableName = this.getTableName(tableName);
+    const processedRecord = await this.processRecord(record);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const query = createSqlBuilder().insert(fullTableName, columns, values);
+    const { sql, params } = query.build();
+    try {
+      await this.executeQuery({ sql, params });
+    } catch (error) {
+      this.logger.error(`Error inserting into ${fullTableName}:`, { error });
+      throw new Error(`Failed to insert into ${fullTableName}: ${error}`);
+    }
+  }
+  async load({ tableName, keys }) {
+    const fullTableName = this.getTableName(tableName);
+    const query = createSqlBuilder().select("*").from(fullTableName);
+    let firstKey = true;
+    for (const [key, value] of Object.entries(keys)) {
+      if (firstKey) {
+        query.where(`${key} = ?`, value);
+        firstKey = false;
+      } else {
+        query.andWhere(`${key} = ?`, value);
+      }
+    }
+    query.limit(1);
+    const { sql, params } = query.build();
+    try {
+      const result = await this.executeQuery({ sql, params, first: true });
+      if (!result) return null;
+      const processedResult = {};
+      for (const [key, value] of Object.entries(result)) {
+        processedResult[key] = this.deserializeValue(value);
+      }
+      return processedResult;
+    } catch (error) {
+      this.logger.error(`Error loading from ${fullTableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async getThreadById({ threadId }) {
+    const thread = await this.load({
+      tableName: storage.TABLE_THREADS,
+      keys: { id: threadId }
+    });
+    if (!thread) return null;
+    try {
+      return {
+        ...thread,
+        createdAt: this.ensureDate(thread.createdAt),
+        updatedAt: this.ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
+      };
+    } catch (error) {
+      this.logger.error(`Error processing thread ${threadId}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return null;
+    }
+  }
+  async getThreadsByResourceId({ resourceId }) {
+    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    try {
+      const query = createSqlBuilder().select("*").from(fullTableName).where("resourceId = ?", resourceId);
+      const { sql, params } = query.build();
+      const results = await this.executeQuery({ sql, params });
+      return (isArrayOfRecords(results) ? results : []).map((thread) => ({
+        ...thread,
+        createdAt: this.ensureDate(thread.createdAt),
+        updatedAt: this.ensureDate(thread.updatedAt),
+        metadata: typeof thread.metadata === "string" ? JSON.parse(thread.metadata || "{}") : thread.metadata || {}
+      }));
+    } catch (error) {
+      this.logger.error(`Error getting threads by resourceId ${resourceId}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async saveThread({ thread }) {
+    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const threadToSave = {
+      id: thread.id,
+      resourceId: thread.resourceId,
+      title: thread.title,
+      metadata: thread.metadata ? JSON.stringify(thread.metadata) : null,
+      createdAt: thread.createdAt,
+      updatedAt: thread.updatedAt
+    };
+    const processedRecord = await this.processRecord(threadToSave);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      resourceId: "excluded.resourceId",
+      title: "excluded.title",
+      metadata: "excluded.metadata",
+      createdAt: "excluded.createdAt",
+      updatedAt: "excluded.updatedAt"
+    };
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["id"], updateMap);
+    const { sql, params } = query.build();
+    try {
+      await this.executeQuery({ sql, params });
+      return thread;
+    } catch (error) {
+      this.logger.error(`Error saving thread to ${fullTableName}:`, { error });
+      throw error;
+    }
+  }
+  async updateThread({
+    id,
+    title,
+    metadata
+  }) {
+    const thread = await this.getThreadById({ threadId: id });
+    if (!thread) {
+      throw new Error(`Thread ${id} not found`);
+    }
+    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    const mergedMetadata = {
+      ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+      ...metadata
+    };
+    const columns = ["title", "metadata", "updatedAt"];
+    const values = [title, JSON.stringify(mergedMetadata), (/* @__PURE__ */ new Date()).toISOString()];
+    const query = createSqlBuilder().update(fullTableName, columns, values).where("id = ?", id);
+    const { sql, params } = query.build();
+    try {
+      await this.executeQuery({ sql, params });
+      return {
+        ...thread,
+        title,
+        metadata: {
+          ...typeof thread.metadata === "string" ? JSON.parse(thread.metadata) : thread.metadata,
+          ...metadata
+        },
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+    } catch (error) {
+      this.logger.error("Error updating thread:", { error });
+      throw error;
+    }
+  }
+  async deleteThread({ threadId }) {
+    const fullTableName = this.getTableName(storage.TABLE_THREADS);
+    try {
+      const deleteThreadQuery = createSqlBuilder().delete(fullTableName).where("id = ?", threadId);
+      const { sql: threadSql, params: threadParams } = deleteThreadQuery.build();
+      await this.executeQuery({ sql: threadSql, params: threadParams });
+      const messagesTableName = this.getTableName(storage.TABLE_MESSAGES);
+      const deleteMessagesQuery = createSqlBuilder().delete(messagesTableName).where("thread_id = ?", threadId);
+      const { sql: messagesSql, params: messagesParams } = deleteMessagesQuery.build();
+      await this.executeQuery({ sql: messagesSql, params: messagesParams });
+    } catch (error) {
+      this.logger.error(`Error deleting thread ${threadId}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to delete thread ${threadId}: ${error}`);
+    }
+  }
+  // Thread and message management methods
+  async saveMessages({ messages }) {
+    if (messages.length === 0) return [];
+    try {
+      const now = /* @__PURE__ */ new Date();
+      for (const [i, message] of messages.entries()) {
+        if (!message.id) throw new Error(`Message at index ${i} missing id`);
+        if (!message.threadId) throw new Error(`Message at index ${i} missing threadId`);
+        if (!message.content) throw new Error(`Message at index ${i} missing content`);
+        if (!message.role) throw new Error(`Message at index ${i} missing role`);
+        const thread = await this.getThreadById({ threadId: message.threadId });
+        if (!thread) {
+          throw new Error(`Thread ${message.threadId} not found`);
+        }
+      }
+      const messagesToInsert = messages.map((message) => {
+        const createdAt = message.createdAt ? new Date(message.createdAt) : now;
+        return {
+          id: message.id,
+          thread_id: message.threadId,
+          content: typeof message.content === "string" ? message.content : JSON.stringify(message.content),
+          createdAt: createdAt.toISOString(),
+          role: message.role,
+          type: message.type
+        };
+      });
+      await this.batchInsert({
+        tableName: storage.TABLE_MESSAGES,
+        records: messagesToInsert
+      });
+      this.logger.debug(`Saved ${messages.length} messages`);
+      return messages;
+    } catch (error) {
+      this.logger.error("Error saving messages:", { message: error instanceof Error ? error.message : String(error) });
+      throw error;
+    }
+  }
+  async getMessages({ threadId, selectBy }) {
+    const fullTableName = this.getTableName(storage.TABLE_MESSAGES);
+    const limit = typeof selectBy?.last === "number" ? selectBy.last : 40;
+    const include = selectBy?.include || [];
+    const messages = [];
+    try {
+      if (include.length) {
+        const prevMax = Math.max(...include.map((i) => i.withPreviousMessages || 0));
+        const nextMax = Math.max(...include.map((i) => i.withNextMessages || 0));
+        const includeIds = include.map((i) => i.id);
+        const sql2 = `
+        WITH ordered_messages AS (
+          SELECT
+            *,
+            ROW_NUMBER() OVER (ORDER BY createdAt DESC) AS row_num
+          FROM ${fullTableName}
+          WHERE thread_id = ?
+        )
+        SELECT
+          m.id,
+          m.content,
+          m.role,
+          m.type,
+          m.createdAt,
+          m.thread_id AS "threadId"
+        FROM ordered_messages m
+        WHERE m.id IN (${includeIds.map(() => "?").join(",")})
+        OR EXISTS (
+          SELECT 1 FROM ordered_messages target
+          WHERE target.id IN (${includeIds.map(() => "?").join(",")})
+          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)
+          )
+        )
+        ORDER BY m.createdAt DESC
+      `;
+        const params2 = [
+          threadId,
+          ...includeIds,
+          // for m.id IN (...)
+          ...includeIds,
+          // for target.id IN (...)
+          prevMax,
+          nextMax
+        ];
+        const includeResult = await this.executeQuery({ sql: sql2, params: params2 });
+        if (Array.isArray(includeResult)) messages.push(...includeResult);
+      }
+      const excludeIds = messages.map((m) => m.id);
+      let query = createSqlBuilder().select(["id", "content", "role", "type", '"createdAt"', 'thread_id AS "threadId"']).from(fullTableName).where("thread_id = ?", threadId).andWhere(`id NOT IN (${excludeIds.map(() => "?").join(",")})`, ...excludeIds).orderBy("createdAt", "DESC").limit(limit);
+      const { sql, params } = query.build();
+      const result = await this.executeQuery({ sql, params });
+      if (Array.isArray(result)) messages.push(...result);
+      messages.sort((a, b) => {
+        const aRecord = a;
+        const bRecord = b;
+        const timeA = new Date(aRecord.createdAt).getTime();
+        const timeB = new Date(bRecord.createdAt).getTime();
+        return timeA - timeB;
+      });
+      const processedMessages = messages.map((message) => {
+        const processedMsg = {};
+        for (const [key, value] of Object.entries(message)) {
+          processedMsg[key] = this.deserializeValue(value);
+        }
+        return processedMsg;
+      });
+      this.logger.debug(`Retrieved ${messages.length} messages for thread ${threadId}`);
+      return processedMessages;
+    } catch (error) {
+      this.logger.error("Error retrieving messages for thread", {
+        threadId,
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  async persistWorkflowSnapshot({
+    workflowName,
+    runId,
+    snapshot
+  }) {
+    const fullTableName = this.getTableName(storage.TABLE_WORKFLOW_SNAPSHOT);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const currentSnapshot = await this.load({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      keys: { workflow_name: workflowName, run_id: runId }
+    });
+    const persisting = currentSnapshot ? {
+      ...currentSnapshot,
+      snapshot: JSON.stringify(snapshot),
+      updatedAt: now
+    } : {
+      workflow_name: workflowName,
+      run_id: runId,
+      snapshot,
+      createdAt: now,
+      updatedAt: now
+    };
+    const processedRecord = await this.processRecord(persisting);
+    const columns = Object.keys(processedRecord);
+    const values = Object.values(processedRecord);
+    const updateMap = {
+      snapshot: "excluded.snapshot",
+      updatedAt: "excluded.updatedAt"
+    };
+    this.logger.debug("Persisting workflow snapshot", { workflowName, runId });
+    const query = createSqlBuilder().insert(fullTableName, columns, values, ["workflow_name", "run_id"], updateMap);
+    const { sql, params } = query.build();
+    try {
+      await this.executeQuery({ sql, params });
+    } catch (error) {
+      this.logger.error("Error persisting workflow snapshot:", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw error;
+    }
+  }
+  async loadWorkflowSnapshot(params) {
+    const { workflowName, runId } = params;
+    this.logger.debug("Loading workflow snapshot", { workflowName, runId });
+    const d = await this.load({
+      tableName: storage.TABLE_WORKFLOW_SNAPSHOT,
+      keys: {
+        workflow_name: workflowName,
+        run_id: runId
+      }
+    });
+    return d ? d.snapshot : null;
+  }
+  /**
+   * Insert multiple records in a batch operation
+   * @param tableName The table to insert into
+   * @param records The records to insert
+   */
+  async batchInsert({ tableName, records }) {
+    if (records.length === 0) return;
+    const fullTableName = this.getTableName(tableName);
+    try {
+      const batchSize = 50;
+      for (let i = 0; i < records.length; i += batchSize) {
+        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 values = columns.map((col) => {
+              if (!record) return null;
+              const value = typeof col === "string" ? record[col] : null;
+              return this.serializeValue(value);
+            });
+            const query = createSqlBuilder().insert(fullTableName, columns, values);
+            const { sql, params } = query.build();
+            await this.executeQuery({ sql, params });
+          }
+        }
+        this.logger.debug(
+          `Processed batch ${Math.floor(i / batchSize) + 1} of ${Math.ceil(records.length / batchSize)}`
+        );
+      }
+      this.logger.debug(`Successfully batch inserted ${records.length} records into ${tableName}`);
+    } catch (error) {
+      this.logger.error(`Error batch inserting into ${tableName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      throw new Error(`Failed to batch insert into ${tableName}: ${error}`);
+    }
+  }
+  async getTraces({
+    name,
+    scope,
+    page,
+    perPage,
+    attributes
+  }) {
+    const fullTableName = this.getTableName(storage.TABLE_TRACES);
+    try {
+      const query = createSqlBuilder().select("*").from(fullTableName).where("1=1");
+      if (name) {
+        query.andWhere("name LIKE ?", `%${name}%`);
+      }
+      if (scope) {
+        query.andWhere("scope = ?", scope);
+      }
+      if (attributes && Object.keys(attributes).length > 0) {
+        for (const [key, value] of Object.entries(attributes)) {
+          query.jsonLike("attributes", key, value);
+        }
+      }
+      query.orderBy("startTime", "DESC").limit(perPage).offset((page - 1) * perPage);
+      const { sql, params } = query.build();
+      const results = await this.executeQuery({ sql, params });
+      return isArrayOfRecords(results) ? results.map((trace) => ({
+        ...trace,
+        attributes: this.deserializeValue(trace.attributes, "jsonb"),
+        status: this.deserializeValue(trace.status, "jsonb"),
+        events: this.deserializeValue(trace.events, "jsonb"),
+        links: this.deserializeValue(trace.links, "jsonb"),
+        other: this.deserializeValue(trace.other, "jsonb")
+      })) : [];
+    } catch (error) {
+      this.logger.error("Error getting traces:", { message: error instanceof Error ? error.message : String(error) });
+      return [];
+    }
+  }
+  async getEvalsByAgentName(agentName, type) {
+    const fullTableName = this.getTableName(storage.TABLE_EVALS);
+    try {
+      let query = createSqlBuilder().select("*").from(fullTableName).where("agent_name = ?", agentName);
+      if (type === "test") {
+        query = query.andWhere("test_info IS NOT NULL AND json_extract(test_info, '$.testPath') IS NOT NULL");
+      } else if (type === "live") {
+        query = query.andWhere("(test_info IS NULL OR json_extract(test_info, '$.testPath') IS NULL)");
+      }
+      query.orderBy("created_at", "DESC");
+      const { sql, params } = query.build();
+      const results = await this.executeQuery({ sql, params });
+      return isArrayOfRecords(results) ? results.map((row) => {
+        const result = this.deserializeValue(row.result);
+        const testInfo = row.test_info ? this.deserializeValue(row.test_info) : void 0;
+        return {
+          input: row.input || "",
+          output: row.output || "",
+          result,
+          agentName: row.agent_name || "",
+          metricName: row.metric_name || "",
+          instructions: row.instructions || "",
+          runId: row.run_id || "",
+          globalRunId: row.global_run_id || "",
+          createdAt: row.created_at || "",
+          testInfo
+        };
+      }) : [];
+    } catch (error) {
+      this.logger.error(`Error getting evals for agent ${agentName}:`, {
+        message: error instanceof Error ? error.message : String(error)
+      });
+      return [];
+    }
+  }
+  getWorkflowRuns(_args) {
+    throw new Error("Method not implemented.");
+  }
+  /**
+   * Close the database connection
+   * No explicit cleanup needed for D1 in either REST or Workers Binding mode
+   */
+  async close() {
+    this.logger.debug("Closing D1 connection");
+  }
+};
+
+exports.D1Store = D1Store;