Implemented ModelData.init(bson:entity:)

Author: colemancda

Sources/MongoDBModel/ModelData.swift

@@ -11,8 +11,26 @@ import MongoSwift
 
 public extension ModelData {
 
-    init(bson: BSONDocument) {
-        fatalError()
+    init(bson: BSONDocument, model: EntityDescription) throws {
+        let id = try bson.modelObjectID
+        self.init(entity: model.id, id: id)
+        // decode attributes
+        for attribute in model.attributes {
+            let value = bson[attribute.id.rawValue]
+                .map { AttributeValue(bson: $0) } ?? .null
+            self.attributes[attribute.id] = value
+        }
+        // decode relationships
+        for relationship in model.relationships {
+            let relationshipBSON = bson[relationship.id.rawValue] ?? .null
+            guard let value = RelationshipValue(
+                bson: relationshipBSON,
+                type: relationship.type
+            ) else {
+                throw DecodingError.typeMismatch(ModelData.self, DecodingError.Context(codingPath: [], debugDescription: ""))
+            }
+            self.relationships[relationship.id] = value
+        }
     }
 }
 

Sources/MongoDBModel/MongoDatabase.swift

@@ -2,23 +2,26 @@ import Foundation
 @_exported import CoreModel
 @_exported import MongoSwift
 
-extension MongoDatabase: ModelStorage {
+extension MongoDatabase {
 
     /// Fetch managed object.
     public func fetch(
-        _ entity: EntityName,
+        _ entity: EntityDescription,
         for id: ObjectID
     ) async throws -> ModelData? {
-        guard let document = try await find(entity, for: id) else {
+        guard let document = try await find(entity.id, for: id) else {
             return nil
         }
-        return ModelData(bson: document)
+        return try ModelData(bson: document, model: entity)
     }
 
     /// Fetch managed objects.
-    public func fetch(_ fetchRequest: FetchRequest) async throws -> [ModelData] {
+    public func fetch(
+        _ fetchRequest: FetchRequest,
+        entity: EntityDescription
+    ) async throws -> [ModelData] {
         try await fetchDocuments(fetchRequest)
-            .map { ModelData(bson: $0) }
+            .map { try ModelData(bson: $0, model: entity) }
     }
 
     /// Fetch and return result count.

Sources/MongoDBModel/ObjectID.swift

@@ -15,3 +15,29 @@ extension BSONObjectID: ObjectIDConvertible {
         try? self.init(objectID.rawValue)
     }
 }
+
+internal extension BSONDocument {
+    
+    var modelObjectID: ObjectID {
+        get throws {
+            guard let id = self[BSONDocument.BuiltInProperty.id.rawValue]?.stringValue else {
+                throw CocoaError(.coderValueNotFound)
+            }
+            return ObjectID(rawValue: id)
+        }
+    }
+}
+
+public extension ObjectID {
+    
+    init?(bson: BSON) {
+        switch bson {
+        case let .string(string):
+            self.init(rawValue: string)
+        case let .objectID(objectID):
+            self.init(rawValue: objectID.description)
+        default:
+            return nil
+        }
+    }
+}

Sources/MongoDBModel/RelationshipValue.swift

@@ -11,8 +11,31 @@ import MongoSwift
 
 public extension RelationshipValue {
 
-    init?(bson: BSON) {
-        fatalError()
+    init?(bson: BSON, type: RelationshipType) {
+        guard bson != .null else {
+            self = .null
+            return
+        }
+        switch type {
+        case .toOne:
+            guard let objectID = ObjectID(bson: bson) else {
+                return nil
+            }
+            self = .toOne(objectID)
+        case .toMany:
+            guard case let .array(array) = bson else {
+                return nil
+            }
+            var objectIDs = [ObjectID]()
+            objectIDs.reserveCapacity(array.count)
+            for item in array {
+                guard let objectID = ObjectID(bson: item) else {
+                    return nil
+                }
+                objectIDs.append(objectID)
+            }
+            self = .toMany(objectIDs)
+        }
     }
 }