[Local Catalog] Update schema with many-to-many images

Modules/Sources/Storage/GRDB/Migrations/V001InitialSchema.swift

@@ -10,6 +10,7 @@ struct V001InitialSchema {
         try createSiteTable(db)
         try createProductTable(db)
         try createProductAttributeTable(db)
+        try createImageTable(db)
         try createProductImageTable(db)
         try createProductVariationTable(db)
         try createProductVariationAttributeTable(db)
@@ -74,23 +75,39 @@ struct V001InitialSchema {
         }
     }
 
+    private static func createImageTable(_ db: Database) throws {
+        // Single image table shared by products and variations
+        try db.create(table: "image") { imageTable in
+            imageTable.column("id", .integer).notNull()
+            imageTable.primaryKey(["siteID", "id"]) // SiteID column created by belongsTo relationship
+            imageTable.belongsTo("site", onDelete: .cascade)
+
+            imageTable.column("dateCreated", .datetime).notNull()
+            imageTable.column("dateModified", .datetime)
+
+            imageTable.column("src", .text).notNull()
+            imageTable.column("name", .text)
+            imageTable.column("alt", .text)
+        }
+    }
+
     private static func createProductImageTable(_ db: Database) throws {
+        // Join table for many-to-many relationship between products and images
         try db.create(table: "productImage") { productImageTable in
             productImageTable.column("siteID", .integer).notNull()
-            productImageTable.column("id", .integer).notNull()
-            productImageTable.primaryKey(["siteID", "id"])
             productImageTable.column("productID", .integer).notNull()
+            productImageTable.column("imageID", .integer).notNull()
+            productImageTable.primaryKey(["siteID", "productID", "imageID"])
+
             productImageTable.foreignKey(["siteID", "productID"],
                                          references: "product",
                                          columns: ["siteID", "id"],
                                          onDelete: .cascade)
 
-            productImageTable.column("dateCreated", .datetime).notNull()
-            productImageTable.column("dateModified", .datetime)
-
-            productImageTable.column("src", .text).notNull()
-            productImageTable.column("name", .text)
-            productImageTable.column("alt", .text)
+            productImageTable.foreignKey(["siteID", "imageID"],
+                                         references: "image",
+                                         columns: ["siteID", "id"],
+                                         onDelete: .cascade)
         }
     }
 
@@ -138,22 +155,22 @@ struct V001InitialSchema {
     }
 
     private static func createProductVariationImageTable(_ db: Database) throws {
+        // Join table for many-to-many relationship between product variations and images
         try db.create(table: "productVariationImage") { productVariationImageTable in
             productVariationImageTable.column("siteID", .integer).notNull()
-            productVariationImageTable.column("id", .integer).notNull()
-            productVariationImageTable.primaryKey(["siteID", "id"])
             productVariationImageTable.column("productVariationID", .integer).notNull()
+            productVariationImageTable.column("imageID", .integer).notNull()
+            productVariationImageTable.primaryKey(["siteID", "productVariationID", "imageID"])
+
             productVariationImageTable.foreignKey(["siteID", "productVariationID"],
                                                   references: "productVariation",
                                                   columns: ["siteID", "id"],
                                                   onDelete: .cascade)
 
-            productVariationImageTable.column("dateCreated", .datetime).notNull()
-            productVariationImageTable.column("dateModified", .datetime)
-
-            productVariationImageTable.column("src", .text).notNull()
-            productVariationImageTable.column("name", .text)
-            productVariationImageTable.column("alt", .text)
+            productVariationImageTable.foreignKey(["siteID", "imageID"],
+                                                  references: "image",
+                                                  columns: ["siteID", "id"],
+                                                  onDelete: .cascade)
         }
     }
 }

Modules/Sources/Storage/GRDB/Model/PersistedImage.swift

@@ -0,0 +1,60 @@
+import Foundation
+import GRDB
+
+// periphery:ignore
+public struct PersistedImage: Codable {
+    public let siteID: Int64
+    public let id: Int64
+    public let dateCreated: Date
+    public let dateModified: Date?
+    public let src: String
+    public let name: String?
+    public let alt: String?
+
+    public init(siteID: Int64,
+                id: Int64,
+                dateCreated: Date,
+                dateModified: Date?,
+                src: String,
+                name: String?,
+                alt: String?) {
+        self.siteID = siteID
+        self.id = id
+        self.dateCreated = dateCreated
+        self.dateModified = dateModified
+        self.src = src
+        self.name = name
+        self.alt = alt
+    }
+}
+
+// periphery:ignore - TODO: remove ignore when populating database
+extension PersistedImage: FetchableRecord, PersistableRecord {
+    public static var databaseTableName: String { "image" }
+
+    public static var primaryKey: [String] { [CodingKeys.siteID.stringValue, CodingKeys.id.stringValue] }
+
+    public enum Columns {
+        public static let siteID = Column(CodingKeys.siteID)
+        public static let id = Column(CodingKeys.id)
+        public static let dateCreated = Column(CodingKeys.dateCreated)
+        public static let dateModified = Column(CodingKeys.dateModified)
+        public static let src = Column(CodingKeys.src)
+        public static let name = Column(CodingKeys.name)
+        public static let alt = Column(CodingKeys.alt)
+    }
+}
+
+
+// periphery:ignore - TODO: remove ignore when populating database
+extension PersistedImage {
+    enum CodingKeys: String, CodingKey {
+        case siteID
+        case id
+        case dateCreated
+        case dateModified
+        case src
+        case name
+        case alt
+    }
+}

Modules/Sources/Storage/GRDB/Model/PersistedProduct.swift

@@ -72,10 +72,17 @@ extension PersistedProduct: FetchableRecord, PersistableRecord {
         public static let stockStatusKey = Column(CodingKeys.stockStatusKey)
     }
 
-    public static let images = hasMany(PersistedProductImage.self,
-                                       using: ForeignKey([PersistedProductImage.CodingKeys.siteID.stringValue,
-                                                          PersistedProductImage.CodingKeys.productID.stringValue],
-                                                         to: primaryKey))
+    // Join table association (internal - used by 'images' through association)
+    private static let productImages = hasMany(PersistedProductImage.self,
+                                               using: ForeignKey([PersistedProductImage.CodingKeys.siteID.stringValue,
+                                                                  PersistedProductImage.CodingKeys.productID.stringValue],
+                                                                 to: primaryKey))
+
+    // Through association to access actual images via join table (use this to fetch images)
+    public static let images = hasMany(PersistedImage.self,
+                                       through: productImages,
+                                       using: PersistedProductImage.image)
+
     public static let attributes = hasMany(PersistedProductAttribute.self,
                                            using: ForeignKey([PersistedProductAttribute.CodingKeys.siteID.stringValue,
                                                               PersistedProductAttribute.CodingKeys.productID.stringValue],

Modules/Sources/Storage/GRDB/Model/PersistedProductImage.swift

@@ -2,64 +2,48 @@ import Foundation
 import GRDB
 
 // periphery:ignore - TODO: remove ignore when populating database
+/// Join table linking products to images (many-to-many relationship)
 public struct PersistedProductImage: Codable {
     public let siteID: Int64
-    public let id: Int64
     public let productID: Int64
-    public let dateCreated: Date
-    public let dateModified: Date?
-    public let src: String
-    public let name: String?
-    public let alt: String?
+    public let imageID: Int64
 
     public init(siteID: Int64,
-                id: Int64,
                 productID: Int64,
-                dateCreated: Date,
-                dateModified: Date?,
-                src: String,
-                name: String?,
-                alt: String?) {
+                imageID: Int64) {
         self.siteID = siteID
-        self.id = id
         self.productID = productID
-        self.dateCreated = dateCreated
-        self.dateModified = dateModified
-        self.src = src
-        self.name = name
-        self.alt = alt
+        self.imageID = imageID
     }
 }
 
 // periphery:ignore - TODO: remove ignore when populating database
 extension PersistedProductImage: FetchableRecord, PersistableRecord {
     public static var databaseTableName: String { "productImage" }
 
-    public static var primaryKey: [String] { [CodingKeys.siteID.stringValue, CodingKeys.id.stringValue] }
+    public static var primaryKey: [String] {
+        [CodingKeys.siteID.stringValue, CodingKeys.productID.stringValue, CodingKeys.imageID.stringValue]
+    }
 
     public enum Columns {
         public static let siteID = Column(CodingKeys.siteID)
-        public static let id = Column(CodingKeys.id)
         public static let productID = Column(CodingKeys.productID)
-        public static let dateCreated = Column(CodingKeys.dateCreated)
-        public static let dateModified = Column(CodingKeys.dateModified)
-        public static let src = Column(CodingKeys.src)
-        public static let name = Column(CodingKeys.name)
-        public static let alt = Column(CodingKeys.alt)
+        public static let imageID = Column(CodingKeys.imageID)
     }
+
+    // Association to the actual image
+    public static let image = belongsTo(PersistedImage.self,
+                                       using: ForeignKey([CodingKeys.siteID.stringValue,
+                                                          CodingKeys.imageID.stringValue],
+                                                         to: PersistedImage.primaryKey))
 }
 
 
 // periphery:ignore - TODO: remove ignore when populating database
 extension PersistedProductImage {
     enum CodingKeys: String, CodingKey {
         case siteID
-        case id
         case productID
-        case dateCreated
-        case dateModified
-        case src
-        case name
-        case alt
+        case imageID
     }
 }

Modules/Sources/Storage/GRDB/Model/PersistedProductVariation.swift

@@ -65,11 +65,19 @@ extension PersistedProductVariation: FetchableRecord, PersistableRecord {
                                            using: ForeignKey([PersistedProductVariationAttribute.CodingKeys.siteID.stringValue,
                                                               PersistedProductVariationAttribute.CodingKeys.productVariationID.stringValue],
                                                              to: primaryKey))
-    public static let image = hasOne(PersistedProductVariationImage.self,
-                                     key: "image",
-                                     using: ForeignKey([PersistedProductVariationImage.CodingKeys.siteID.stringValue,
-                                                        PersistedProductVariationImage.CodingKeys.productVariationID.stringValue],
-                                                       to: primaryKey))
+
+    // Join table association (internal - used by 'image' through association)
+    private static let productVariationImage = hasOne(PersistedProductVariationImage.self,
+                                                      key: "productVariationImage",
+                                                      using: ForeignKey([PersistedProductVariationImage.CodingKeys.siteID.stringValue,
+                                                                         PersistedProductVariationImage.CodingKeys.productVariationID.stringValue],
+                                                                        to: primaryKey))
+
+    // Through association to access actual image via join table (use this to fetch image)
+    public static let image = hasOne(PersistedImage.self,
+                                     through: productVariationImage,
+                                     using: PersistedProductVariationImage.image,
+                                     key: "image")
 }
 
 

Modules/Sources/Storage/GRDB/Model/PersistedProductVariationImage.swift

@@ -2,64 +2,48 @@ import Foundation
 import GRDB
 
 // periphery:ignore - TODO: remove ignore when populating database
+/// Join table linking product variations to images (many-to-many relationship)
 public struct PersistedProductVariationImage: Codable {
     public let siteID: Int64
-    public let id: Int64
     public let productVariationID: Int64
-    public let dateCreated: Date
-    public let dateModified: Date?
-    public let src: String
-    public let name: String?
-    public let alt: String?
+    public let imageID: Int64
 
     public init(siteID: Int64,
-                id: Int64,
                 productVariationID: Int64,
-                dateCreated: Date,
-                dateModified: Date?,
-                src: String,
-                name: String?,
-                alt: String?) {
+                imageID: Int64) {
         self.siteID = siteID
-        self.id = id
         self.productVariationID = productVariationID
-        self.dateCreated = dateCreated
-        self.dateModified = dateModified
-        self.src = src
-        self.name = name
-        self.alt = alt
+        self.imageID = imageID
     }
 }
 
 // periphery:ignore - TODO: remove ignore when populating database
 extension PersistedProductVariationImage: FetchableRecord, PersistableRecord {
     public static var databaseTableName: String { "productVariationImage" }
 
-    public static var primaryKey: [String] { [CodingKeys.siteID.stringValue, CodingKeys.id.stringValue] }
+    public static var primaryKey: [String] {
+        [CodingKeys.siteID.stringValue, CodingKeys.productVariationID.stringValue, CodingKeys.imageID.stringValue]
+    }
 
     public enum Columns {
         public static let siteID = Column(CodingKeys.siteID)
-        public static let id = Column(CodingKeys.id)
         public static let productVariationID = Column(CodingKeys.productVariationID)
-        public static let dateCreated = Column(CodingKeys.dateCreated)
-        public static let dateModified = Column(CodingKeys.dateModified)
-        public static let src = Column(CodingKeys.src)
-        public static let name = Column(CodingKeys.name)
-        public static let alt = Column(CodingKeys.alt)
+        public static let imageID = Column(CodingKeys.imageID)
     }
+
+    // Association to the actual image
+    public static let image = belongsTo(PersistedImage.self,
+                                       using: ForeignKey([CodingKeys.siteID.stringValue,
+                                                          CodingKeys.imageID.stringValue],
+                                                         to: PersistedImage.primaryKey))
 }
 
 
 // periphery:ignore - TODO: remove ignore when populating database
 extension PersistedProductVariationImage {
     enum CodingKeys: String, CodingKey {
         case siteID
-        case id
         case productVariationID
-        case dateCreated
-        case dateModified
-        case src
-        case name
-        case alt
+        case imageID
     }
 }

Modules/Sources/Yosemite/Model/Storage/PersistedImage+Conversions.swift

@@ -0,0 +1,29 @@
+import Foundation
+import Storage
+
+// MARK: - PersistedImage Conversions
+public extension PersistedImage {
+    /// Create a PersistedImage from a ProductImage
+    static func make(from productImage: ProductImage, siteID: Int64) -> PersistedImage {
+        return PersistedImage(
+            siteID: siteID,
+            id: productImage.imageID,
+            dateCreated: productImage.dateCreated,
+            dateModified: productImage.dateModified,
+            src: productImage.src,
+            name: productImage.name,
+            alt: productImage.alt
+        )
+    }
+
+    func toProductImage() -> ProductImage {
+        return ProductImage(
+            imageID: id,
+            dateCreated: dateCreated,
+            dateModified: dateModified,
+            src: src,
+            name: name,
+            alt: alt
+        )
+    }
+}