@mastra/libsql 1.17.0-alpha.1 → 1.17.0-alpha.4

package/dist/index.js

@@ -13363,8 +13363,10 @@ function assertIdentifier(kind, name) {
   }
 }
 function isUniqueViolation(error) {
+  const code = typeof error === "object" && error !== null ? error.code : void 0;
+  if (code === "SQLITE_CONSTRAINT_UNIQUE" || code === "SQLITE_CONSTRAINT_PRIMARYKEY") return true;
   const message = error instanceof Error ? error.message : String(error);
-  return message.includes("UNIQUE constraint failed") || message.includes("SQLITE_CONSTRAINT");
+  return message.includes("UNIQUE constraint failed") || message.includes("SQLITE_CONSTRAINT_UNIQUE") || message.includes("SQLITE_CONSTRAINT_PRIMARYKEY");
 }
 function primaryKeyOf(schema) {
   const pks = Object.entries(schema.columns).filter(([, spec]) => spec.type === "uuid-pk" || spec.primaryKey);
@@ -13674,6 +13676,20 @@ var LibSQLFactoryStorage = class extends FactoryStorage {
   async initStorage() {
     await this.#client.execute("SELECT 1");
   }
+  async withTransaction(fn) {
+    if (this.#config.url.includes(":memory:")) return fn(this.ops);
+    const transaction = await this.#client.transaction("write");
+    try {
+      const result = await fn(new LibSQLFactoryStorageOps(transaction, this.#schemas));
+      await transaction.commit();
+      return result;
+    } catch (error) {
+      await transaction.rollback();
+      throw error;
+    } finally {
+      transaction.close();
+    }
+  }
   async ensureCollections(schemas) {
     for (const schema of schemas) {
       await this.#ensureCollection(schema);
@@ -13694,6 +13710,35 @@ var LibSQLFactoryStorage = class extends FactoryStorage {
     if (spec.default !== void 0) ddl += ` DEFAULT ${serializeDefault(spec.default)}`;
     return ddl;
   }
+  /**
+   * A table created by an older schema may still say NOT NULL on a column the
+   * current schema declares nullable — inserts of null then fail on databases
+   * that predate the change. SQLite has no `ALTER COLUMN DROP NOT NULL`, so
+   * relaxation swaps in a table rebuilt from the current schema (create shadow
+   * → copy → drop → rename) atomically.
+   */
+  async #relaxDriftedNotNulls(schema) {
+    const info = await this.#client.execute(`PRAGMA table_info("${schema.name}")`);
+    const hasDrift = info.rows.some((row) => {
+      const spec = schema.columns[String(row.name)];
+      if (!spec || spec.type === "uuid-pk" || spec.primaryKey) return false;
+      return spec.nullable === true && Number(row.notnull) === 1;
+    });
+    if (!hasDrift) return;
+    const ddl = Object.entries(schema.columns).map(([name, spec]) => this.#columnDdl(name, spec));
+    const shadow = `${schema.name}__nullable_rebuild`;
+    const cols = Object.keys(schema.columns).map((name) => `"${name}"`).join(", ");
+    await this.#client.batch(
+      [
+        `DROP TABLE IF EXISTS "${shadow}"`,
+        `CREATE TABLE "${shadow}" (${ddl.join(", ")})`,
+        `INSERT INTO "${shadow}" (${cols}) SELECT ${cols} FROM "${schema.name}"`,
+        `DROP TABLE "${schema.name}"`,
+        `ALTER TABLE "${shadow}" RENAME TO "${schema.name}"`
+      ],
+      "write"
+    );
+  }
   async #ensureCollection(schema) {
     assertIdentifier("collection", schema.name);
     primaryKeyOf(schema);
@@ -13705,6 +13750,7 @@ var LibSQLFactoryStorage = class extends FactoryStorage {
       if (existing.has(name)) continue;
       await this.#client.execute(`ALTER TABLE "${schema.name}" ADD COLUMN ${this.#columnDdl(name, spec)}`);
     }
+    await this.#relaxDriftedNotNulls(schema);
     for (const index of schema.uniqueIndexes ?? []) {
       assertIdentifier("index", index.name);
       index.columns.forEach((column) => assertIdentifier("column", column));