Fixed an issue where loading from a fresh datastore would throw an error

Fixes #163

Author: dimitribouniol

Sources/CodableDatastore/Datastore/Datastore.swift

@@ -476,6 +476,9 @@ extension Datastore {
                 return instance
             } catch DatastoreInterfaceError.instanceNotFound {
                 return nil
+            } catch DatastoreInterfaceError.datastoreKeyNotFound {
+                /// There isn't a datastore yet, so no entries would exist either.
+                return nil
             } catch {
                 throw error
             }
@@ -496,12 +499,16 @@ extension Datastore {
                 actionName: nil,
                 options: [.readOnly]
             ) { transaction, _ in
-                try await transaction.primaryIndexScan(range: range.applying(order), datastoreKey: self.key) { versionData, instanceData in
-                    let entryVersion = try Version(versionData)
-                    let decoder = try await self.decoder(for: entryVersion)
-                    let decodedValue = try await decoder(instanceData)
-                    
-                    try await provider.yield(decodedValue)
+                do {
+                    try await transaction.primaryIndexScan(range: range.applying(order), datastoreKey: self.key) { versionData, instanceData in
+                        let entryVersion = try Version(versionData)
+                        let decoder = try await self.decoder(for: entryVersion)
+                        let decodedValue = try await decoder(instanceData)
+                        
+                        try await provider.yield(decodedValue)
+                    }
+                } catch DatastoreInterfaceError.datastoreKeyNotFound {
+                    /// There isn't a datastore yet, so no entries would exist either. Do nothing and let the stream end.
                 }
             }
         }
@@ -542,34 +549,38 @@ extension Datastore {
                 actionName: nil,
                 options: [.readOnly]
             ) { transaction, _ in
-                let isDirectIndex = self.directIndexes.contains { $0.path == indexPath.path }
-                
-                if isDirectIndex {
-                    try await transaction.directIndexScan(
-                        range: range.applying(order),
-                        indexName: indexPath.path,
-                        datastoreKey: self.key
-                    ) { versionData, instanceData in
-                        let entryVersion = try Version(versionData)
-                        let decoder = try await self.decoder(for: entryVersion)
-                        let instance = try await decoder(instanceData).instance
-                        
-                        try await provider.yield(instance)
-                    }
-                } else {
-                    try await transaction.secondaryIndexScan(
-                        range: range.applying(order),
-                        indexName: indexPath.path,
-                        datastoreKey: self.key
-                    ) { (identifier: IdentifierType) in
-                        let persistedEntry = try await transaction.primaryIndexCursor(for: identifier, datastoreKey: self.key)
-                        
-                        let entryVersion = try Version(persistedEntry.versionData)
-                        let decoder = try await self.decoder(for: entryVersion)
-                        let instance = try await decoder(persistedEntry.instanceData).instance
-                        
-                        try await provider.yield(instance)
+                do {
+                    let isDirectIndex = self.directIndexes.contains { $0.path == indexPath.path }
+                    
+                    if isDirectIndex {
+                        try await transaction.directIndexScan(
+                            range: range.applying(order),
+                            indexName: indexPath.path,
+                            datastoreKey: self.key
+                        ) { versionData, instanceData in
+                            let entryVersion = try Version(versionData)
+                            let decoder = try await self.decoder(for: entryVersion)
+                            let instance = try await decoder(instanceData).instance
+                            
+                            try await provider.yield(instance)
+                        }
+                    } else {
+                        try await transaction.secondaryIndexScan(
+                            range: range.applying(order),
+                            indexName: indexPath.path,
+                            datastoreKey: self.key
+                        ) { (identifier: IdentifierType) in
+                            let persistedEntry = try await transaction.primaryIndexCursor(for: identifier, datastoreKey: self.key)
+                            
+                            let entryVersion = try Version(persistedEntry.versionData)
+                            let decoder = try await self.decoder(for: entryVersion)
+                            let instance = try await decoder(persistedEntry.instanceData).instance
+                            
+                            try await provider.yield(instance)
+                        }
                     }
+                } catch DatastoreInterfaceError.datastoreKeyNotFound {
+                    /// There isn't a datastore yet, so no entries would exist either. Do nothing and let the stream end.
                 }
             }
         }

Tests/CodableDatastoreTests/DiskPersistenceDatastoreTests.swift

@@ -75,6 +75,12 @@ final class DiskPersistenceDatastoreTests: XCTestCase {
                 ]
             )
 
+            let count = try await datastore.count
+            XCTAssertEqual(count, 0)
+            
+            let entry0 = try await datastore.load("0")
+            XCTAssertNil(entry0)
+            
             try await datastore.persist(TestStruct(id: "3", value: "My name is Dimitri"))
             try await datastore.persist(TestStruct(id: "1", value: "Hello, World!"))
             try await datastore.persist(TestStruct(id: "2", value: "Twenty Three is Number One"))
@@ -96,6 +102,8 @@ final class DiskPersistenceDatastoreTests: XCTestCase {
         let count = try await datastore.count
         XCTAssertEqual(count, 3)
 
+        let entry0 = try await datastore.load("0")
+        XCTAssertNil(entry0)
         let entry1 = try await datastore.load("1")
         XCTAssertEqual(entry1?.value, "Hello, World!")
         let entry2 = try await datastore.load("2")
@@ -215,6 +223,10 @@ final class DiskPersistenceDatastoreTests: XCTestCase {
             ]
         )
 
+        /// Read before persisting anything
+        var values = try await datastore.load(...).map { $0.value }.reduce(into: []) { $0.append($1) }
+        XCTAssertEqual(values, [])
+        
         for n in 0..<200 {
             try await datastore.persist(TestStruct(id: n*2, value: "\(n*2)"))
         }
@@ -223,7 +235,7 @@ final class DiskPersistenceDatastoreTests: XCTestCase {
         XCTAssertEqual(count, 200)
 
         /// Simple ranges
-        var values = try await datastore.load(5..<9).map { $0.value }.reduce(into: []) { $0.append($1) }
+        values = try await datastore.load(5..<9).map { $0.value }.reduce(into: []) { $0.append($1) }
         XCTAssertEqual(values, ["6", "8"])
 
         values = try await datastore.load((5..<9).reversed).map { $0.value }.reduce(into: []) { $0.append($1) }