@mastra/libsql 0.13.8-alpha.0 → 0.13.8-alpha.2

package/src/storage/domains/scores/index.ts

@@ -1,226 +0,0 @@
-import type { Client, InValue } from '@libsql/client';
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import type { ScoreRowData, ScoringSource } from '@mastra/core/scores';
-import { TABLE_SCORERS, ScoresStorage, safelyParseJSON } from '@mastra/core/storage';
-import type { PaginationInfo, StoragePagination } from '@mastra/core/storage';
-import type { StoreOperationsLibSQL } from '../operations';
-
-export class ScoresLibSQL extends ScoresStorage {
-  private operations: StoreOperationsLibSQL;
-  private client: Client;
-  constructor({ client, operations }: { client: Client; operations: StoreOperationsLibSQL }) {
-    super();
-    this.operations = operations;
-    this.client = client;
-  }
-
-  async getScoresByRunId({
-    runId,
-    pagination,
-  }: {
-    runId: string;
-    pagination: StoragePagination;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE runId = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [runId, pagination.perPage + 1, pagination.page * pagination.perPage],
-      });
-      return {
-        scores: result.rows?.slice(0, pagination.perPage).map(row => this.transformScoreRow(row)) ?? [],
-        pagination: {
-          total: result.rows?.length ?? 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: result.rows?.length > pagination.perPage,
-        },
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_GET_SCORES_BY_RUN_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoresByScorerId({
-    scorerId,
-    entityId,
-    entityType,
-    source,
-    pagination,
-  }: {
-    scorerId: string;
-    entityId?: string;
-    entityType?: string;
-    source?: ScoringSource;
-    pagination: StoragePagination;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const conditions: string[] = [];
-      const queryParams: InValue[] = [];
-
-      if (scorerId) {
-        conditions.push(`scorerId = ?`);
-        queryParams.push(scorerId);
-      }
-
-      if (entityId) {
-        conditions.push(`entityId = ?`);
-        queryParams.push(entityId);
-      }
-
-      if (entityType) {
-        conditions.push(`entityType = ?`);
-        queryParams.push(entityType);
-      }
-
-      if (source) {
-        conditions.push(`source = ?`);
-        queryParams.push(source);
-      }
-
-      const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} ${whereClause} ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [...queryParams, pagination.perPage + 1, pagination.page * pagination.perPage],
-      });
-
-      return {
-        scores: result.rows?.slice(0, pagination.perPage).map(row => this.transformScoreRow(row)) ?? [],
-        pagination: {
-          total: result.rows?.length ?? 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: result.rows?.length > pagination.perPage,
-        },
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_GET_SCORES_BY_SCORER_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  private transformScoreRow(row: Record<string, any>): ScoreRowData {
-    const scorerValue = safelyParseJSON(row.scorer);
-    const inputValue = safelyParseJSON(row.input ?? '{}');
-    const outputValue = safelyParseJSON(row.output ?? '{}');
-    const additionalLLMContextValue = row.additionalLLMContext ? safelyParseJSON(row.additionalLLMContext) : null;
-    const runtimeContextValue = row.runtimeContext ? safelyParseJSON(row.runtimeContext) : null;
-    const metadataValue = row.metadata ? safelyParseJSON(row.metadata) : null;
-    const entityValue = row.entity ? safelyParseJSON(row.entity) : null;
-    const preprocessStepResultValue = row.preprocessStepResult ? safelyParseJSON(row.preprocessStepResult) : null;
-    const analyzeStepResultValue = row.analyzeStepResult ? safelyParseJSON(row.analyzeStepResult) : null;
-
-    return {
-      id: row.id,
-      traceId: row.traceId,
-      runId: row.runId,
-      scorer: scorerValue,
-      score: row.score,
-      reason: row.reason,
-      preprocessStepResult: preprocessStepResultValue,
-      analyzeStepResult: analyzeStepResultValue,
-      analyzePrompt: row.analyzePrompt,
-      preprocessPrompt: row.preprocessPrompt,
-      generateScorePrompt: row.generateScorePrompt,
-      generateReasonPrompt: row.generateReasonPrompt,
-      metadata: metadataValue,
-      input: inputValue,
-      output: outputValue,
-      additionalContext: additionalLLMContextValue,
-      runtimeContext: runtimeContextValue,
-      entityType: row.entityType,
-      entity: entityValue,
-      entityId: row.entityId,
-      scorerId: row.scorerId,
-      source: row.source,
-      resourceId: row.resourceId,
-      threadId: row.threadId,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-    };
-  }
-
-  async getScoreById({ id }: { id: string }): Promise<ScoreRowData | null> {
-    const result = await this.client.execute({
-      sql: `SELECT * FROM ${TABLE_SCORERS} WHERE id = ?`,
-      args: [id],
-    });
-    return result.rows?.[0] ? this.transformScoreRow(result.rows[0]) : null;
-  }
-
-  async saveScore(score: Omit<ScoreRowData, 'id' | 'createdAt' | 'updatedAt'>): Promise<{ score: ScoreRowData }> {
-    try {
-      const id = crypto.randomUUID();
-
-      await this.operations.insert({
-        tableName: TABLE_SCORERS,
-        record: {
-          id,
-          createdAt: new Date().toISOString(),
-          updatedAt: new Date().toISOString(),
-          ...score,
-        },
-      });
-
-      const scoreFromDb = await this.getScoreById({ id });
-      return { score: scoreFromDb! };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_SAVE_SCORE_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async getScoresByEntityId({
-    entityId,
-    entityType,
-    pagination,
-  }: {
-    pagination: StoragePagination;
-    entityId: string;
-    entityType: string;
-  }): Promise<{ pagination: PaginationInfo; scores: ScoreRowData[] }> {
-    try {
-      const result = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_SCORERS} WHERE entityId = ? AND entityType = ? ORDER BY createdAt DESC LIMIT ? OFFSET ?`,
-        args: [entityId, entityType, pagination.perPage + 1, pagination.page * pagination.perPage],
-      });
-      return {
-        scores: result.rows?.slice(0, pagination.perPage).map(row => this.transformScoreRow(row)) ?? [],
-        pagination: {
-          total: result.rows?.length ?? 0,
-          page: pagination.page,
-          perPage: pagination.perPage,
-          hasMore: result.rows?.length > pagination.perPage,
-        },
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_GET_SCORES_BY_ENTITY_ID_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-}

package/src/storage/domains/traces/index.ts

@@ -1,150 +0,0 @@
-import type { Client, InValue } from '@libsql/client';
-import { ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
-import { TABLE_TRACES, TracesStorage, safelyParseJSON } from '@mastra/core/storage';
-import type { StorageGetTracesArg, StorageGetTracesPaginatedArg, PaginationInfo } from '@mastra/core/storage';
-import type { Trace } from '@mastra/core/telemetry';
-import { parseSqlIdentifier } from '@mastra/core/utils';
-import type { StoreOperationsLibSQL } from '../operations';
-
-export class TracesLibSQL extends TracesStorage {
-  private client: Client;
-  private operations: StoreOperationsLibSQL;
-
-  constructor({ client, operations }: { client: Client; operations: StoreOperationsLibSQL }) {
-    super();
-    this.client = client;
-    this.operations = operations;
-  }
-
-  async getTraces(args: StorageGetTracesArg): Promise<Trace[]> {
-    if (args.fromDate || args.toDate) {
-      (args as any).dateRange = {
-        start: args.fromDate,
-        end: args.toDate,
-      };
-    }
-    try {
-      const result = await this.getTracesPaginated(args);
-      return result.traces;
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_GET_TRACES_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async getTracesPaginated(args: StorageGetTracesPaginatedArg): Promise<PaginationInfo & { traces: Trace[] }> {
-    const { name, scope, page = 0, perPage = 100, attributes, filters, dateRange } = args;
-    const fromDate = dateRange?.start;
-    const toDate = dateRange?.end;
-    const currentOffset = page * perPage;
-
-    const queryArgs: InValue[] = [];
-    const conditions: string[] = [];
-
-    if (name) {
-      conditions.push('name LIKE ?');
-      queryArgs.push(`${name}%`);
-    }
-    if (scope) {
-      conditions.push('scope = ?');
-      queryArgs.push(scope);
-    }
-    if (attributes) {
-      Object.entries(attributes).forEach(([key, value]) => {
-        conditions.push(`json_extract(attributes, '$.${key}') = ?`);
-        queryArgs.push(value);
-      });
-    }
-    if (filters) {
-      Object.entries(filters).forEach(([key, value]) => {
-        conditions.push(`${parseSqlIdentifier(key, 'filter key')} = ?`);
-        queryArgs.push(value);
-      });
-    }
-    if (fromDate) {
-      conditions.push('createdAt >= ?');
-      queryArgs.push(fromDate.toISOString());
-    }
-    if (toDate) {
-      conditions.push('createdAt <= ?');
-      queryArgs.push(toDate.toISOString());
-    }
-
-    const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(' AND ')}` : '';
-
-    try {
-      const countResult = await this.client.execute({
-        sql: `SELECT COUNT(*) as count FROM ${TABLE_TRACES} ${whereClause}`,
-        args: queryArgs,
-      });
-      const total = Number(countResult.rows?.[0]?.count ?? 0);
-
-      if (total === 0) {
-        return {
-          traces: [],
-          total: 0,
-          page,
-          perPage,
-          hasMore: false,
-        };
-      }
-
-      const dataResult = await this.client.execute({
-        sql: `SELECT * FROM ${TABLE_TRACES} ${whereClause} ORDER BY "startTime" DESC LIMIT ? OFFSET ?`,
-        args: [...queryArgs, perPage, currentOffset],
-      });
-
-      const traces =
-        dataResult.rows?.map(
-          row =>
-            ({
-              id: row.id,
-              parentSpanId: row.parentSpanId,
-              traceId: row.traceId,
-              name: row.name,
-              scope: row.scope,
-              kind: row.kind,
-              status: safelyParseJSON(row.status),
-              events: safelyParseJSON(row.events),
-              links: safelyParseJSON(row.links),
-              attributes: safelyParseJSON(row.attributes),
-              startTime: row.startTime,
-              endTime: row.endTime,
-              other: safelyParseJSON(row.other),
-              createdAt: row.createdAt,
-            }) as Trace,
-        ) ?? [];
-
-      return {
-        traces,
-        total,
-        page,
-        perPage,
-        hasMore: currentOffset + traces.length < total,
-      };
-    } catch (error) {
-      throw new MastraError(
-        {
-          id: 'LIBSQL_STORE_GET_TRACES_PAGINATED_FAILED',
-          domain: ErrorDomain.STORAGE,
-          category: ErrorCategory.THIRD_PARTY,
-        },
-        error,
-      );
-    }
-  }
-
-  async batchTraceInsert({ records }: { records: Record<string, any>[] }): Promise<void> {
-    this.logger.debug('Batch inserting traces', { count: records.length });
-    await this.operations.batchInsert({
-      tableName: TABLE_TRACES,
-      records,
-    });
-  }
-}

package/src/storage/domains/utils.ts

@@ -1,272 +0,0 @@
-import type { InValue } from '@libsql/client';
-import type { IMastraLogger } from '@mastra/core/logger';
-import { safelyParseJSON, TABLE_SCHEMAS } from '@mastra/core/storage';
-import type { PaginationArgs, StorageColumn, TABLE_NAMES } from '@mastra/core/storage';
-import { parseSqlIdentifier } from '@mastra/core/utils';
-
-export function createExecuteWriteOperationWithRetry({
-  logger,
-  maxRetries,
-  initialBackoffMs,
-}: {
-  logger: IMastraLogger;
-  maxRetries: number;
-  initialBackoffMs: number;
-}) {
-  return async function executeWriteOperationWithRetry<T>(
-    operationFn: () => Promise<T>,
-    operationDescription: string,
-  ): Promise<T> {
-    let retries = 0;
-
-    while (true) {
-      try {
-        return await operationFn();
-      } catch (error: any) {
-        if (
-          error.message &&
-          (error.message.includes('SQLITE_BUSY') || error.message.includes('database is locked')) &&
-          retries < maxRetries
-        ) {
-          retries++;
-          const backoffTime = initialBackoffMs * Math.pow(2, retries - 1);
-          logger.warn(
-            `LibSQLStore: Encountered SQLITE_BUSY during ${operationDescription}. Retrying (${retries}/${maxRetries}) in ${backoffTime}ms...`,
-          );
-          await new Promise(resolve => setTimeout(resolve, backoffTime));
-        } else {
-          logger.error(`LibSQLStore: Error during ${operationDescription} after ${retries} retries: ${error}`);
-          throw error;
-        }
-      }
-    }
-  };
-}
-
-export function prepareStatement({ tableName, record }: { tableName: TABLE_NAMES; record: Record<string, any> }): {
-  sql: string;
-  args: InValue[];
-} {
-  const parsedTableName = parseSqlIdentifier(tableName, 'table name');
-  const columns = Object.keys(record).map(col => parseSqlIdentifier(col, 'column name'));
-  const values = Object.values(record).map(v => {
-    if (typeof v === `undefined` || v === null) {
-      // returning an undefined value will cause libsql to throw
-      return null;
-    }
-    if (v instanceof Date) {
-      return v.toISOString();
-    }
-    return typeof v === 'object' ? JSON.stringify(v) : v;
-  });
-  const placeholders = values.map(() => '?').join(', ');
-
-  return {
-    sql: `INSERT OR REPLACE INTO ${parsedTableName} (${columns.join(', ')}) VALUES (${placeholders})`,
-    args: values,
-  };
-}
-
-export function prepareUpdateStatement({
-  tableName,
-  updates,
-  keys,
-}: {
-  tableName: TABLE_NAMES;
-  updates: Record<string, any>;
-  keys: Record<string, any>;
-}): {
-  sql: string;
-  args: InValue[];
-} {
-  const parsedTableName = parseSqlIdentifier(tableName, 'table name');
-  const schema = TABLE_SCHEMAS[tableName];
-
-  // Prepare SET clause
-  const updateColumns = Object.keys(updates).map(col => parseSqlIdentifier(col, 'column name'));
-  const updateValues = Object.values(updates).map(transformToSqlValue);
-  const setClause = updateColumns.map(col => `${col} = ?`).join(', ');
-
-  const whereClause = prepareWhereClause(keys, schema);
-
-  return {
-    sql: `UPDATE ${parsedTableName} SET ${setClause}${whereClause.sql}`,
-    args: [...updateValues, ...whereClause.args],
-  };
-}
-
-export function transformToSqlValue(value: any): InValue {
-  if (typeof value === 'undefined' || value === null) {
-    return null;
-  }
-  if (value instanceof Date) {
-    return value.toISOString();
-  }
-  return typeof value === 'object' ? JSON.stringify(value) : value;
-}
-
-export function prepareDeleteStatement({ tableName, keys }: { tableName: TABLE_NAMES; keys: Record<string, any> }): {
-  sql: string;
-  args: InValue[];
-} {
-  const parsedTableName = parseSqlIdentifier(tableName, 'table name');
-  const whereClause = prepareWhereClause(keys, TABLE_SCHEMAS[tableName]);
-
-  return {
-    sql: `DELETE FROM ${parsedTableName}${whereClause.sql}`,
-    args: whereClause.args,
-  };
-}
-
-type WhereValue = InValue | { startAt?: InValue; endAt?: InValue };
-
-export function prepareWhereClause(
-  filters: Record<string, WhereValue>,
-  schema: Record<string, StorageColumn>,
-): {
-  sql: string;
-  args: InValue[];
-} {
-  const conditions: string[] = [];
-  const args: InValue[] = [];
-
-  for (const [columnName, filterValue] of Object.entries(filters)) {
-    const column = schema[columnName];
-    if (!column) {
-      throw new Error(`Unknown column: ${columnName}`);
-    }
-
-    const parsedColumn = parseSqlIdentifier(columnName, 'column name');
-    const result = buildCondition(parsedColumn, filterValue);
-
-    conditions.push(result.condition);
-    args.push(...result.args);
-  }
-
-  return {
-    sql: conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '',
-    args,
-  };
-}
-
-function buildCondition(columnName: string, filterValue: WhereValue): { condition: string; args: InValue[] } {
-  // Handle null values - IS NULL
-  if (filterValue === null) {
-    return { condition: `${columnName} IS NULL`, args: [] };
-  }
-
-  // Handle date range objects
-  if (typeof filterValue === 'object' && filterValue !== null && ('startAt' in filterValue || 'endAt' in filterValue)) {
-    return buildDateRangeCondition(columnName, filterValue);
-  }
-
-  // Handle exact match
-  return {
-    condition: `${columnName} = ?`,
-    args: [transformToSqlValue(filterValue)],
-  };
-}
-
-function buildDateRangeCondition(
-  columnName: string,
-  range: { startAt?: InValue; endAt?: InValue },
-): { condition: string; args: InValue[] } {
-  const conditions: string[] = [];
-  const args: InValue[] = [];
-
-  if (range.startAt !== undefined) {
-    conditions.push(`${columnName} >= ?`);
-    args.push(transformToSqlValue(range.startAt));
-  }
-
-  if (range.endAt !== undefined) {
-    conditions.push(`${columnName} <= ?`);
-    args.push(transformToSqlValue(range.endAt));
-  }
-
-  if (conditions.length === 0) {
-    throw new Error('Date range must specify at least startAt or endAt');
-  }
-
-  return {
-    condition: conditions.join(' AND '),
-    args,
-  };
-}
-
-type DateRangeFilter = {
-  startAt?: string;
-  endAt?: string;
-};
-
-/**
- * Converts pagination date range to where clause date range format
- * @param dateRange - The date range from pagination
- * @param columnName - The timestamp column to filter on (defaults to 'createdAt')
- * @returns Object with the date range filter, or empty object if no date range
- */
-export function buildDateRangeFilter(
-  dateRange?: PaginationArgs['dateRange'],
-  columnName: string = 'createdAt',
-): Record<string, DateRangeFilter> {
-  if (!dateRange?.start && !dateRange?.end) {
-    return {};
-  }
-
-  const filter: DateRangeFilter = {};
-
-  if (dateRange.start) {
-    filter.startAt = new Date(dateRange.start).toISOString();
-  }
-
-  if (dateRange.end) {
-    filter.endAt = new Date(dateRange.end).toISOString();
-  }
-
-  return { [columnName]: filter };
-}
-
-/**
- * Transforms SQL row data back to a typed object format
- * Reverses the transformations done in prepareStatement
- */
-export function transformFromSqlRow<T>({
-  tableName,
-  sqlRow,
-}: {
-  tableName: TABLE_NAMES;
-  sqlRow: Record<string, any>;
-}): T {
-  const result: Record<string, any> = {};
-  const jsonColumns = new Set(
-    Object.keys(TABLE_SCHEMAS[tableName])
-      .filter(key => TABLE_SCHEMAS[tableName][key]!.type === 'jsonb')
-      .map(key => key),
-  );
-  const dateColumns = new Set(
-    Object.keys(TABLE_SCHEMAS[tableName])
-      .filter(key => TABLE_SCHEMAS[tableName][key]!.type === 'timestamp')
-      .map(key => key),
-  );
-
-  for (const [key, value] of Object.entries(sqlRow)) {
-    if (value === null || value === undefined) {
-      result[key] = value;
-      continue;
-    }
-
-    if (dateColumns.has(key) && typeof value === 'string') {
-      result[key] = new Date(value);
-      continue;
-    }
-
-    if (jsonColumns.has(key) && typeof value === 'string') {
-      result[key] = safelyParseJSON(value);
-      continue;
-    }
-
-    result[key] = value;
-  }
-
-  return result as T;
-}