@mastra/cloudflare-d1 0.1.5-alpha.2

package/LICENSE.md

@@ -0,0 +1,46 @@
+# Elastic License 2.0 (ELv2)
+
+Copyright (c) 2025 Mastra AI, Inc.
+
+**Acceptance**
+By using the software, you agree to all of the terms and conditions below.
+
+**Copyright License**
+The licensor grants you a non-exclusive, royalty-free, worldwide, non-sublicensable, non-transferable license to use, copy, distribute, make available, and prepare derivative works of the software, in each case subject to the limitations and conditions below
+
+**Limitations**
+You may not provide the software to third parties as a hosted or managed service, where the service provides users with access to any substantial set of the features or functionality of the software.
+
+You may not move, change, disable, or circumvent the license key functionality in the software, and you may not remove or obscure any functionality in the software that is protected by the license key.
+
+You may not alter, remove, or obscure any licensing, copyright, or other notices of the licensor in the software. Any use of the licensor’s trademarks is subject to applicable law.
+
+**Patents**
+The licensor grants you a license, under any patent claims the licensor can license, or becomes able to license, to make, have made, use, sell, offer for sale, import and have imported the software, in each case subject to the limitations and conditions in this license. This license does not cover any patent claims that you cause to be infringed by modifications or additions to the software. If you or your company make any written claim that the software infringes or contributes to infringement of any patent, your patent license for the software granted under these terms ends immediately. If your company makes such a claim, your patent license ends immediately for work on behalf of your company.
+
+**Notices**
+You must ensure that anyone who gets a copy of any part of the software from you also gets a copy of these terms.
+
+If you modify the software, you must include in any modified copies of the software prominent notices stating that you have modified the software.
+
+**No Other Rights**
+These terms do not imply any licenses other than those expressly granted in these terms.
+
+**Termination**
+If you use the software in violation of these terms, such use is not licensed, and your licenses will automatically terminate. If the licensor provides you with a notice of your violation, and you cease all violation of this license no later than 30 days after you receive that notice, your licenses will be reinstated retroactively. However, if you violate these terms after such reinstatement, any additional violation of these terms will cause your licenses to terminate automatically and permanently.
+
+**No Liability**
+As far as the law allows, the software comes as is, without any warranty or condition, and the licensor will not be liable to you for any damages arising out of these terms or the use or nature of the software, under any kind of legal claim.
+
+**Definitions**
+The _licensor_ is the entity offering these terms, and the _software_ is the software the licensor makes available under these terms, including any portion of it.
+
+_you_ refers to the individual or entity agreeing to these terms.
+
+_your company_ is any legal entity, sole proprietorship, or other kind of organization that you work for, plus all organizations that have control over, are under the control of, or are under common control with that organization. _control_ means ownership of substantially all the assets of an entity, or the power to direct its management and policies by vote, contract, or otherwise. Control can be direct or indirect.
+
+_your licenses_ are all the licenses granted to you for the software under these terms.
+
+_use_ means anything you do with the software requiring one of your licenses.
+
+_trademark_ means trademarks, service marks, and similar rights.

package/README.md

@@ -0,0 +1,142 @@
+# @mastra/cloudflare-d1
+
+A Mastra store for Cloudflare D1 SQL databases, supporting threads, messages, workflows, evaluations, and traces with robust SQL features.
+
+## Features
+
+- Thread and message storage using SQL tables
+- True sorted order and filtering via SQL queries
+- Rich metadata support (JSON-encoded)
+- Timestamp tracking for all records
+- Workflow snapshot persistence
+- Trace and evaluation storage
+- Efficient batch operations (with prepared statements)
+- Automatic JSON serialization/deserialization for metadata and custom fields
+- Error handling and logging for all operations
+- Supports both Cloudflare Workers D1 Binding and REST API
+
+## Prerequisites
+
+- Access to a Cloudflare account with D1 enabled
+- D1 database created and configured
+- For Workers binding: Worker configured with D1 binding
+- For REST API: Cloudflare API Token with D1 permissions
+
+## Installation
+
+```bash
+pnpm add @mastra/cloudflare-d1
+```
+
+## Usage
+
+### With Workers D1 Binding
+
+```typescript
+import { D1Store } from '@mastra/cloudflare-d1';
+
+const store = new D1Store({
+  binding: env.DB, // D1Database binding from Worker environment
+  tablePrefix: 'mastra_', // optional
+});
+```
+
+### With REST API
+
+```typescript
+import { D1Store } from '@mastra/cloudflare-d1';
+
+const store = new D1Store({
+  accountId: '<your-account-id>',
+  databaseId: '<your-d1-database-id>',
+  apiToken: '<your-api-token>',
+  tablePrefix: 'mastra_', // optional
+});
+```
+
+## Supported Methods
+
+### Thread Operations
+
+- `saveThread(thread)`: Create or update a thread
+- `getThreadById({ threadId })`: Get a thread by ID
+- `getThreadsByResourceId({ resourceId })`: Fetch all threads associated with a resource.
+- `updateThread({ id, title, metadata })`: Update the title and/or metadata of a thread.
+- `deleteThread({ threadId })`: Delete a thread and all its messages.
+
+### Message Operations
+
+- `saveMessages({ messages })`: Save multiple messages in a batch operation (uses prepared statements).
+- `getMessages({ threadId, selectBy? })`: Retrieve messages for a thread, with optional filtering (e.g., last N, include surrounding messages).
+
+### Workflow Operations
+
+- `persistWorkflowSnapshot({ workflowName, runId, snapshot })`: Save workflow state for a given workflow/run.
+- `loadWorkflowSnapshot({ workflowName, runId })`: Load persisted workflow state.
+
+### Trace/Evaluation Operations
+
+- `getTraces({ name?, scope?, page, perPage, attributes? })`: Query trace records with optional filters and pagination.
+- `getEvalsByAgentName({ agentName, type? })`: Query evaluation results by agent name.
+
+### Utility
+
+- `clearTable({ tableName })`: Remove all records from a logical table.
+- `batchInsert({ tableName, records })`: Batch insert multiple records.
+- `insert({ tableName, record })`: Insert a single record into a table.
+
+---
+
+## Data Types
+
+The D1 store supports the following data types:
+
+- `text`: String
+- `timestamp`: ISO8601 string (converted to/from Date)
+- `uuid`: String
+- `jsonb`: JSON-encoded object
+- `integer`: Integer (for internal counters, etc)
+
+All metadata and custom fields are automatically serialized/deserialized as JSON.
+
+---
+
+## Configuration Reference
+
+| Option      | Type       | Description                          |
+| ----------- | ---------- | ------------------------------------ |
+| binding     | D1Database | D1 Workers binding (for Workers)     |
+| accountId   | string     | Cloudflare Account ID (for REST API) |
+| databaseId  | string     | D1 Database ID (for REST API)        |
+| apiToken    | string     | Cloudflare API Token (for REST API)  |
+| tablePrefix | string     | Optional prefix for all table names  |
+
+---
+
+## Table/Namespace Mapping
+
+Each logical Mastra table maps to a SQL table in D1 (with optional prefix):
+
+- `mastra_threads` — stores threads
+- `mastra_messages` — stores messages
+- `mastra_workflow_snapshot` — stores workflow snapshots
+- `mastra_evals` — stores evaluations
+- `mastra_traces` — stores traces
+
+(The prefix is configurable via `tablePrefix`.)
+
+---
+
+## Limitations
+
+- No multi-statement transactions (D1 currently supports single statements per query)
+- No advanced SQL joins (D1 is SQLite-based, but some features may be limited)
+- Batch operations are processed in chunks, not truly atomic
+- Some REST API operations may be slower than Workers binding
+- D1 is in beta and may have evolving limitations
+- No vector search capabilities
+- Note: D1 has specific limitations and behaviors, please refer to the official Cloudflare D1 documentation for more information.
+
+## Cleanup / Disconnect
+
+No explicit cleanup is required. Connections are managed by the platform.

package/dist/_tsup-dts-rollup.d.cts

@@ -0,0 +1,313 @@
+import type { D1Database as D1Database_2 } from '@cloudflare/workers-types';
+import type { EvalRow } from '@mastra/core/storage';
+import { MastraStorage } from '@mastra/core/storage';
+import type { MessageType } from '@mastra/core/memory';
+import type { StorageColumn } from '@mastra/core/storage';
+import type { StorageGetMessagesArg } from '@mastra/core/storage';
+import type { StorageThreadType } from '@mastra/core/memory';
+import type { TABLE_NAMES } from '@mastra/core/storage';
+import type { WorkflowRuns } from '@mastra/core/storage';
+import type { WorkflowRunState } from '@mastra/core/workflows';
+import type { WorkflowRunState as WorkflowRunState_2 } from '@mastra/core';
+
+export declare const createSampleMessage: (threadId: string) => any;
+
+export declare const createSampleThread: () => {
+    id: string;
+    resourceId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata: {
+        key: string;
+    };
+};
+
+export declare const createSampleThreadWithParams: (threadId: string, resourceId: string, createdAt: Date, updatedAt: Date) => {
+    id: string;
+    resourceId: string;
+    title: string;
+    createdAt: Date;
+    updatedAt: Date;
+    metadata: {
+        key: string;
+    };
+};
+
+export declare const createSampleTrace: (name: string, scope?: string, attributes?: Record<string, string>) => {
+    id: string;
+    parentSpanId: string;
+    traceId: string;
+    name: string;
+    scope: string | undefined;
+    kind: string;
+    status: string;
+    events: string;
+    links: string;
+    attributes: string | undefined;
+    startTime: string;
+    endTime: string;
+    other: string;
+    createdAt: string;
+};
+
+export declare const createSampleWorkflowSnapshot: (threadId: string) => WorkflowRunState_2;
+
+export declare function createSqlBuilder(): SqlBuilder;
+
+/**
+ * Configuration for D1 using the REST API
+ */
+declare interface D1Config {
+    /** Cloudflare account ID */
+    accountId: string;
+    /** Cloudflare API token with D1 access */
+    apiToken: string;
+    /** D1 database ID */
+    databaseId: string;
+    /** Optional prefix for table names */
+    tablePrefix?: string;
+}
+export { D1Config }
+export { D1Config as D1Config_alias_1 }
+
+declare class D1Store extends MastraStorage {
+    private client?;
+    private accountId?;
+    private databaseId?;
+    private binding?;
+    private tablePrefix;
+    /**
+     * Creates a new D1Store instance
+     * @param config Configuration for D1 access (either REST API or Workers Binding API)
+     */
+    constructor(config: D1StoreConfig);
+    private getTableName;
+    private formatSqlParams;
+    private createIndexIfNotExists;
+    private executeWorkersBindingQuery;
+    private executeRestQuery;
+    /**
+     * 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
+     */
+    private executeQuery;
+    private getSqlType;
+    private ensureDate;
+    private serializeDate;
+    private serializeValue;
+    private deserializeValue;
+    createTable({ tableName, schema, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+    }): Promise<void>;
+    clearTable({ tableName }: {
+        tableName: TABLE_NAMES;
+    }): Promise<void>;
+    private processRecord;
+    insert({ tableName, record }: {
+        tableName: TABLE_NAMES;
+        record: Record<string, any>;
+    }): Promise<void>;
+    load<R>({ tableName, keys }: {
+        tableName: TABLE_NAMES;
+        keys: Record<string, string>;
+    }): Promise<R | null>;
+    getThreadById({ threadId }: {
+        threadId: string;
+    }): Promise<StorageThreadType | null>;
+    getThreadsByResourceId({ resourceId }: {
+        resourceId: string;
+    }): Promise<StorageThreadType[]>;
+    saveThread({ thread }: {
+        thread: StorageThreadType;
+    }): Promise<StorageThreadType>;
+    updateThread({ id, title, metadata, }: {
+        id: string;
+        title: string;
+        metadata: Record<string, unknown>;
+    }): Promise<StorageThreadType>;
+    deleteThread({ threadId }: {
+        threadId: string;
+    }): Promise<void>;
+    saveMessages({ messages }: {
+        messages: MessageType[];
+    }): Promise<MessageType[]>;
+    getMessages<T = MessageType>({ threadId, selectBy }: StorageGetMessagesArg): Promise<T[]>;
+    persistWorkflowSnapshot({ workflowName, runId, snapshot, }: {
+        workflowName: string;
+        runId: string;
+        snapshot: WorkflowRunState;
+    }): Promise<void>;
+    loadWorkflowSnapshot(params: {
+        workflowName: string;
+        runId: string;
+    }): Promise<WorkflowRunState | null>;
+    /**
+     * Insert multiple records in a batch operation
+     * @param tableName The table to insert into
+     * @param records The records to insert
+     */
+    batchInsert({ tableName, records }: {
+        tableName: TABLE_NAMES;
+        records: Record<string, any>[];
+    }): Promise<void>;
+    getTraces({ name, scope, page, perPage, attributes, }: {
+        name?: string;
+        scope?: string;
+        page: number;
+        perPage: number;
+        attributes?: Record<string, string>;
+    }): Promise<Record<string, any>[]>;
+    getEvalsByAgentName(agentName: string, type?: 'test' | 'live'): Promise<EvalRow[]>;
+    getWorkflowRuns(_args?: {
+        workflowName?: string;
+        fromDate?: Date;
+        toDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<WorkflowRuns>;
+    /**
+     * Close the database connection
+     * No explicit cleanup needed for D1 in either REST or Workers Binding mode
+     */
+    close(): Promise<void>;
+}
+export { D1Store }
+export { D1Store as D1Store_alias_1 }
+
+/**
+ * Combined configuration type supporting both REST API and Workers Binding API
+ */
+declare type D1StoreConfig = D1Config | D1WorkersConfig;
+export { D1StoreConfig }
+export { D1StoreConfig as D1StoreConfig_alias_1 }
+
+/**
+ * Configuration for D1 using the Workers Binding API
+ */
+declare interface D1WorkersConfig {
+    /** D1 database binding from Workers environment */
+    binding: D1Database_2;
+    /** Optional prefix for table names */
+    tablePrefix?: string;
+}
+export { D1WorkersConfig }
+export { D1WorkersConfig as D1WorkersConfig_alias_1 }
+
+export declare const retryUntil: <T>(fn: () => Promise<T>, condition: (result: T) => boolean, timeout?: number, // REST API needs longer timeout due to higher latency
+interval?: number) => Promise<T>;
+
+/**
+ * SQL Builder class for constructing type-safe SQL queries
+ * This helps create maintainable and secure SQL queries with proper parameter handling
+ */
+export declare class SqlBuilder {
+    private sql;
+    private params;
+    private whereAdded;
+    select(columns?: string | string[]): SqlBuilder;
+    from(table: string): SqlBuilder;
+    /**
+     * Add a WHERE clause to the query
+     * @param condition The condition to add
+     * @param params Parameters to bind to the condition
+     */
+    where(condition: string, ...params: SqlParam[]): SqlBuilder;
+    /**
+     * 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: string, ...params: SqlParam[]): SqlBuilder;
+    andWhere(condition: string, ...params: SqlParam[]): SqlBuilder;
+    orWhere(condition: string, ...params: SqlParam[]): SqlBuilder;
+    orderBy(column: string, direction?: 'ASC' | 'DESC'): SqlBuilder;
+    limit(count: number): SqlBuilder;
+    offset(count: number): SqlBuilder;
+    /**
+     * 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: string, columns: string[], values: SqlParam[], conflictColumns?: string[], updateMap?: Record<string, string>): SqlBuilder;
+    update(table: string, columns: string[], values: SqlParam[]): SqlBuilder;
+    delete(table: string): SqlBuilder;
+    /**
+     * 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: string, columnDefinitions: string[], tableConstraints?: string[]): SqlBuilder;
+    /**
+     * 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: string, tableName: string): SqlBuilder;
+    /**
+     * 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: string, tableName: string, columnName: string, indexType?: string): SqlBuilder;
+    raw(sql: string, ...params: SqlParam[]): SqlBuilder;
+    /**
+     * 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: string, value: string, exact?: boolean): SqlBuilder;
+    /**
+     * 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: string, key: string, value: string): SqlBuilder;
+    /**
+     * Get the built query
+     * @returns Object containing the SQL string and parameters array
+     */
+    build(): {
+        sql: string;
+        params: SqlParam[];
+    };
+    /**
+     * Reset the builder for reuse
+     * @returns The reset builder instance
+     */
+    reset(): SqlBuilder;
+}
+
+/**
+ * Type definition for SQL query parameters
+ */
+export declare type SqlParam = string | number | boolean | null | undefined;
+
+/**
+ * Interface for SQL query options with generic type support
+ */
+declare interface SqlQueryOptions {
+    /** SQL query to execute */
+    sql: string;
+    /** Parameters to bind to the query */
+    params?: SqlParam[];
+    /** Whether to return only the first result */
+    first?: boolean;
+}
+export { SqlQueryOptions }
+export { SqlQueryOptions as SqlQueryOptions_alias_1 }
+
+export { }