wrap migrations in a transaction, enable exclusive locking

Author: andykais

drivers/sqlite.ts

@@ -350,6 +350,19 @@ class Torm extends TormBase<sqlite3.DatabaseSync> {
     }
   }
 
+  public override transaction = <T>(fn: () => T) => (): T => {
+    try {
+      this.driver.exec('BEGIN TRANSACTION')
+      const result = fn()
+      this.driver.exec('COMMIT')
+      return result
+    } catch(e) {
+      this.driver.exec('ROLLBACK')
+      throw e
+    }
+  }
+
+
   private get_backup_name(folder: string, name: string, suffix?: number): string {
     const now = new Date()
     let backup_name = `${now.getUTCFullYear()}-${now.getUTCMonth().toString().padStart(2, '0')}-${now.getUTCDay().toString().padStart(2, '0')}_${name}`

src/migration.ts

@@ -159,10 +159,16 @@ class MigrationsManager {
     }
     const next_version = upgrade_versions.find(version => version > current_version)
     if (next_version === undefined) throw new Error('No new version exists. Database is up to date')
-    // TODO put a transaction around this block
+
     for (const migration of migration_map.get(next_version)!) {
       migration.prepare_queries()
-      migration.call()
+      if (migration.TRANSACTION) {
+        this.#torm.transaction(() => {
+          migration.call()
+        })()
+      } else {
+        migration.call()
+      }
     }
     this.#torm.schemas.unsafe_version_set(next_version)
 
@@ -225,6 +231,8 @@ interface MigrationClass {
 }
 
 interface MigrationInstance extends ModelBase {
+  /** Whether or not to use a transaction when running this migration. Disabling transactions around migrations should only be done if you know what you are doing. */
+  TRANSACTION: boolean
   version: Version
   call: (driver?: Driver) => void
   is_seed_migration(): boolean
@@ -233,6 +241,7 @@ interface MigrationInstance extends ModelBase {
 abstract class MigrationBase extends ModelBase implements MigrationInstance {
   public abstract version: Version
   public abstract call(driver?: Driver): void
+  public TRANSACTION: boolean = true
 
   public is_seed_migration(): boolean {
     return false

src/torm.ts

@@ -123,27 +123,34 @@ abstract class TormBase<D extends Driver> {
         this.migrations_manager.initialize_database()
       }
 
-      if (auto_migrate) {
-        while (this.migrations_manager.is_database_outdated()) {
-          this.status = 'outdated'
-          const current_version = this.schemas.version()
-          const migration_operation: MigrationOperation = {
-            start_version: current_version,
-            backup: false,
-            next_version: -1,
-          }
-          if (backup_before_migrate) {
-            if (!options?.backups?.folder) {
-              throw new Error(`backups_folder must be defined in order to use automatic backups`)
+      if (auto_migrate && this.migrations_manager.is_database_outdated()) {
+        try {
+          driver.exec(`PRAGMA locking_mode = EXCLUSIVE`)
+
+          while (this.migrations_manager.is_database_outdated()) {
+            this.status = 'outdated'
+            const current_version = this.schemas.version()
+            const migration_operation: MigrationOperation = {
+              start_version: current_version,
+              backup: false,
+              next_version: -1,
+            }
+            if (backup_before_migrate) {
+              if (!options?.backups?.folder) {
+                throw new Error(`backups_folder must be defined in order to use automatic backups`)
+              }
+              migration_operation.backup = true
+              this.backup(options.backups.folder, `migration_backup_v${current_version}`)
             }
-            migration_operation.backup = true
-            this.backup(options.backups.folder, `migration_backup_v${current_version}`)
+            const next_version = this.migrations_manager.upgrade_database()
+            migration_operation.next_version = next_version
+            migration_operations.push(migration_operation)
           }
-          const next_version = this.migrations_manager.upgrade_database()
-          migration_operation.next_version = next_version
-          migration_operations.push(migration_operation)
+          this.initialize_models()
+
+        } finally {
+          driver.exec(`PRAGMA locking_mode = normal`)
         }
-        this.initialize_models()
       }
       if (this.migrations_manager.is_database_outdated()) {
         this.status = 'outdated'
@@ -164,6 +171,8 @@ abstract class TormBase<D extends Driver> {
 
   public abstract backup(folder: string, name: string): void
 
+  public abstract transaction<T>(fn: () => T): () => T
+
   private initialize_models = () => {
     for (const model of this.model_registry) {
       model.prepare_queries()