@mastra/cloudflare-d1 0.1.5-alpha.2

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

@@ -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 { }