SwiftUI update of deleted CoreData entities from different Tab

Code Block swift
struct Tab1: View {
    @Environment(\.managedObjectContext) var managedObjectContext
    @FetchRequest(entity: MyPersistenceObject.entity(),
                  sortDescriptors: [])
    var myPersistenceObjects: FetchedResults<MyPersistenceObject>
    ...
    ForEach(myPersistenceObjects, id: \.self) { myPersistenceObject in
         ListViewTab1(myPersistenceObject: myPersistenceObject)
    }
    

Code Block swift
struct Tab2: View {
    @FetchRequest(entity: MyPersistenceObjectParentParent.entity(),
                  sortDescriptors: [])
    private var parentParents: FetchedResults<MyPersistenceObjectParentParent>
}

Code Block 
struct Tab2Child: View {
    @Environment(\.managedObjectContext) var managedObjectContext
    @ObservedObject var parentParent: MyPersistenceObjectParentParent
    @FetchRequest
    var myPersistenceObjectParents: FetchedResults<MyPersistenceObjectParent>
    init(parentParent: MyPersistenceObjectParentParent) {
        self.parentParent = parentParent
        self._myPersistenceObjectParents = FetchRequest(entity: MyPersistenceObjectParent.entity(),
                                      sortDescriptors: [],
                                      predicate: NSPredicate(format: "parentParent = %@", argumentArray: [parentParent]))
    }

Code Block 
struct Detail-View2-Parent: View {
    @Environment(\.managedObjectContext) var managedObjectContext
    @ObservedObject
    var myPersistenceObjectParent: MyPersistenceObjectParent
    var body: some View {
        List {
                ForEach(myPersistenceObjectParent.myPersistenceObjects, id: \.self) { myPersistenceObject in
                    DetailView(myPersistenceObject: myPersistenceObject)
                }

• when a detail view is initialized, record the id of the object you display (you do have an id: UUID? attribute on the object, yes?).

• with every .onAppear() of the DetailView, use a Core Data fetch to see whether you still have a CD object with that id.

• if no such object exists, then just dismiss the detail view right away.

Code Block swift
struct DetailView: View {
    @State private var viewAppeared: Bool = false
    var body: some View {
        Group {
            RealDetailView()
            if viewAppeared {
                EmptyView()
        }.onAppear {
            viewAppeared.toggle()
        }
}

Code Block 
struct NotifyOfDeletionView: View {
    @Environment(\.managedObjectContext) var viewContext
    @Environment(\.presentationMode) var presentationMode
    @ObservedObject var managedObject: NSManagedObject
    var body: some View {
        Text(managedObject.objectID.description)
            .onReceive(
                NotificationCenter.default.publisher(for: .NSManagedObjectContextDidSave, object: viewContext),
                perform: dismissIfObjectIsDeleted(_:)
            )
    }
    private func dismissIfObjectIsDeleted(_ notification: Notification) {
let user
        if let userInfo = notification.userInfo,
           let deletedObjectIDs = userInfo[NSManagedObjectContext.NotificationKey.deletedObjectIDs] as? Set<NSManagedObjectID>,
           deletedObjectIDs.contains(managedObject.objectID) /* The object was deleted */
        {
            /* This will dismiss a modal (sheet/fullScreenCover) or pop the top view of a NavagationView stack */
            presentationMode.wrappedValue.dismiss()
        }
    }
}

Code Block swift
import SwiftUI
import CoreData
@main
struct SwiftUI_CoreData_ExApp: App {
    let persistenceController = PersistenceController.shared
    var body: some Scene {
        WindowGroup {
            TabView {
                View1().tabItem {
                    Image(systemName: "1.square.fill")
                    Text("Tab 1")
                }
                View1().tabItem {
                    Image(systemName: "2.square.fill")
                    Text("Tab 2")
                }
            }
            .environment(\.managedObjectContext, persistenceController.container.viewContext)
            .onAppear(perform: {
                let moc = persistenceController.container.viewContext
                /*Create persistence instances in Core Data database for test and reproduction purpose*/
                print("Preparing test data")
                let fetchRequest: NSFetchRequest<NSFetchRequestResult> = NSFetchRequest(entityName: Item.entity().name!)
                let deleteRequest = NSBatchDeleteRequest(fetchRequest: fetchRequest)
                try! moc.execute(deleteRequest)
                for i in 1..<4 {
                    let item = Item(context: moc)
                    item.name = "Item \(i)"
                }
                try! moc.save()
            })
        }
    }
}

Code Block swift
import SwiftUI
struct View1: View {
    @FetchRequest(entity: Item.entity(), sortDescriptors: [])
    private var items: FetchedResults<Item>
    
    var body: some View {
        NavigationView {
            List {
                ForEach(self.items, id: \.self) { item in
                    View1_Row(item: item)
                }
            }.listStyle(InsetGroupedListStyle())
            .navigationTitle("View 1")
        }
    }
}
struct View1_Row: View {
    @ObservedObject var item: Item
    @State var isView2Presented: Bool = false
    var body: some View {
        NavigationLink(
            destination: View2(item: item, isView2Presented: $isView2Presented),
            isActive: $isView2Presented,
            label: {
                Text("\(item.name ?? "missing item name") - View 2")
            })
            .isDetailLink(false)
    }
}

Code Block swift
import SwiftUI
struct View2: View {
    @Environment(\.managedObjectContext) var moc
    @ObservedObject var item: Item
    @Binding var isView2Presented: Bool
    
    var body: some View {
        List {
            Text("Item name: \(item.name ?? "item name unknown")")
            View2_Row(item: item)
            Button(action: { isView2Presented = false }, label: {Text("Dismiss")})
        }
        .listStyle(InsetGroupedListStyle())
        .navigationTitle("View 2")
        .onReceive(NotificationCenter.default.publisher(for: Notification.Name(rawValue: "Reset"))) { _ in
            print("\(Self.self) inside reset notification closure")
            self.isView2Presented = false
        }
        .onReceive(NotificationCenter.default.publisher(for: .NSManagedObjectContextDidSave, object: self.moc),
                   perform: dismissIfObjectIsDeleted(_:))
    }
    
    private func dismissIfObjectIsDeleted(_ notification: Notification) {
        if notification.isDeletion(of: self.item) {
            print("\(Self.self) dismissIfObjectIsDeleted Dismiss view after deletion of Item")
            isView2Presented = false
        }
    }
}
struct View2_Row : View {
    @ObservedObject var item: Item
    @State private var isView3Presented: Bool = false
        
    var body: some View {
        NavigationLink("View 3",
                       destination: View3(item: item,
                                          isView3Presented: $isView3Presented),
                       isActive: $isView3Presented)
        .isDetailLink(false)
    }
}

Code Block swift
import SwiftUI
struct View3: View {
    @Environment(\.managedObjectContext) var moc
    @ObservedObject var item: Item
    
    @State var isAddViewPresented: Bool = false
    @Binding var isView3Presented: Bool
    var body: some View {
        Group {
            List {
                Text("Item name: \(item.name ?? "item name unknown")")
                
                Button("DELETE this Item") {
                    moc.delete(self.item)
                    try! moc.save()
                    /*adding the next line does not matter:*/
                    /*NotificationCenter.default.post(Notification.init(name: Notification.Name(rawValue: "Reset")))*/
                }.foregroundColor(.red)
                
                Button(action: {
                    NotificationCenter.default.post(Notification.init(name: Notification.Name(rawValue: "Reset")))
                }, label: {Text("Reset")}).foregroundColor(.green)
                
                Button(action: {isView3Presented = false }, label: {Text("Dismiss")})
            }
        }
        .onReceive(NotificationCenter.default.publisher(for: .NSManagedObjectContextDidSave, object: self.moc),
                   perform: dismissIfObjectIsDeleted(_:))
        .onReceive(NotificationCenter.default.publisher(for: Notification.Name(rawValue: "Reset"))) { _ in
            print("\(Self.self) inside reset notification closure")
            self.isView3Presented = false
        }
        .listStyle(InsetGroupedListStyle())
        .navigationTitle("View 3")
        .toolbar {
            ToolbarItem {
                Button(action: {isAddViewPresented.toggle()}, label: {
                    Label("Add", systemImage: "plus.circle.fill")
                })
            }
        }
        .sheet(isPresented: $isAddViewPresented, content: {
            Text("DestinationDummyView")
        })
    }
    
    private func dismissIfObjectIsDeleted(_ notification: Notification) {
        if notification.isDeletion(of: self.item) {
            print("\(Self.self) dismissIfObjectIsDeleted Dismiss view after deletion of Item")
            isView3Presented = false
        }
    }
}

Code Block swift
import CoreData
extension Notification {
    /*Returns whether this notification is about the deletion of the given `NSManagedObject` instance*/
    func isDeletion(of managedObject: NSManagedObject) -> Bool {
        guard let deletedObjectIDs = self.deletedObjectIDs
        else {
            return false
        }
        return deletedObjectIDs.contains(managedObject.objectID)
    }
    private var deletedObjectIDs: [NSManagedObjectID]? {
        guard let deletedObjects =
                self.userInfo?[NSManagedObjectContext.NotificationKey.deletedObjects.rawValue]
                as? Set<NSManagedObject>,
              deletedObjects.count > 0
        else {
            return .none
        }
        return deletedObjects.map(\.objectID)
    }
}