Add "Email to Subscribers" row to "Publishing" sheet (#24946)

* Add jetpackNewsletterEmailDisabled to PostMetadata

* Remove unused encodeMetadata

* Rename PostMetadataContainer

* Add PostMetadata

* Integrate PostMetadataContainer

* Add email-sbubscribers row

* Update label

* Update release notes

* Reverse the toggle

* Send a string

* Add an assertion that only strings are supported

Author: kean

Modules/Sources/WordPressKit/RemotePostParameters.swift

@@ -233,26 +233,6 @@ struct RemotePostCreateParametersWordPressComEncoder: Encodable {
             try container.encode(parameters.isSticky, forKey: .isSticky)
         }
     }
-
-    // - warning: fixme
-    static func encodeMetadata(_ metadata: Set<RemotePostMetadataItem>) -> [[String: Any]] {
-        metadata.map { item in
-            var operation = "update"
-            if item.key == nil {
-                if item.id != nil && item.value == nil {
-                    operation = "delete"
-                } else if item.id == nil && item.value != nil {
-                    operation = "add"
-                }
-            }
-            var dictionary: [String: Any] = [:]
-            if let id = item.id { dictionary["id"] = id }
-            if let value = item.value { dictionary["value"] = value }
-            if let key = item.key { dictionary["key"] = key }
-            dictionary["operation"] = operation
-            return dictionary
-        }
-    }
 }
 
 struct RemotePostUpdateParametersWordPressComMetadata: Encodable {

RELEASE-NOTES.txt

@@ -1,6 +1,7 @@
 26.5
 -----
 * [*] Add "Access" section to "Post Settings" [#24942]
+* [*] Add "Email to Subscribers" row to "Publishing" sheet [#24946]
 
 26.4
 -----

Sources/WordPressData/Swift/PostHelper+Metadata.swift

@@ -23,10 +23,14 @@ extension PostHelper {
 
     public static func mapDictionaryToMetadataItems(_ dictionary: [String: Any]) -> RemotePostMetadataItem? {
         let id = dictionary["id"]
+        let value = dictionary["value"]
+        if let value {
+            wpAssert(value is String, "only strings are currently supported by WordPressKit")
+        }
         return RemotePostMetadataItem(
             id: (id as? String) ?? (id as? NSNumber)?.stringValue,
             key: dictionary["key"] as? String,
-            value: dictionary["value"] as? String
+            value: value as? String
         )
     }
 

Sources/WordPressData/Swift/PostMetadata.swift

@@ -1,189 +1,62 @@
 import Foundation
-import WordPressKit
 import WordPressShared
 
-/// A convenience struct that provides CRUD operations on post metadata.
-///
-/// ## WordPress Metadata Overview
-///
-/// WordPress stores custom metadata as key-value pairs associated with posts.
-/// Each metadata item contains a string key, a value (which can be any
-/// JSON-serializable type), and an optional ID for database tracking.
-///
-/// ## Expected Format
-///
-/// Metadata is stored as a JSON array of dictionaries, where each dictionary represents one
-/// metadata item:
-///
-/// ```json
-/// [
-///   {
-///     "key": "_jetpack_newsletter_access",
-///     "value": "subscribers",
-///     "id": "123"
-///   },
-///   {
-///     "key": "custom_field",
-///     "value": "some value"
-///   }
-/// ]
-/// ```
-public struct PostMetadata {
-    public struct Key: ExpressibleByStringLiteral, Hashable {
-        public let rawValue: String
-
-        public init(rawValue: String) {
-            self.rawValue = rawValue
-        }
-
-        public init(stringLiteral value: String) {
-            self.rawValue = value
-        }
-    }
-
-    enum Error: Swift.Error {
-        case invalidData
-    }
-
-    // Raw JSON dictionaries, keyed by metadata key
-    private var items: [Key: [String: Any]] = [:]
+/// Metadata used by the app.
+public struct PostMetadata: Hashable {
+    /// Gets or sets the Jetpack Newsletter access level as a PostAccessLevel enum
+    public var accessLevel: JetpackPostAccessLevel?
 
-    /// Returns all metadata as a dictionary (alias for allItems)
-    public var values: [[String: Any]] {
-        Array(items.values)
-    }
+    /// Returns `true` if the post is configured to _not_ be sent in an email
+    /// to subscribers.
+    public var isJetpackNewsletterEmailDisabled: Bool
 
     /// Initialized metadata with the given post.
     public init(_ post: AbstractPost) {
-        if let data = post.rawMetadata {
-            do {
-                let metadata = try JSONSerialization.jsonObject(with: data) as? [[String: Any]] ?? []
-                self = PostMetadata(metadata: metadata)
-            } catch {
-                wpAssertionFailure("Failed to decode metadata JSON", userInfo: ["error": error.localizedDescription])
-                self = PostMetadata()
-            }
-        } else {
-            self = PostMetadata()
-        }
+        self = PostMetadata(from: PostMetadataContainer(post))
     }
 
-    /// Initialize with raw metadata Data (non-throwing version for backward compatibility)
-    /// If the data is invalid, creates an empty PostMetadata
-    ///
-    /// - Parameter data: The JSON data containing metadata array
-    public init(data: Data) throws {
-        let metadata = try JSONSerialization.jsonObject(with: data)
-        guard let dictionary = metadata as? [[String: Any]] else {
-            throw Error.invalidData
-        }
-        self = PostMetadata(metadata: dictionary)
+    public init(from container: PostMetadataContainer) {
+        self.accessLevel = container.accessLevel
+        self.isJetpackNewsletterEmailDisabled = container.getAdaptiveBool(for: .jetpackNewsletterEmailDisabled)
     }
 
-    /// Initialize with raw metadata array (same format as JSON data)
-    /// - Parameter metadata: Array of metadata dictionaries with "key", "value", and optional "id"
-    public init(metadata: [[String: Any]] = []) {
-        for item in metadata {
-            if let key = item["key"] as? String {
-                self.items[Key(rawValue: key)] = item
-            }
+    /// Applies the metadata values to the container and returns them
+    /// as metadata values.
+    public func encode(in container: inout PostMetadataContainer) {
+        let previous = PostMetadata(from: container)
+        if previous.accessLevel != accessLevel {
+            container.accessLevel = accessLevel
         }
-    }
-
-    // MARK: - Encoding
-
-    /// Encodes the metadata back to Data for storage in rawMetadata
-    /// - Returns: JSON Data representation of the metadata, or nil if empty
-    public func encode() throws -> Data {
-        do {
-            return try JSONSerialization.data(withJSONObject: Array(items.values), options: [])
-        } catch {
-            wpAssertionFailure("Failed to encode metadata to JSON", userInfo: ["error": error.localizedDescription])
-            throw error
+        if previous.isJetpackNewsletterEmailDisabled != isJetpackNewsletterEmailDisabled {
+            container.setValue(String(describing: isJetpackNewsletterEmailDisabled), for: .jetpackNewsletterEmailDisabled)
         }
     }
 
-    // MARK: - CRUD
-
-    /// Retrieves a metadata value by key with generic type casting
-    /// - Parameters:
-    ///   - expectedType: The expected type of the value
-    ///   - key: The metadata key to search for
-    /// - Returns: The value cast to the specified type if found and compatible, nil otherwise
-    public func getValue<T>(_ expectedType: T.Type, forKey key: Key) -> T? {
-        guard let dict = items[key], let value = dict["value"] else { return nil }
-        guard let value = value as? T else {
-            wpAssertionFailure("unexpected value", userInfo: [
-                "key": key.rawValue,
-                "actual_type": String(describing: expectedType),
-                "expected_type": String(describing: type(of: value))
-            ])
-            return nil
-        }
-        return value
-    }
-
-    /// Retrieves a metadata value by key as String (convenience method)
-    /// - Parameter key: The metadata key to search for
-    /// - Returns: The value as String if found and convertible, nil otherwise
-    public func getString(for key: Key) -> String? {
-        getValue(String.self, forKey: key)
-    }
-
-    /// Sets or updates a metadata item with any JSON-compatible value
-    /// - Parameters:
-    ///   - value: The metadata value (must be JSON-compatible)
-    ///   - key: The metadata key
-    ///   - id: Optional metadata ID
-    public mutating func setValue(_ value: Any, for key: Key, id: String? = nil) {
-        var dict: [String: Any] = [
-            "key": key.rawValue,
-            "value": value
-        ]
-        // Preserve existing ID if not provided
-        if let id {
-            dict["id"] = id
-        } else if let existingDict = items[key], let existingID = existingDict["id"] {
-            dict["id"] = existingID
-        }
-        guard JSONSerialization.isValidJSONObject(dict) else {
-            return wpAssertionFailure("invalid value", userInfo: ["type": String(describing: type(of: value))])
-        }
-        items[key] = dict
-    }
-
-    /// Removes a metadata item by key
-    /// - Parameter key: The metadata key to remove
-    /// - Returns: True if the item was found and removed, false otherwise
-    @discardableResult
-    public mutating func removeValue(for key: Key) -> Bool {
-        items.removeValue(forKey: key) != nil
-    }
-
-    /// Clears all metadata
-    public mutating func clear() {
-        items.removeAll()
-    }
-
-    /// Returns the complete dictionary entry for the given key.
+    /// Returns all metadata values encoded in `PostMetadataContainer` as
+    /// WordPress metadata fields.
     ///
-    /// - Parameter key: The metadata key to retrieve
-    /// - Returns: The complete metadata dictionary containing "key", "value", and optional "id", or nil if not found
-    public func entry(forKey key: Key) -> [String: Any]? {
-        return items[key]
+    /// - note: It returns _only_ the fields managed by the app so that we
+    /// don't send more than needed to the server when updating it.
+    public static func entries(in container: PostMetadataContainer) -> [[String: Any]] {
+        PostMetadata.allKeys.compactMap(container.entry)
     }
-}
 
-// MARK: - PostMetadata (Jetpack)
+    /// Returns all keys managed by the app.
+    public static let allKeys: [PostMetadataContainer.Key] = [
+        .jetpackNewsletterAccess,
+        .jetpackNewsletterEmailDisabled
+    ]
+}
 
-extension PostMetadata.Key {
-    /// Jetpack Newsletter access level metadata key
-    public static let jetpackNewsletterAccess: PostMetadata.Key = "_jetpack_newsletter_access"
+/// Valid access levels for Jetpack Newsletter
+public enum JetpackPostAccessLevel: String, CaseIterable, Hashable, Codable {
+    case everybody = "everybody"
+    case subscribers = "subscribers"
+    case paidSubscribers = "paid_subscribers"
 }
 
-extension PostMetadata {
-    /// Gets or sets the Jetpack Newsletter access level as a PostAccessLevel enum
-    public var accessLevel: JetpackPostAccessLevel? {
+private extension PostMetadataContainer {
+    var accessLevel: JetpackPostAccessLevel? {
         get {
             guard let value = getString(for: .jetpackNewsletterAccess) else { return nil }
             return JetpackPostAccessLevel(rawValue: value)
@@ -198,9 +71,7 @@ extension PostMetadata {
     }
 }
 
-/// Valid access levels for Jetpack Newsletter
-public enum JetpackPostAccessLevel: String, CaseIterable, Hashable, Codable {
-    case everybody = "everybody"
-    case subscribers = "subscribers"
-    case paidSubscribers = "paid_subscribers"
+extension PostMetadataContainer.Key {
+    static let jetpackNewsletterAccess: PostMetadataContainer.Key = "_jetpack_newsletter_access"
+    static let jetpackNewsletterEmailDisabled: PostMetadataContainer.Key = "_jetpack_dont_email_post_to_subs"
 }