How to avoid Swift concurrency warnings?

[groue]

The Swift 5.10 compiler and concurrency checks can trigger warnings in your GRDB-powered application.

The future GRDB 7 aims at solving those warnings. Meanwhile, you might wonder how to fix them.

Please ask your questions below, so that we can share answers and best practices.

[groue]

Warnings in associations declarations

The Swift compiler can warn when you declare a association between record types:

import GRDB

extension Author: Codable, FetchableRecord, PersistableRecord {
  // ⚠️ Static property 'books' is not concurrency-safe because it is not
  // either conforming to 'Sendable' or isolated to a global actor;
  // this is an error in Swift 6
  static let books = hasMany(Book.self)
}

The reason for this warning is that GRBD associations do not conform to the Sendable protocol.

Associations will be sendable in the next major version, GRDB 7. Until, then please apply one of those techniques:

1. (SOON) Import GRDB with @preconcurrency:

   @preconcurrency import GRDB
   
   extension Author: Codable, FetchableRecord, PersistableRecord {
     static let books = hasMany(Book.self)
   }

   😬 Unfortunately, there is a bug in the Swift 5.10 compiler (Xcode 15.3) that prevents this technique from removing the warning 🤦

2. Declare the association as nonisolated(unsafe)

   import GRDB
   
   extension Author: Codable, FetchableRecord, PersistableRecord {
     // Declare associations as nonisolated until GRDB7.
     // This is safe according to <https://github.com/groue/GRDB.swift/discussions/1509>
     nonisolated(unsafe) static let books = hasMany(Book.self)
   }

   The "unsafe" word sounds scary, but the belongsTo(Author.self) association is completely safe. You will not have any problem at runtime. The type of this association is not marked as Sendable, which explains the compiler warning. But this particular instance of association has all the runtime properties of a sendable value. It won't blow up your program, 100% guaranteed. But you have to trust my words.

   How to be really unsafe

   It is possible to create an unsafe association, but it is really involved and nobody does that. For example, the association below is unsafe because it embeds a non-sendable type, and will invoke it from the various threads that connect to the database:

   extension Author {
     // UNSAFE ASSOCIATION
     static func wackyBooks(_ value: NonSendableType) -> HasManyAssociation<Author, Book> {
       Author.hasMany(Book.self).filterWhenConnected { db in
         Column("name") == value.description
       }
     }
   }

   Since you do not write code like that, your associations can safely be declared as nonisolated(unsafe.

[groue]

GRDB 7 solves the warnings of GRDB 6.