concurrency

Author: Geor Kasapidi

.github/workflows/swift.yml

@@ -9,9 +9,12 @@ on:
 jobs:
   build:
 
-    runs-on: macos-latest
+    runs-on: macos-11
 
     steps:
     - uses: actions/checkout@v2
-    - name: Test
-      run: xcodebuild -scheme Sworm-Package -destination 'platform=macOS,arch=x86_64' clean test
+    - uses: maxim-lobanov/setup-xcode@v1.3.0
+      with:
+        xcode-version: '13.2'
+    - name: Test 15
+      run: xcodebuild -scheme Sworm-Package -destination 'platform=iOS Simulator,name=iPhone 13,OS=15.2' clean test

.swiftformat

@@ -0,0 +1,8 @@
+--self insert
+--wrapcollections before-first
+--wraparguments before-first
+--wrapparameters before-first
+--header strip
+--ifdef no-indent
+--enable wrapSwitchCases
+--swiftversion 5.5

Package.swift

@@ -1,4 +1,4 @@
-// swift-tools-version:5.3
+// swift-tools-version:5.5
 // The swift-tools-version declares the minimum version of Swift required to build this package.
 
 import PackageDescription
@@ -22,14 +22,8 @@ let package = Package(
         ),
     ],
     targets: [
-        .target(
-            name: "Sworm",
-            dependencies: []
-        ),
-        .target(
-            name: "SwormTools",
-            dependencies: []
-        ),
+        .target(name: "Sworm"),
+        .target(name: "SwormTools"),
         .testTarget(
             name: "SwormTests",
             dependencies: ["Sworm", "SwormTools"]

README.md

@@ -45,10 +45,6 @@ Use SPM:
 
 ``` swift
 dependencies: [
-    .package(url: "https://github.com/geor-kasapidi/Sworm.git", .upToNextMajor(from: "1.0.0"))
+    .package(url: "https://github.com/prisma-ai/Sworm.git", .upToNextMajor(from: "1.0.0"))
 ]
 ```
-
-## Code style
-
-`swiftformat --self insert --swiftversion 5.3 .`

Sources/Sworm/Attributes/Attribute.swift

@@ -1,20 +1,6 @@
 import CoreData
 
 public final class Attribute<PlainObject: ManagedObjectConvertible>: Hashable {
-    let name: String
-    let keyPath: PartialKeyPath<PlainObject>
-
-    let encode: (PlainObject, NSManagedObject) -> Void
-    let decode: (inout PlainObject, NSManagedObject) throws -> Void
-
-    public func hash(into hasher: inout Hasher) {
-        self.keyPath.hash(into: &hasher)
-    }
-
-    public static func == (lhs: Attribute<PlainObject>, rhs: Attribute<PlainObject>) -> Bool {
-        lhs.keyPath == rhs.keyPath
-    }
-
     public init<Attribute: SupportedAttributeType>(
         _ keyPath: WritableKeyPath<PlainObject, Attribute>,
         _ name: String
@@ -62,6 +48,20 @@ public final class Attribute<PlainObject: ManagedObjectConvertible>: Hashable {
             }
         }
     }
+
+    public static func == (lhs: Attribute<PlainObject>, rhs: Attribute<PlainObject>) -> Bool {
+        lhs.keyPath == rhs.keyPath
+    }
+
+    public func hash(into hasher: inout Hasher) {
+        self.keyPath.hash(into: &hasher)
+    }
+
+    let name: String
+    let keyPath: PartialKeyPath<PlainObject>
+
+    let encode: (PlainObject, NSManagedObject) -> Void
+    let decode: (inout PlainObject, NSManagedObject) throws -> Void
 }
 
 extension ManagedObjectConvertible {

Sources/Sworm/Attributes/AttributeError.swift

@@ -1,10 +1,10 @@
 public enum AttributeError: Swift.Error {
+    case badInput(Any?)
+    case badAttribute(Context)
+
     public struct Context {
         public let name: String
         public let entity: String
         public let originalError: Swift.Error
     }
-
-    case badInput(Any?)
-    case badAttribute(Context)
 }

Sources/Sworm/DataHelper.swift

@@ -0,0 +1,40 @@
+import CoreData
+
+internal extension NSManagedObject {
+    subscript(primitiveValue key: String) -> Any? {
+        get {
+            self.willAccessValue(forKey: key)
+            defer { self.didAccessValue(forKey: key) }
+            return self.primitiveValue(forKey: key)
+        }
+        set {
+            self.willChangeValue(forKey: key)
+            self.setPrimitiveValue(newValue, forKey: key)
+            self.didChangeValue(forKey: key)
+        }
+    }
+}
+
+internal extension NSManagedObjectContext {
+    func execute<T>(
+        _ reset: Bool,
+        _ action: @escaping (ManagedObjectContext) throws -> T
+    ) throws -> T {
+        defer {
+            if reset {
+                self.reset()
+            }
+        }
+        let result = try action(.init(self))
+        if self.hasChanges {
+            try self.save()
+        }
+        return result
+    }
+
+    func insert(entity name: String) -> NSManagedObject? {
+        self.persistentStoreCoordinator
+            .flatMap { $0.managedObjectModel.entitiesByName[name] }
+            .flatMap { .init(entity: $0, insertInto: self) }
+    }
+}

Sources/Sworm/Extensions.swift

@@ -0,0 +1,99 @@
+import CoreData
+
+public final class PersistentContainer {
+    public init(
+        managedObjectContext: @escaping () throws -> NSManagedObjectContext,
+        logError: ((Swift.Error) -> Void)? = nil,
+        cleanUpAfterExecution: Bool = true
+    ) {
+        self.managedObjectContext = managedObjectContext
+        self.logError = logError
+        self.cleanUpAfterExecution = cleanUpAfterExecution
+    }
+
+    public enum Error: Swift.Error {
+        case noResult
+    }
+
+    @discardableResult
+    public func perform<T>(
+        action: @escaping (ManagedObjectContext) throws -> T
+    ) throws -> T {
+        do {
+            let context = try self.managedObjectContext()
+            let reset = self.cleanUpAfterExecution
+
+            if #available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *) {
+                return try context.performAndWait {
+                    try context.execute(reset, action)
+                }
+            }
+
+            var result: Result<T, Swift.Error>?
+
+            context.performAndWait {
+                result = Result(catching: {
+                    try context.execute(reset, action)
+                })
+            }
+
+            switch result {
+            case let .success(value):
+                return value
+            case let .failure(error):
+                throw error
+            case .none:
+                throw Self.Error.noResult
+            }
+        } catch {
+            self.logError?(error)
+
+            throw error
+        }
+    }
+
+    #if canImport(_Concurrency)
+    @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *)
+    @discardableResult
+    public func schedule<T>(
+        action: @escaping (ManagedObjectContext) throws -> T
+    ) async throws -> T {
+        do {
+            let context = try self.managedObjectContext()
+            let reset = self.cleanUpAfterExecution
+
+            if #available(macOS 12.0, iOS 15.0, tvOS 15.0, watchOS 8.0, *) {
+                return try await context.perform(schedule: .immediate) {
+                    try context.execute(reset, action)
+                }
+            }
+
+            #if DEBUG
+            return try await withCheckedThrowingContinuation { continuation in
+                context.perform {
+                    continuation.resume(with: .init(catching: {
+                        try context.execute(reset, action)
+                    }))
+                }
+            }
+            #else
+            return try await withUnsafeThrowingContinuation { continuation in
+                context.perform {
+                    continuation.resume(with: .init(catching: {
+                        try context.execute(reset, action)
+                    }))
+                }
+            }
+            #endif
+        } catch {
+            self.logError?(error)
+
+            throw error
+        }
+    }
+    #endif
+
+    private let managedObjectContext: () throws -> NSManagedObjectContext
+    private let logError: ((Swift.Error) -> Void)?
+    private let cleanUpAfterExecution: Bool
+}

Sources/Sworm/PersistentContainer.swift

@@ -1,23 +1,23 @@
 public struct ToOneRelation<Destination: ManagedObjectConvertible> {
-    let name: String
-
     public init(_ name: String) {
         self.name = name
     }
-}
 
-public struct ToManyRelation<Destination: ManagedObjectConvertible> {
     let name: String
+}
 
+public struct ToManyRelation<Destination: ManagedObjectConvertible> {
     public init(_ name: String) {
         self.name = name
     }
-}
 
-public struct ToManyOrderedRelation<Destination: ManagedObjectConvertible> {
     let name: String
+}
 
+public struct ToManyOrderedRelation<Destination: ManagedObjectConvertible> {
     public init(_ name: String) {
         self.name = name
     }
+
+    let name: String
 }