@mastra/libsql 0.10.2-alpha.0 → 0.10.2-alpha.1

package/.turbo/turbo-build.log

@@ -1,23 +1,23 @@
 
-> @mastra/libsql@0.10.2-alpha.0 build /home/runner/work/mastra/mastra/stores/libsql
+> @mastra/libsql@0.10.2-alpha.1 build /home/runner/work/mastra/mastra/stores/libsql
 > tsup src/index.ts --format esm,cjs --experimental-dts --clean --treeshake=smallest --splitting
 
 CLI Building entry: src/index.ts
 CLI Using tsconfig: tsconfig.json
 CLI tsup v8.5.0
 TSC Build start
-TSC ⚡️ Build success in 9535ms
+TSC ⚡️ Build success in 10122ms
 DTS Build start
 CLI Target: es2022
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.ts
 Analysis will use the bundled TypeScript version 5.8.3
 Writing package typings: /home/runner/work/mastra/mastra/stores/libsql/dist/_tsup-dts-rollup.d.cts
-DTS ⚡️ Build success in 9079ms
+DTS ⚡️ Build success in 11851ms
 CLI Cleaning output folder
 ESM Build start
 CJS Build start
-ESM dist/index.js 55.48 KB
-ESM ⚡️ Build success in 980ms
-CJS dist/index.cjs 55.76 KB
-CJS ⚡️ Build success in 980ms
+ESM dist/index.js 57.43 KB
+ESM ⚡️ Build success in 1740ms
+CJS dist/index.cjs 57.72 KB
+CJS ⚡️ Build success in 1740ms

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @mastra/libsql
 
+## 0.10.2-alpha.1
+
+### Patch Changes
+
+- dffb67b: updated stores to add alter table and change tests
+- Updated dependencies [f6fd25f]
+- Updated dependencies [dffb67b]
+- Updated dependencies [f1309d3]
+- Updated dependencies [f7f8293]
+  - @mastra/core@0.10.4-alpha.1
+
 ## 0.10.2-alpha.0
 
 ### Patch Changes

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

@@ -89,6 +89,18 @@ declare class LibSQLStore extends MastraStorage {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;

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

@@ -89,6 +89,18 @@ declare class LibSQLStore extends MastraStorage {
         tableName: TABLE_NAMES;
         schema: Record<string, StorageColumn>;
     }): Promise<void>;
+    protected getSqlType(type: StorageColumn['type']): string;
+    /**
+     * Alters table schema to add columns if they don't exist
+     * @param tableName Name of the table
+     * @param schema Schema of the table
+     * @param ifNotExists Array of column names to add if they don't exist
+     */
+    alterTable({ tableName, schema, ifNotExists, }: {
+        tableName: TABLE_NAMES;
+        schema: Record<string, StorageColumn>;
+        ifNotExists: string[];
+    }): Promise<void>;
     clearTable({ tableName }: {
         tableName: TABLE_NAMES;
     }): Promise<void>;

package/dist/index.cjs

@@ -851,6 +851,52 @@ var LibSQLStore = class extends storage.MastraStorage {
       throw error;
     }
   }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return super.getSqlType(type);
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
+    try {
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
   async clearTable({ tableName }) {
     const parsedTableName = utils.parseSqlIdentifier(tableName, "table name");
     try {
@@ -1076,6 +1122,10 @@ var LibSQLStore = class extends storage.MastraStorage {
     return updatedThread;
   }
   async deleteThread({ threadId }) {
+    await this.client.execute({
+      sql: `DELETE FROM ${storage.TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId]
+    });
     await this.client.execute({
       sql: `DELETE FROM ${storage.TABLE_THREADS} WHERE id = ?`,
       args: [threadId]
@@ -1092,7 +1142,8 @@ var LibSQLStore = class extends storage.MastraStorage {
       content,
       role: row.role,
       createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
     if (row.type && row.type !== `v2`) result.type = row.type;
     return result;

package/dist/index.js

@@ -849,6 +849,52 @@ var LibSQLStore = class extends MastraStorage {
       throw error;
     }
   }
+  getSqlType(type) {
+    switch (type) {
+      case "bigint":
+        return "INTEGER";
+      // SQLite uses INTEGER for all integer sizes
+      case "jsonb":
+        return "TEXT";
+      // Store JSON as TEXT in SQLite
+      default:
+        return super.getSqlType(type);
+    }
+  }
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists
+  }) {
+    const parsedTableName = parseSqlIdentifier(tableName, "table name");
+    try {
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row) => row.name.toLowerCase()));
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type);
+          const nullable = columnDef.nullable === false ? "NOT NULL" : "";
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : "";
+          const alterSql = `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
   async clearTable({ tableName }) {
     const parsedTableName = parseSqlIdentifier(tableName, "table name");
     try {
@@ -1074,6 +1120,10 @@ var LibSQLStore = class extends MastraStorage {
     return updatedThread;
   }
   async deleteThread({ threadId }) {
+    await this.client.execute({
+      sql: `DELETE FROM ${TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId]
+    });
     await this.client.execute({
       sql: `DELETE FROM ${TABLE_THREADS} WHERE id = ?`,
       args: [threadId]
@@ -1090,7 +1140,8 @@ var LibSQLStore = class extends MastraStorage {
       content,
       role: row.role,
       createdAt: new Date(row.createdAt),
-      threadId: row.thread_id
+      threadId: row.thread_id,
+      resourceId: row.resourceId
     };
     if (row.type && row.type !== `v2`) result.type = row.type;
     return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mastra/libsql",
-  "version": "0.10.2-alpha.0",
+  "version": "0.10.2-alpha.1",
   "description": "Libsql provider for Mastra - includes both vector and db storage capabilities",
   "type": "module",
   "main": "dist/index.js",
@@ -28,10 +28,10 @@
     "eslint": "^9.28.0",
     "tsup": "^8.5.0",
     "typescript": "^5.8.3",
-    "vitest": "^3.1.2",
-    "@internal/lint": "0.0.10",
-    "@mastra/core": "0.10.4-alpha.0",
-    "@internal/storage-test-utils": "0.0.6"
+    "vitest": "^3.2.2",
+    "@mastra/core": "0.10.4-alpha.1",
+    "@internal/storage-test-utils": "0.0.6",
+    "@internal/lint": "0.0.10"
   },
   "peerDependencies": {
     "@mastra/core": "^0.10.2-alpha.0"

package/src/storage/index.test.ts

@@ -3,8 +3,9 @@ import {
   createSampleEval,
   createSampleTraceForDB,
   createSampleThread,
-  createSampleMessage,
   createTestSuite,
+  createSampleMessageV1,
+  resetRole,
 } from '@internal/storage-test-utils';
 import type { MastraMessageV1, StorageThreadType } from '@mastra/core';
 import { Mastra } from '@mastra/core/mastra';
@@ -243,16 +244,14 @@ describe('LibSQLStore Pagination Features', () => {
 
   describe('getMessages with pagination', () => {
     it('should return paginated messages with total count', async () => {
+      resetRole();
       const threadData = createSampleThread();
       threadData.resourceId = 'resource-msg-pagination';
       const thread = await store.saveThread({ thread: threadData as StorageThreadType });
 
       const messageRecords: MastraMessageV1[] = [];
       for (let i = 0; i < 15; i++) {
-        messageRecords.push({
-          ...createSampleMessage(thread.id),
-          content: [{ type: 'text', text: `Message ${i + 1}` }],
-        } as MastraMessageV1);
+        messageRecords.push(createSampleMessageV1({ threadId: thread.id, content: `Message ${i + 1}` }));
       }
       await store.saveMessages({ messages: messageRecords });
 
@@ -300,17 +299,21 @@ describe('LibSQLStore Pagination Features', () => {
 
       // Ensure timestamps are distinct for reliable sorting by creating them with a slight delay for testing clarity
       const messagesToSave: MastraMessageV1[] = [];
-      messagesToSave.push(createSampleMessage(thread.id, dayBeforeYesterday));
+      messagesToSave.push(
+        createSampleMessageV1({ threadId: thread.id, content: 'Message 1', createdAt: dayBeforeYesterday }),
+      );
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, dayBeforeYesterday));
+      messagesToSave.push(
+        createSampleMessageV1({ threadId: thread.id, content: 'Message 2', createdAt: dayBeforeYesterday }),
+      );
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, yesterday));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 3', createdAt: yesterday }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, yesterday));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 4', createdAt: yesterday }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, now));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 5', createdAt: now }));
       await new Promise(r => setTimeout(r, 5));
-      messagesToSave.push(createSampleMessage(thread.id, now));
+      messagesToSave.push(createSampleMessageV1({ threadId: thread.id, content: 'Message 6', createdAt: now }));
 
       await store.saveMessages({ messages: messagesToSave, format: 'v1' });
       // Total 6 messages: 2 now, 2 yesterday, 2 dayBeforeYesterday (oldest to newest)

package/src/storage/index.ts

@@ -125,6 +125,63 @@ export class LibSQLStore extends MastraStorage {
     }
   }
 
+  protected getSqlType(type: StorageColumn['type']): string {
+    switch (type) {
+      case 'bigint':
+        return 'INTEGER'; // SQLite uses INTEGER for all integer sizes
+      case 'jsonb':
+        return 'TEXT'; // Store JSON as TEXT in SQLite
+      default:
+        return super.getSqlType(type);
+    }
+  }
+
+  /**
+   * Alters table schema to add columns if they don't exist
+   * @param tableName Name of the table
+   * @param schema Schema of the table
+   * @param ifNotExists Array of column names to add if they don't exist
+   */
+  async alterTable({
+    tableName,
+    schema,
+    ifNotExists,
+  }: {
+    tableName: TABLE_NAMES;
+    schema: Record<string, StorageColumn>;
+    ifNotExists: string[];
+  }): Promise<void> {
+    const parsedTableName = parseSqlIdentifier(tableName, 'table name');
+
+    try {
+      // 1. Get existing columns using PRAGMA
+      const pragmaQuery = `PRAGMA table_info(${parsedTableName})`;
+      const result = await this.client.execute(pragmaQuery);
+      const existingColumnNames = new Set(result.rows.map((row: any) => row.name.toLowerCase()));
+
+      // 2. Add missing columns
+      for (const columnName of ifNotExists) {
+        if (!existingColumnNames.has(columnName.toLowerCase()) && schema[columnName]) {
+          const columnDef = schema[columnName];
+          const sqlType = this.getSqlType(columnDef.type); // ensure this exists or implement
+          const nullable = columnDef.nullable === false ? 'NOT NULL' : '';
+          // In SQLite, you must provide a DEFAULT if adding a NOT NULL column to a non-empty table
+          const defaultValue = columnDef.nullable === false ? this.getDefaultValue(columnDef.type) : '';
+          const alterSql =
+            `ALTER TABLE ${parsedTableName} ADD COLUMN "${columnName}" ${sqlType} ${nullable} ${defaultValue}`.trim();
+
+          await this.client.execute(alterSql);
+          this.logger?.debug?.(`Added column ${columnName} to table ${parsedTableName}`);
+        }
+      }
+    } catch (error) {
+      this.logger?.error?.(
+        `Error altering table ${tableName}: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      throw new Error(`Failed to alter table ${tableName}: ${error}`);
+    }
+  }
+
   async clearTable({ tableName }: { tableName: TABLE_NAMES }): Promise<void> {
     const parsedTableName = parseSqlIdentifier(tableName, 'table name');
     try {
@@ -414,11 +471,17 @@ export class LibSQLStore extends MastraStorage {
   }
 
   async deleteThread({ threadId }: { threadId: string }): Promise<void> {
+    // Delete messages for this thread (manual step)
+    await this.client.execute({
+      sql: `DELETE FROM ${TABLE_MESSAGES} WHERE thread_id = ?`,
+      args: [threadId],
+    });
+
     await this.client.execute({
       sql: `DELETE FROM ${TABLE_THREADS} WHERE id = ?`,
       args: [threadId],
     });
-    // Messages will be automatically deleted due to CASCADE constraint
+    // TODO: Need to check if CASCADE is enabled so that messages will be automatically deleted due to CASCADE constraint
   }
 
   private parseRow(row: any): MastraMessageV2 {
@@ -434,6 +497,7 @@ export class LibSQLStore extends MastraStorage {
       role: row.role,
       createdAt: new Date(row.createdAt as string),
       threadId: row.thread_id,
+      resourceId: row.resourceId,
     } as MastraMessageV2;
     if (row.type && row.type !== `v2`) result.type = row.type;
     return result;