crossmate

PersistenceController.swift (8231B)

---

 import CoreData
 import Foundation
 
 /// Wraps the app's `NSPersistentContainer`. Plain Core Data with no
 /// CloudKit mirroring — sync (single-user iPhone↔iPad and CKShare
 /// collaboration alike) is the job of a separate sync engine that will
 /// drive CloudKit directly on top of this same store. See PLAN.md for the
 /// layered design.
 @MainActor
 final class PersistenceController {
     let container: NSPersistentContainer
 
     var viewContext: NSManagedObjectContext { container.viewContext }
 
     private let eventLog: EventLog?
 
     init(inMemory: Bool = false, storeURL: URL? = nil, eventLog: EventLog? = nil) {
         self.eventLog = eventLog
         container = NSPersistentContainer(
             name: "CrossmateModel",
             managedObjectModel: Self.sharedModel
         )
 
         if inMemory {
             // NSInMemoryStoreType keeps each store fully isolated in process
             // memory with no file involvement, which prevents concurrent test
             // runs from colliding through shared SQLite WAL files at /dev/null.
             let description = NSPersistentStoreDescription()
             description.type = NSInMemoryStoreType
             container.persistentStoreDescriptions = [description]
         } else {
             // The app always uses the container's default location; tests
             // point the store at a throwaway URL to exercise the on-disk
             // load/recovery path without touching real data.
             if let storeURL {
                 container.persistentStoreDescriptions = [
                     NSPersistentStoreDescription(url: storeURL)
                 ]
             }
             // Enable lightweight migration so additive schema changes — and
             // attribute renames carrying a `renamingIdentifier` in the model
             // — apply on launch without a hand-written mapping. A non-additive
             // change made in place (no prior model version kept as a migration
             // source) can't be inferred; `recreateStore(after:)` handles that
             // by discarding and rebuilding the store.
             for description in container.persistentStoreDescriptions {
                 description.shouldMigrateStoreAutomatically = true
                 description.shouldInferMappingModelAutomatically = true
             }
         }
 
         container.loadPersistentStores { [self] _, error in
             guard let error else { return }
             if inMemory {
                 fatalError("Failed to load in-memory Core Data store: \(error)")
             }
             recreateStore(after: error)
         }
 
         container.viewContext.automaticallyMergesChangesFromParent = true
         container.viewContext.mergePolicy = NSMergePolicy.mergeByPropertyObjectTrump
 
         if !inMemory {
             backfillCachedSummaryFields()
         }
     }
 
     /// Rebuilds the store empty when an existing one can't be opened against
     /// the current model — e.g. after an in-place schema change with no
     /// migration source. The store is *usually* a rebuildable cache of CloudKit
     /// (the sync engine refetches every record on the next sync), but not
     /// always: iCloud sync is user-toggleable, making the local store the only
     /// copy of that user's games, and even with sync on, offline edits may not
     /// have uploaded yet. The failing files are therefore moved aside under a
     /// `.broken-<timestamp>` suffix rather than destroyed, so the data stays
     /// inspectable and recoverable, and the recovery is surfaced through
     /// diagnostics.
     private func recreateStore(after originalError: Error) {
         let coordinator = container.persistentStoreCoordinator
         var preserved: [String] = []
         for description in container.persistentStoreDescriptions {
             guard let url = description.url else { continue }
             preserved.append(contentsOf: preserveBrokenStore(at: url))
             do {
                 try coordinator.destroyPersistentStore(
                     at: url,
                     ofType: description.type,
                     options: description.options
                 )
             } catch {
                 // Best effort — fall through and let the reload attempt report
                 // the real failure if the store truly can't be replaced.
             }
         }
         container.loadPersistentStores { _, retryError in
             if let retryError {
                 fatalError(
                     "Failed to load Core Data store after reset: \(retryError) "
                     + "(original open error: \(originalError))"
                 )
             }
         }
         eventLog?.note(
             "PersistenceController: store load failed; rebuilt empty"
             + (preserved.isEmpty
                 ? " (no files to preserve)"
                 : " (broken store preserved as \(preserved.joined(separator: ", ")))")
             + " — \(originalError)",
             level: "error"
         )
     }
 
     /// Moves the failing store's files (including the `-wal`/`-shm` sidecars)
     /// aside before destructive recovery, returning the names of the files it
     /// preserved. Best effort: a file that can't be moved is left in place for
     /// `destroyPersistentStore` to clear, so recovery always proceeds.
     private func preserveBrokenStore(at url: URL) -> [String] {
         let fileManager = FileManager.default
         let formatter = DateFormatter()
         formatter.dateFormat = "yyyyMMdd-HHmmss"
         formatter.timeZone = TimeZone(secondsFromGMT: 0)
         let timestamp = formatter.string(from: Date())
         var preserved: [String] = []
         for suffix in ["", "-wal", "-shm"] {
             let source = URL(fileURLWithPath: url.path + suffix)
             guard fileManager.fileExists(atPath: source.path) else { continue }
             let destination = URL(fileURLWithPath: source.path + ".broken-\(timestamp)")
             do {
                 try fileManager.moveItem(at: source, to: destination)
                 preserved.append(destination.lastPathComponent)
             } catch {
                 // Leave the file for destroyPersistentStore.
             }
         }
         return preserved
     }
 
     /// One-shot pass for `GameEntity` rows created before cached summary
     /// fields were wired into the creation paths. Runs off the main thread,
     /// no-ops on every subsequent launch.
     private func backfillCachedSummaryFields() {
         let bg = container.newBackgroundContext()
         bg.perform {
             let req = NSFetchRequest<GameEntity>(entityName: "GameEntity")
             req.predicate = NSPredicate(
                 format: "gridWidth == 0 AND puzzleSource != nil AND puzzleSource != %@",
                 ""
             )
             guard let rows = try? bg.fetch(req), !rows.isEmpty else { return }
             for entity in rows {
                 guard let source = entity.puzzleSource,
                       let xd = try? XD.parse(source) else { continue }
                 entity.populateCachedSummaryFields(from: Puzzle(xd: xd))
             }
             if bg.hasChanges {
                 do {
                     try bg.save()
                 } catch {
                     Task { @MainActor [weak self] in
                         self?.eventLog?.note(
                             "PersistenceController: backfillCachedSummaryFields save failed — \(error)",
                             level: "error"
                         )
                     }
                 }
             }
         }
     }
 
     // Loaded once and shared across all container instances so that entity
     // descriptions are identical objects, which is required for CoreData
     // relationship type-checking to pass when tests create multiple containers
     // concurrently.
     private static let sharedModel: NSManagedObjectModel = {
         for bundle in Bundle.allBundles + Bundle.allFrameworks {
             if let url = bundle.url(forResource: "CrossmateModel", withExtension: "momd"),
                let model = NSManagedObjectModel(contentsOf: url) {
                 return model
             }
         }
         fatalError("CrossmateModel.momd not found in any loaded bundle")
     }()
 }