A nestable transaction handler in Swift.

1. Transaction.swift

import Foundation

public final class Transaction {

    public enum Error: Swift.Error {
        case notInTransaction
    }

    private static let key = DispatchSpecificKey<Void>()

    public static func validate() throws {
        guard DispatchQueue.main.getSpecific(key: Transaction.key) != nil else {
            throw Error.notInTransaction
        }
    }

    public func performUpdates(_ updates: @escaping () -> Void, completion: (() -> Void)?) {
        #if DEBUG
        let block = {
            let value: Void? = DispatchQueue.main.getSpecific(key: Transaction.key)

            if value == nil {
                DispatchQueue.main.setSpecific(key: Transaction.key, value: ())
            }

            updates()

            if value == nil {
                DispatchQueue.main.setSpecific(key: Transaction.key, value: nil)
            }
        }
        #else
        // For non-DEBUG builds we can skip the marker and just execute
        // This may improve RELEASE builds performance
        let block = updates
        #endif

        block()
        completion?()
    }

    public init() { }

}

2. Transaction+Spec.swift

import XCTest
import Quick
import Nimble

final class Transaction_Spec: QuickSpec {

    override func spec() {
        context("Given a transaction") {
            it("it should validate when called inside a transaction") {
                let expect = self.expectation(description: "Inside transaction")

                Transaction().performUpdates({
                    do {
                        try Transaction.validate()
                        expect.fulfill()
                    } catch { }
                }, completion: nil)
            }

            it("it should throw when called inside a transaction but dispatched to another queue") {
                let expect = self.expectation(description: "Inside transaction but dispatched")

                Transaction().performUpdates({
                    DispatchQueue.global().async {
                        do {
                            try Transaction.validate()
                        } catch {
                            expect.fulfill()
                        }
                    }
                }, completion: nil)
            }

            it("it should throw when called outside a transaction") {
                let expect = self.expectation(description: "Inside transaction")

                do {
                    try Transaction.validate()
                } catch {
                    expect.fulfill()
                }
            }
        }
    }

}

Example:

        Transaction().performBatchUpdates({
            do {
                try Transaction.validate()
            } catch {
                print("This won't print")
            }
        }, completion: nil)

        do {
            try Transaction.validate()
        } catch {
            print("This will print")
        }