@rovq/react-native 0.0.0-stage → 0.1.0

package/ios/Engine/ZipReader.swift

@@ -0,0 +1,378 @@
+import Compression
+import Foundation
+
+private let endOfDirectorySignature: UInt32 = 0x0605_4b50
+private let centralHeaderSignature: UInt32 = 0x0201_4b50
+private let localHeaderSignature: UInt32 = 0x0403_4b50
+private let endOfDirectorySize = 22
+private let centralHeaderSize = 46
+private let localHeaderSize = 30
+private let maxCommentSize = 65_535
+private let flagEncrypted: UInt16 = 0x1
+private let flagUTF8Name: UInt16 = 0x800
+private let methodStore: UInt16 = 0
+private let methodDeflate: UInt16 = 8
+private let unicodePathExtraField: UInt16 = 0x7075
+private let fileTypeMask: UInt32 = 0o170000
+private let regularFile: UInt32 = 0o100000
+private let bufferSize = 64 * 1024
+
+/// Thrown for any malformed or disallowed ZIP file.
+struct ZipError: Error {
+    let message: String
+}
+
+struct ZipEntry {
+    let name: String
+    let method: UInt16
+    let crc32: UInt32
+    let compressedSize: Int64
+    let uncompressedSize: Int64
+    let localHeaderOffset: Int64
+    let isFolder: Bool
+}
+
+/// iOS has no public ZIP API. This reader is small and strict: it reads names from the
+/// central directory, the same source the server checked, and refuses anything ambiguous.
+/// ZIP64 is not needed, because the size limit of a package is below 4 GB.
+final class ZipReader {
+    private let handle: FileHandle
+    private let fileSize: Int64
+    let entries: [ZipEntry]
+
+    init(url: URL) throws {
+        do {
+            handle = try FileHandle(forReadingFrom: url)
+            fileSize = Int64(try handle.seekToEnd())
+        } catch {
+            throw ZipError(message: "Could not open the file")
+        }
+        entries = try ZipReader.readDirectory(handle: handle, fileSize: fileSize)
+        try ZipReader.checkNoOverlap(handle: handle, fileSize: fileSize, entries: entries)
+    }
+
+    deinit {
+        try? handle.close()
+    }
+
+    /// Writes one entry to `output`, counting real bytes.
+    ///
+    /// - Parameter allowance: the most bytes this entry may produce.
+    /// - Returns: the number of bytes written.
+    /// - Throws: `ZipError` for a problem in the file, or the underlying error from `write`.
+    func extract(_ entry: ZipEntry, allowance: Int64, write: (Data) throws -> Void) throws -> Int64 {
+        let start = try ZipReader.dataOffset(handle: handle, fileSize: fileSize, entry: entry)
+        try handle.seek(toOffset: UInt64(start))
+
+        var crc = CRC32()
+        var written: Int64 = 0
+        let emit: (Data) throws -> Void = { chunk in
+            written += Int64(chunk.count)
+            if written > allowance { throw ZipError(message: "The package is too large when decompressed") }
+            if written > entry.uncompressedSize {
+                throw ZipError(message: "The file \(entry.name) lies about its size")
+            }
+            crc.update(chunk)
+            try write(chunk)
+        }
+
+        switch entry.method {
+        case methodStore:
+            try copyStored(entry: entry, emit: emit)
+        case methodDeflate:
+            try inflate(entry: entry, emit: emit)
+        default:
+            throw ZipError(message: "The file \(entry.name) uses an unsupported compression method")
+        }
+
+        if written != entry.uncompressedSize {
+            throw ZipError(message: "The file \(entry.name) lies about its size")
+        }
+        if crc.value != entry.crc32 {
+            throw ZipError(message: "The file \(entry.name) is corrupted")
+        }
+        return written
+    }
+
+    private func readChunk(remaining: Int64) throws -> Data {
+        let wanted = min(remaining, Int64(bufferSize))
+        guard let chunk = try handle.read(upToCount: Int(wanted)), !chunk.isEmpty else {
+            throw ZipError(message: "The file ended early")
+        }
+        return chunk
+    }
+
+    private func copyStored(entry: ZipEntry, emit: (Data) throws -> Void) throws {
+        if entry.compressedSize != entry.uncompressedSize {
+            throw ZipError(message: "The file \(entry.name) lies about its size")
+        }
+        var remaining = entry.compressedSize
+        while remaining > 0 {
+            let chunk = try readChunk(remaining: remaining)
+            remaining -= Int64(chunk.count)
+            try emit(chunk)
+        }
+    }
+
+    private func inflate(entry: ZipEntry, emit: (Data) throws -> Void) throws {
+        let stream = UnsafeMutablePointer<compression_stream>.allocate(capacity: 1)
+        defer { stream.deallocate() }
+        // COMPRESSION_ZLIB is raw DEFLATE, which is what ZIP stores.
+        guard compression_stream_init(stream, COMPRESSION_STREAM_DECODE, COMPRESSION_ZLIB)
+            == COMPRESSION_STATUS_OK
+        else { throw ZipError(message: "Could not start decompressing") }
+        defer { compression_stream_destroy(stream) }
+
+        let input = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer { input.deallocate() }
+        let output = UnsafeMutablePointer<UInt8>.allocate(capacity: bufferSize)
+        defer { output.deallocate() }
+
+        var remaining = entry.compressedSize
+        stream.pointee.src_ptr = UnsafePointer(input)
+        stream.pointee.src_size = 0
+        stream.pointee.dst_ptr = output
+        stream.pointee.dst_size = bufferSize
+
+        while true {
+            if stream.pointee.src_size == 0 && remaining > 0 {
+                let chunk = try readChunk(remaining: remaining)
+                chunk.copyBytes(to: input, count: chunk.count)
+                remaining -= Int64(chunk.count)
+                stream.pointee.src_ptr = UnsafePointer(input)
+                stream.pointee.src_size = chunk.count
+            }
+
+            let flags = remaining == 0 ? Int32(COMPRESSION_STREAM_FINALIZE.rawValue) : 0
+            let status = compression_stream_process(stream, flags)
+
+            let produced = bufferSize - stream.pointee.dst_size
+            if produced > 0 {
+                try emit(Data(bytes: output, count: produced))
+                stream.pointee.dst_ptr = output
+                stream.pointee.dst_size = bufferSize
+            }
+
+            switch status {
+            case COMPRESSION_STATUS_END:
+                if remaining != 0 || stream.pointee.src_size != 0 {
+                    throw ZipError(message: "The file \(entry.name) has extra data")
+                }
+                return
+            case COMPRESSION_STATUS_OK:
+                if remaining == 0 && stream.pointee.src_size == 0 && produced == 0 {
+                    // All input was consumed and nothing came out, so it can never finish.
+                    throw ZipError(message: "The file \(entry.name) is truncated")
+                }
+            default:
+                throw ZipError(message: "The file \(entry.name) could not be decompressed")
+            }
+        }
+    }
+
+    // MARK: Structure
+
+    private static func read(_ handle: FileHandle, at offset: Int64, count: Int) throws -> Data {
+        try handle.seek(toOffset: UInt64(offset))
+        guard let data = try handle.read(upToCount: count), data.count == count else {
+            throw ZipError(message: "The file ended early")
+        }
+        return data
+    }
+
+    private static func readDirectory(handle: FileHandle, fileSize: Int64) throws -> [ZipEntry] {
+        let end = try findEndOfDirectory(handle: handle, fileSize: fileSize)
+        guard end.uint16(4) == 0, end.uint16(6) == 0, end.uint16(8) == end.uint16(10) else {
+            throw ZipError(message: "Split ZIP files are not supported")
+        }
+        let count = Int(end.uint16(10))
+        let directorySize = Int64(end.uint32(12))
+        let directoryOffset = Int64(end.uint32(16))
+        if end.uint16(10) == 0xffff || end.uint32(12) == 0xffff_ffff || end.uint32(16) == 0xffff_ffff {
+            throw ZipError(message: "ZIP64 files are not supported")
+        }
+        if directoryOffset + directorySize > fileSize {
+            throw ZipError(message: "The directory is outside the file")
+        }
+        if directorySize > 64 * 1024 * 1024 {
+            throw ZipError(message: "The directory is too large")
+        }
+
+        let directory = ByteReader(
+            try read(handle, at: directoryOffset, count: Int(directorySize))
+        )
+        var entries: [ZipEntry] = []
+        entries.reserveCapacity(min(count, PackageRules.maxEntries))
+        var position = 0
+        for _ in 0..<count {
+            guard position + centralHeaderSize <= directory.count,
+                directory.uint32(position) == centralHeaderSignature
+            else { throw ZipError(message: "The directory is malformed") }
+
+            let flags = directory.uint16(position + 8)
+            let method = directory.uint16(position + 10)
+            let nameLength = Int(directory.uint16(position + 28))
+            let extraLength = Int(directory.uint16(position + 30))
+            let commentLength = Int(directory.uint16(position + 32))
+            let attributes = directory.uint32(position + 38)
+            let total = centralHeaderSize + nameLength + extraLength + commentLength
+            guard position + total <= directory.count else {
+                throw ZipError(message: "The directory is malformed")
+            }
+
+            if flags & flagEncrypted != 0 { throw ZipError(message: "A file is encrypted") }
+
+            let nameBytes = directory.data(position + centralHeaderSize, nameLength)
+            let name = try decodeName(nameBytes, flags: flags)
+            try checkExtraFields(directory.data(position + centralHeaderSize + nameLength, extraLength))
+
+            // Symbolic links could point outside the package folder after extraction.
+            let fileType = (attributes >> 16) & fileTypeMask
+            let isFolderType = fileType == 0o040000
+            if fileType != 0 && fileType != regularFile && !isFolderType {
+                throw ZipError(message: "The file \(name) is not a regular file")
+            }
+
+            entries.append(
+                ZipEntry(
+                    name: name,
+                    method: method,
+                    crc32: directory.uint32(position + 16),
+                    compressedSize: Int64(directory.uint32(position + 20)),
+                    uncompressedSize: Int64(directory.uint32(position + 24)),
+                    localHeaderOffset: Int64(directory.uint32(position + 42)),
+                    isFolder: name.hasSuffix("/") || isFolderType
+                )
+            )
+            position += total
+        }
+        guard position == directory.count else {
+            throw ZipError(message: "The directory has extra data")
+        }
+        return entries
+    }
+
+    /// Rejects names that different ZIP readers would decode differently. Otherwise the
+    /// server could approve one path while this device writes to another.
+    private static func decodeName(_ bytes: Data, flags: UInt16) throws -> String {
+        if flags & flagUTF8Name == 0, bytes.contains(where: { $0 >= 0x7f || $0 < 0x20 }) {
+            throw ZipError(message: "A file name is not ASCII and is not marked as UTF-8")
+        }
+        guard let name = String(data: bytes, encoding: .utf8) else {
+            throw ZipError(message: "A file name is not valid UTF-8")
+        }
+        return name
+    }
+
+    private static func checkExtraFields(_ extra: Data) throws {
+        let reader = ByteReader(extra)
+        var position = 0
+        while position + 4 <= reader.count {
+            if reader.uint16(position) == unicodePathExtraField {
+                throw ZipError(message: "A file has an alternative name, which is not allowed")
+            }
+            position += 4 + Int(reader.uint16(position + 2))
+        }
+    }
+
+    private static func findEndOfDirectory(handle: FileHandle, fileSize: Int64) throws -> ByteReader {
+        if fileSize < Int64(endOfDirectorySize) { throw ZipError(message: "Not a ZIP file") }
+        let tailSize = Int(min(fileSize, Int64(endOfDirectorySize + maxCommentSize)))
+        let tail = ByteReader(try read(handle, at: fileSize - Int64(tailSize), count: tailSize))
+
+        var position = tail.count - endOfDirectorySize
+        while position >= 0 {
+            // The comment length must reach exactly to the end, so comment bytes that merely
+            // look like this record are not mistaken for it.
+            if tail.uint32(position) == endOfDirectorySignature,
+                position + endOfDirectorySize + Int(tail.uint16(position + 20)) == tail.count
+            {
+                return ByteReader(tail.data(position, endOfDirectorySize))
+            }
+            position -= 1
+        }
+        throw ZipError(message: "Not a ZIP file")
+    }
+
+    /// Returns where the entry's bytes start. The local header must name the same file as
+    /// the directory, because other readers trust the local header instead.
+    private static func dataOffset(handle: FileHandle, fileSize: Int64, entry: ZipEntry) throws -> Int64 {
+        if entry.localHeaderOffset + Int64(localHeaderSize) > fileSize {
+            throw ZipError(message: "A file is outside the ZIP file")
+        }
+        let header = ByteReader(try read(handle, at: entry.localHeaderOffset, count: localHeaderSize))
+        guard header.uint32(0) == localHeaderSignature else {
+            throw ZipError(message: "A file header is malformed")
+        }
+        let nameLength = Int(header.uint16(26))
+        let extraLength = Int(header.uint16(28))
+        let nameBytes = try read(
+            handle, at: entry.localHeaderOffset + Int64(localHeaderSize), count: nameLength)
+        guard String(data: nameBytes, encoding: .utf8) == entry.name else {
+            throw ZipError(message: "The file \(entry.name) has a different name in its local header")
+        }
+        let start = entry.localHeaderOffset + Int64(localHeaderSize + nameLength + extraLength)
+        if start + entry.compressedSize > fileSize {
+            throw ZipError(message: "The file \(entry.name) is outside the ZIP file")
+        }
+        return start
+    }
+
+    /// Entries that share bytes let a tiny file expand enormously, so each must have its own.
+    private static func checkNoOverlap(handle: FileHandle, fileSize: Int64, entries: [ZipEntry]) throws {
+        let ranges = try entries.map { entry -> (start: Int64, end: Int64) in
+            let start = try dataOffset(handle: handle, fileSize: fileSize, entry: entry)
+            return (entry.localHeaderOffset, start + entry.compressedSize)
+        }.sorted { $0.start < $1.start }
+        for (previous, next) in zip(ranges, ranges.dropFirst()) where next.start < previous.end {
+            throw ZipError(message: "Files in the ZIP overlap")
+        }
+    }
+}
+
+/// Reads little-endian numbers without assuming alignment.
+private struct ByteReader {
+    private let bytes: [UInt8]
+    var count: Int { bytes.count }
+
+    init(_ data: Data) {
+        bytes = [UInt8](data)
+    }
+
+    func uint16(_ offset: Int) -> UInt16 {
+        UInt16(bytes[offset]) | UInt16(bytes[offset + 1]) << 8
+    }
+
+    func uint32(_ offset: Int) -> UInt32 {
+        UInt32(uint16(offset)) | UInt32(uint16(offset + 2)) << 16
+    }
+
+    func data(_ offset: Int, _ length: Int) -> Data {
+        Data(bytes[offset..<(offset + length)])
+    }
+}
+
+/// ZIP's checksum. It also catches mistakes in the decompression code above.
+private struct CRC32 {
+    private static let table: [UInt32] = (0..<256).map { index in
+        var value = UInt32(index)
+        for _ in 0..<8 {
+            value = value & 1 == 1 ? 0xedb8_8320 ^ (value >> 1) : value >> 1
+        }
+        return value
+    }
+
+    private var state: UInt32 = 0xffff_ffff
+
+    var value: UInt32 { ~state }
+
+    mutating func update(_ data: Data) {
+        var current = state
+        data.withUnsafeBytes { raw in
+            for byte in raw {
+                current = CRC32.table[Int((current ^ UInt32(byte)) & 0xff)] ^ (current >> 8)
+            }
+        }
+        state = current
+    }
+}

package/ios/React/RovqHost.swift

@@ -0,0 +1,253 @@
+import Foundation
+import React
+import UIKit
+
+/// What an app supplies. Everything here ships inside the app, so nothing here is secret.
+public struct RovqConfig {
+    public let apiURL: String
+    public let deploymentKey: String
+    /// Change this whenever native code changes.
+    public let runtimeVersion: String
+    /// Key IDs and their Base64 Ed25519 public keys.
+    public let trustedKeys: [String: String]
+    /// Allows http:// for local development only.
+    public let allowInsecureURLs: Bool
+
+    public init(
+        apiURL: String,
+        deploymentKey: String,
+        runtimeVersion: String,
+        trustedKeys: [String: String],
+        allowInsecureURLs: Bool = false
+    ) {
+        self.apiURL = apiURL
+        self.deploymentKey = deploymentKey
+        self.runtimeVersion = runtimeVersion
+        self.trustedKeys = trustedKeys
+        self.allowInsecureURLs = allowInsecureURLs
+    }
+}
+
+/// Connects the engine to React Native. Call `initialize` when the app starts, and return
+/// `bundleURL()` from the React Native delegate.
+@objc(RovqHost)
+public final class RovqHost: NSObject {
+    private static var engine: RovqEngine?
+    private static var backgroundObservers: [NSObjectProtocol] = []
+    private static var isGuarding = false
+    private static var previousFatalHandler: RCTFatalHandler?
+    private static var previousExceptionHandler: RCTFatalExceptionHandler?
+
+    /// Must run before React Native starts. If the settings are unusable, the app still runs
+    /// the bundle inside it, and no update is ever accepted.
+    public static func initialize(config: RovqConfig) {
+        guard engine == nil else { return }
+        let info = Bundle.main.infoDictionary ?? [:]
+        let support = FileManager.default.urls(for: .applicationSupportDirectory, in: .userDomainMask)[0]
+        do {
+            engine = try RovqEngine(
+                rootFolder: support.appendingPathComponent("rovq", isDirectory: true),
+                config: EngineConfig(
+                    apiURL: config.apiURL,
+                    deploymentKey: config.deploymentKey,
+                    runtimeVersion: config.runtimeVersion,
+                    binaryVersion: info["CFBundleShortVersionString"] as? String ?? "0",
+                    binaryId: binaryId(info),
+                    trustedKeys: config.trustedKeys,
+                    allowInsecureURLs: config.allowInsecureURLs
+                )
+            )
+            watchForBackground()
+        } catch {
+            NSLog("Rovq: could not start, so updates are off: %@", error.localizedDescription)
+        }
+    }
+
+    /// An app with scenes gets the scene notification, and one without gets the app one. With
+    /// several windows, only the last one leaving counts as leaving the app.
+    private static func watchForBackground() {
+        let center = NotificationCenter.default
+        backgroundObservers = [
+            center.addObserver(forName: UIApplication.didEnterBackgroundNotification, object: nil, queue: .main) { _ in
+                engine?.noteBackgrounded()
+            },
+            center.addObserver(forName: UIScene.didEnterBackgroundNotification, object: nil, queue: .main) { _ in
+                let scenes = UIApplication.shared.connectedScenes
+                if scenes.allSatisfy({ $0.activationState == .background }) {
+                    engine?.noteBackgrounded()
+                }
+            },
+        ]
+    }
+
+    /// React Native calls this each time JavaScript starts, including on reload. Returns nil
+    /// for the bundle inside the app.
+    public static func bundleURL() -> URL? {
+        guard let engine else { return nil }
+        let bundle = engine.resolveBundle()
+        if engine.status().tryingReleaseId != nil {
+            startGuarding()
+        } else {
+            stopGuarding()
+        }
+        NSLog("Rovq: loading %@", bundle?.path ?? "the bundle inside the app")
+        return bundle
+    }
+
+    /// Without this, code that throws before registerComponent leaves a blank screen with the
+    /// process alive, so rollback would not run until the user closed the app. It applies only
+    /// while a release is being tried. After that, the app's own fatal handling is restored.
+    /// See docs/ios-bundle-loading.md.
+    private static func startGuarding() {
+        guard !isGuarding else { return }
+        isGuarding = true
+        previousFatalHandler = RCTGetFatalHandler()
+        previousExceptionHandler = RCTGetFatalExceptionHandler()
+        RCTSetFatalHandler { error in
+            NSLog("Rovq: this update failed to start: %@", error?.localizedDescription ?? "unknown")
+            engine?.noteCrashed()
+            abort()
+        }
+        RCTSetFatalExceptionHandler { exception in
+            NSLog("Rovq: this update failed to start: %@", exception?.reason ?? "unknown")
+            engine?.noteCrashed()
+            abort()
+        }
+    }
+
+    private static func stopGuarding() {
+        guard isGuarding else { return }
+        isGuarding = false
+        RCTSetFatalHandler(previousFatalHandler)
+        RCTSetFatalExceptionHandler(previousExceptionHandler)
+    }
+
+    /// The modification date changes when the app itself is updated, even at the same version.
+    private static func binaryId(_ info: [String: Any]) -> String {
+        let version = info["CFBundleShortVersionString"] as? String ?? "0"
+        let build = info["CFBundleVersion"] as? String ?? "0"
+        let modified = Bundle.main.executableURL.flatMap {
+            try? $0.resourceValues(forKeys: [.contentModificationDateKey]).contentModificationDate
+        }
+        return "\(version):\(build):\(modified?.timeIntervalSince1970 ?? 0)"
+    }
+
+    // MARK: Used by the native module
+
+    @objc public static func notifyReady() {
+        engine?.notifyReady()
+        stopGuarding()
+    }
+
+    // The methods below run on a background queue, because they use the network and the disk.
+
+    @objc public static func checkForUpdate(completion: @escaping ([String: Any]) -> Void) {
+        run(completion) { engine in
+            switch engine.checkForUpdate() {
+            case .upToDate:
+                return ["result": "UP_TO_DATE"]
+            case .rolledBack:
+                return ["result": "ROLLED_BACK"]
+            case .updateAvailable(let update, let alreadyDownloaded):
+                return [
+                    "result": "UPDATE_AVAILABLE",
+                    "update": dictionary(update),
+                    "alreadyDownloaded": alreadyDownloaded,
+                ]
+            case .failed(let code, let message):
+                return failure(code, message)
+            }
+        }
+    }
+
+    @objc public static func downloadUpdate(
+        onProgress: @escaping (Int64, Int64) -> Void,
+        completion: @escaping ([String: Any]) -> Void
+    ) {
+        let throttle = ProgressThrottle(onChange: onProgress)
+        run(completion) { engine in
+            switch engine.downloadUpdate(onProgress: throttle.report) {
+            case .downloaded(let update):
+                return ["result": "DOWNLOADED", "update": dictionary(update)]
+            case .failed(let code, let message):
+                return failure(code, message)
+            }
+        }
+    }
+
+    @objc public static func installUpdate(completion: @escaping ([String: Any]) -> Void) {
+        run(completion) { engine in
+            switch engine.installUpdate() {
+            case .installed(let releaseId):
+                return ["result": "INSTALLED", "releaseId": releaseId]
+            case .failed(let code, let message):
+                return failure(code, message)
+            }
+        }
+    }
+
+    @objc public static func sync(
+        onProgress: @escaping (Int64, Int64) -> Void,
+        completion: @escaping ([String: Any]) -> Void
+    ) {
+        let throttle = ProgressThrottle(onChange: onProgress)
+        run(completion) { engine in
+            switch engine.sync(onProgress: throttle.report) {
+            case .upToDate:
+                return ["result": "UP_TO_DATE"]
+            case .rolledBack:
+                return ["result": "ROLLED_BACK"]
+            case .updateReady(let releaseId, let mandatory):
+                return ["result": "UPDATE_READY", "releaseId": releaseId, "mandatory": mandatory]
+            case .failed(let code, let message):
+                return failure(code, message)
+            }
+        }
+    }
+
+    @objc public static func rollback(completion: @escaping (Bool) -> Void) {
+        DispatchQueue.global(qos: .utility).async {
+            let result = engine?.rollback() ?? false
+            completion(result)
+        }
+    }
+
+    @objc public static func status() -> [String: Any] {
+        guard let status = engine?.status() else { return [:] }
+        return [
+            "deviceId": status.deviceId,
+            "currentReleaseId": status.currentReleaseId ?? NSNull(),
+            "downloadedReleaseId": status.downloadedReleaseId ?? NSNull(),
+            "pendingReleaseId": status.pendingReleaseId ?? NSNull(),
+            "tryingReleaseId": status.tryingReleaseId ?? NSNull(),
+            "highestSequence": status.highestSequence,
+        ]
+    }
+
+    private static func run(
+        _ completion: @escaping ([String: Any]) -> Void,
+        work: @escaping (RovqEngine) -> [String: Any]
+    ) {
+        DispatchQueue.global(qos: .utility).async {
+            guard let engine else {
+                completion(failure(.engineUnavailable, "RovqHost.initialize was not called, or could not start"))
+                return
+            }
+            completion(work(engine))
+        }
+    }
+
+    private static func failure(_ code: RovqErrorCode, _ message: String) -> [String: Any] {
+        NSLog("Rovq: failed with %@: %@", code.rawValue, message)
+        return ["result": "FAILED", "code": code.rawValue, "message": message]
+    }
+
+    private static func dictionary(_ update: UpdateInfo) -> [String: Any] {
+        [
+            "releaseId": update.releaseId,
+            "sequence": update.sequence,
+            "mandatory": update.mandatory,
+            "packageSize": update.packageSize,
+        ]
+    }
+}