pulse-updates 1.0.0

package/ios/PulseUpdates/Database/PulseDatabaseSchema.swift

@@ -0,0 +1,229 @@
+// PulseUpdates Database Schema and Initialization
+// Based on expo-updates UpdatesDatabaseInitialization
+
+import Foundation
+import SQLite3
+
+// MARK: - Schema Definition
+
+struct PulseDatabaseSchema {
+    static let version = 1
+    static let filename = "pulse-v\(version).db"
+
+    /// Current database schema
+    static let schema = """
+        -- Updates table: stores update metadata
+        CREATE TABLE IF NOT EXISTS updates (
+            update_id TEXT PRIMARY KEY NOT NULL,
+            scope_key TEXT NOT NULL,
+            runtime_version TEXT NOT NULL,
+            commit_time INTEGER NOT NULL,
+            status TEXT NOT NULL DEFAULT 'pending',
+            keep INTEGER NOT NULL DEFAULT 1,
+            manifest TEXT,
+            bundle_hash TEXT,
+            last_accessed INTEGER,
+            successful_launch_count INTEGER NOT NULL DEFAULT 0,
+            failed_launch_count INTEGER NOT NULL DEFAULT 0
+        );
+
+        -- Assets table: stores asset metadata
+        CREATE TABLE IF NOT EXISTS assets (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            asset_key TEXT,
+            asset_hash TEXT NOT NULL,
+            url TEXT,
+            type TEXT,
+            metadata TEXT,
+            download_time INTEGER,
+            relative_path TEXT,
+            expected_hash TEXT,
+            extra_request_headers TEXT,
+            marked_for_deletion INTEGER NOT NULL DEFAULT 0,
+            -- Embedded asset info (for fallback)
+            ns_bundle_dir TEXT,
+            ns_bundle_filename TEXT
+        );
+
+        -- Junction table: links updates to assets
+        CREATE TABLE IF NOT EXISTS update_assets (
+            update_id TEXT NOT NULL,
+            asset_id INTEGER NOT NULL,
+            asset_key TEXT,
+            asset_hash TEXT NOT NULL,
+            is_launch_asset INTEGER NOT NULL DEFAULT 0,
+            FOREIGN KEY (update_id) REFERENCES updates(update_id) ON DELETE CASCADE,
+            FOREIGN KEY (asset_id) REFERENCES assets(id) ON DELETE CASCADE,
+            PRIMARY KEY (update_id, asset_id)
+        );
+
+        -- Health table: tracks update launch health
+        CREATE TABLE IF NOT EXISTS health (
+            update_id TEXT PRIMARY KEY NOT NULL,
+            launch_in_progress_at INTEGER,
+            app_ready_at INTEGER,
+            last_launch_at INTEGER,
+            successful_launch_count INTEGER NOT NULL DEFAULT 0,
+            failed_launch_count INTEGER NOT NULL DEFAULT 0,
+            consecutive_failures INTEGER NOT NULL DEFAULT 0,
+            FOREIGN KEY (update_id) REFERENCES updates(update_id) ON DELETE CASCADE
+        );
+
+        -- JSON data table: stores manifest filters and other metadata
+        CREATE TABLE IF NOT EXISTS json_data (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            scope_key TEXT NOT NULL,
+            key TEXT NOT NULL,
+            value TEXT NOT NULL,
+            last_updated INTEGER NOT NULL,
+            UNIQUE(scope_key, key)
+        );
+
+        -- Indexes for performance
+        CREATE INDEX IF NOT EXISTS idx_updates_scope_runtime ON updates(scope_key, runtime_version);
+        CREATE INDEX IF NOT EXISTS idx_updates_commit_time ON updates(commit_time DESC);
+        CREATE INDEX IF NOT EXISTS idx_assets_hash ON assets(asset_hash);
+        CREATE INDEX IF NOT EXISTS idx_update_assets_update ON update_assets(update_id);
+        CREATE INDEX IF NOT EXISTS idx_update_assets_hash ON update_assets(asset_hash);
+        CREATE INDEX IF NOT EXISTS idx_json_data_scope ON json_data(scope_key);
+    """
+}
+
+// MARK: - Database Initialization
+
+final class PulseDatabaseInitialization {
+
+    /// Initialize or open the database with the latest schema
+    static func initializeDatabase(inDirectory directory: URL) throws -> OpaquePointer {
+        let dbPath = directory.appendingPathComponent(PulseDatabaseSchema.filename)
+        let isNewDatabase = !FileManager.default.fileExists(atPath: dbPath.path)
+
+        // Try to migrate from older versions if needed
+        if !isNewDatabase {
+            // Database exists, no migration needed for v1
+        } else {
+            // Check for legacy database and migrate if needed
+            migrateLegacyDatabaseIfNeeded(inDirectory: directory, toPath: dbPath)
+        }
+
+        // Open database
+        var db: OpaquePointer?
+        let result = sqlite3_open(dbPath.path, &db)
+
+        guard result == SQLITE_OK, let database = db else {
+            let error = db != nil ? String(cString: sqlite3_errmsg(db)) : "Unknown error"
+            sqlite3_close(db)
+
+            // If database is corrupt, try to recover
+            if result == SQLITE_CORRUPT || result == SQLITE_NOTADB {
+                try handleCorruptDatabase(at: dbPath, inDirectory: directory)
+                return try initializeDatabase(inDirectory: directory)
+            }
+
+            throw PulseDatabaseError.openFailed(code: result, message: error)
+        }
+
+        // Enable foreign keys
+        sqlite3_exec(database, "PRAGMA foreign_keys=ON;", nil, nil, nil)
+
+        // Initialize schema if new database
+        if isNewDatabase || !hasRequiredTables(db: database) {
+            try initializeSchema(db: database)
+        }
+
+        return database
+    }
+
+    /// Check if database has all required tables
+    private static func hasRequiredTables(db: OpaquePointer) -> Bool {
+        let tables = ["updates", "assets", "update_assets", "health", "json_data"]
+
+        for table in tables {
+            let sql = "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+            do {
+                let rows = try PulseDatabaseUtils.execute(sql: sql, args: [table], db: db)
+                if rows.isEmpty {
+                    return false
+                }
+            } catch {
+                return false
+            }
+        }
+
+        return true
+    }
+
+    /// Initialize database schema
+    private static func initializeSchema(db: OpaquePointer) throws {
+        guard sqlite3_exec(db, PulseDatabaseSchema.schema, nil, nil, nil) == SQLITE_OK else {
+            throw PulseDatabaseError.schemaInitFailed
+        }
+    }
+
+    /// Handle corrupt database by archiving and creating new
+    private static func handleCorruptDatabase(at dbPath: URL, inDirectory directory: URL) throws {
+        let archiveName = String(format: "corrupt-%.0f-%@", Date().timeIntervalSince1970, PulseDatabaseSchema.filename)
+        let archivePath = directory.appendingPathComponent(archiveName)
+
+        do {
+            try FileManager.default.moveItem(at: dbPath, to: archivePath)
+            print("[PulseUpdates] Archived corrupt database to \(archiveName)")
+        } catch {
+            // If we can't move, try to delete
+            try? FileManager.default.removeItem(at: dbPath)
+        }
+    }
+
+    /// Migrate from legacy pulse.db if exists
+    private static func migrateLegacyDatabaseIfNeeded(inDirectory directory: URL, toPath newPath: URL) {
+        let legacyPath = directory.appendingPathComponent("pulse.db")
+
+        if FileManager.default.fileExists(atPath: legacyPath.path) {
+            do {
+                // Open legacy database
+                var legacyDb: OpaquePointer?
+                guard sqlite3_open(legacyPath.path, &legacyDb) == SQLITE_OK else {
+                    return
+                }
+                defer { sqlite3_close(legacyDb) }
+
+                // Copy to new location
+                try FileManager.default.copyItem(at: legacyPath, to: newPath)
+
+                // Archive legacy database
+                let archiveName = "legacy-pulse.db"
+                let archivePath = directory.appendingPathComponent(archiveName)
+                try? FileManager.default.moveItem(at: legacyPath, to: archivePath)
+
+                print("[PulseUpdates] Migrated legacy database")
+            } catch {
+                print("[PulseUpdates] Failed to migrate legacy database: \(error)")
+            }
+        }
+    }
+}
+
+// MARK: - Database Migrations
+
+/// Protocol for database migrations
+protocol PulseDatabaseMigration {
+    var fromVersion: Int { get }
+    var toVersion: Int { get }
+    func run(db: OpaquePointer) throws
+}
+
+/// Migration registry
+final class PulseDatabaseMigrationRegistry {
+    static let migrations: [PulseDatabaseMigration] = [
+        // Add migrations here as needed
+        // PulseMigration1To2(),
+    ]
+
+    static func migrate(db: OpaquePointer, fromVersion: Int, toVersion: Int) throws {
+        for migration in migrations {
+            if migration.fromVersion >= fromVersion && migration.toVersion <= toVersion {
+                try migration.run(db: db)
+            }
+        }
+    }
+}

package/ios/PulseUpdates/Database/PulseDatabaseUtils.swift

@@ -0,0 +1,247 @@
+// PulseUpdates Database Utilities
+// Based on expo-updates UpdatesDatabaseUtils
+
+import Foundation
+import SQLite3
+
+// MARK: - Error Types
+
+enum PulseDatabaseError: Error, LocalizedError {
+    case openFailed(code: Int32, message: String)
+    case prepareFailed(code: Int32, message: String)
+    case executeFailed(code: Int32, message: String)
+    case bindFailed(code: Int32, message: String)
+    case migrationFailed(message: String)
+    case corruptDatabase
+    case schemaInitFailed
+
+    var errorDescription: String? {
+        switch self {
+        case .openFailed(let code, let message):
+            return "Failed to open database (code \(code)): \(message)"
+        case .prepareFailed(let code, let message):
+            return "Failed to prepare statement (code \(code)): \(message)"
+        case .executeFailed(let code, let message):
+            return "Failed to execute statement (code \(code)): \(message)"
+        case .bindFailed(let code, let message):
+            return "Failed to bind parameter (code \(code)): \(message)"
+        case .migrationFailed(let message):
+            return "Migration failed: \(message)"
+        case .corruptDatabase:
+            return "Database is corrupt"
+        case .schemaInitFailed:
+            return "Failed to initialize database schema"
+        }
+    }
+}
+
+// MARK: - SQLite Constants
+
+let SQLITE_STATIC = unsafeBitCast(0, to: sqlite3_destructor_type.self)
+let SQLITE_TRANSIENT = unsafeBitCast(-1, to: sqlite3_destructor_type.self)
+
+// MARK: - Database Utils
+
+final class PulseDatabaseUtils {
+
+    /// Execute a SQL query with optional arguments and return results
+    static func execute(
+        sql: String,
+        args: [Any?]? = nil,
+        db: OpaquePointer
+    ) throws -> [[String: Any?]] {
+        var stmt: OpaquePointer?
+
+        guard sqlite3_prepare_v2(db, sql, -1, &stmt, nil) == SQLITE_OK else {
+            throw PulseDatabaseError.prepareFailed(
+                code: sqlite3_errcode(db),
+                message: String(cString: sqlite3_errmsg(db))
+            )
+        }
+
+        defer { sqlite3_finalize(stmt) }
+
+        // Bind arguments if provided
+        if let args = args {
+            try bindArgs(args, to: stmt!, db: db)
+        }
+
+        // Execute and collect results
+        var rows: [[String: Any?]] = []
+        var columnNames: [String]?
+
+        while true {
+            let result = sqlite3_step(stmt)
+
+            switch result {
+            case SQLITE_ROW:
+                // Fetch column names on first row
+                if columnNames == nil {
+                    columnNames = getColumnNames(stmt!)
+                }
+
+                let row = getRowValues(stmt!, columnNames: columnNames!)
+                rows.append(row)
+
+            case SQLITE_DONE:
+                return rows
+
+            default:
+                throw PulseDatabaseError.executeFailed(
+                    code: sqlite3_errcode(db),
+                    message: String(cString: sqlite3_errmsg(db))
+                )
+            }
+        }
+    }
+
+    /// Execute a SQL statement without returning results
+    static func executeUpdate(
+        sql: String,
+        args: [Any?]? = nil,
+        db: OpaquePointer
+    ) throws {
+        _ = try execute(sql: sql, args: args, db: db)
+    }
+
+    /// Execute raw SQL (for schema creation)
+    static func executeRaw(sql: String, db: OpaquePointer) throws {
+        guard sqlite3_exec(db, sql, nil, nil, nil) == SQLITE_OK else {
+            throw PulseDatabaseError.executeFailed(
+                code: sqlite3_errcode(db),
+                message: String(cString: sqlite3_errmsg(db))
+            )
+        }
+    }
+
+    // MARK: - Private Helpers
+
+    private static func bindArgs(_ args: [Any?], to stmt: OpaquePointer, db: OpaquePointer) throws {
+        for (index, arg) in args.enumerated() {
+            let bindIdx = Int32(index + 1)
+            var result: Int32 = SQLITE_OK
+
+            switch arg {
+            case nil:
+                result = sqlite3_bind_null(stmt, bindIdx)
+
+            case let value as Int:
+                result = sqlite3_bind_int64(stmt, bindIdx, Int64(value))
+
+            case let value as Int64:
+                result = sqlite3_bind_int64(stmt, bindIdx, value)
+
+            case let value as Double:
+                result = sqlite3_bind_double(stmt, bindIdx, value)
+
+            case let value as String:
+                result = sqlite3_bind_text(stmt, bindIdx, value, -1, SQLITE_TRANSIENT)
+
+            case let value as Data:
+                result = value.withUnsafeBytes { ptr in
+                    sqlite3_bind_blob(stmt, bindIdx, ptr.baseAddress, Int32(value.count), SQLITE_TRANSIENT)
+                }
+
+            case let value as Date:
+                let timestamp = Int64(value.timeIntervalSince1970 * 1000)
+                result = sqlite3_bind_int64(stmt, bindIdx, timestamp)
+
+            case let value as Bool:
+                result = sqlite3_bind_int(stmt, bindIdx, value ? 1 : 0)
+
+            case let value as [String: Any]:
+                if let jsonData = try? JSONSerialization.data(withJSONObject: value),
+                   let jsonString = String(data: jsonData, encoding: .utf8) {
+                    result = sqlite3_bind_text(stmt, bindIdx, jsonString, -1, SQLITE_TRANSIENT)
+                } else {
+                    result = sqlite3_bind_null(stmt, bindIdx)
+                }
+
+            default:
+                // Try to convert to string
+                let stringValue = String(describing: arg!)
+                result = sqlite3_bind_text(stmt, bindIdx, stringValue, -1, SQLITE_TRANSIENT)
+            }
+
+            guard result == SQLITE_OK else {
+                throw PulseDatabaseError.bindFailed(
+                    code: sqlite3_errcode(db),
+                    message: String(cString: sqlite3_errmsg(db))
+                )
+            }
+        }
+    }
+
+    private static func getColumnNames(_ stmt: OpaquePointer) -> [String] {
+        let count = sqlite3_column_count(stmt)
+        var names: [String] = []
+
+        for i in 0..<count {
+            if let name = sqlite3_column_name(stmt, i) {
+                names.append(String(cString: name))
+            } else {
+                names.append("column_\(i)")
+            }
+        }
+
+        return names
+    }
+
+    private static func getRowValues(_ stmt: OpaquePointer, columnNames: [String]) -> [String: Any?] {
+        var row: [String: Any?] = [:]
+
+        for (i, name) in columnNames.enumerated() {
+            let col = Int32(i)
+            let type = sqlite3_column_type(stmt, col)
+
+            switch type {
+            case SQLITE_INTEGER:
+                row[name] = sqlite3_column_int64(stmt, col)
+
+            case SQLITE_FLOAT:
+                row[name] = sqlite3_column_double(stmt, col)
+
+            case SQLITE_TEXT:
+                if let text = sqlite3_column_text(stmt, col) {
+                    row[name] = String(cString: text)
+                } else {
+                    row[name] = nil
+                }
+
+            case SQLITE_BLOB:
+                let bytes = sqlite3_column_bytes(stmt, col)
+                if bytes > 0, let blob = sqlite3_column_blob(stmt, col) {
+                    row[name] = Data(bytes: blob, count: Int(bytes))
+                } else {
+                    row[name] = nil
+                }
+
+            case SQLITE_NULL:
+                row[name] = nil
+
+            default:
+                row[name] = nil
+            }
+        }
+
+        return row
+    }
+
+    /// Get error info from database
+    static func errorInfo(db: OpaquePointer?) -> (code: Int32, message: String) {
+        guard let db = db else {
+            return (0, "No database connection")
+        }
+        return (sqlite3_errcode(db), String(cString: sqlite3_errmsg(db)))
+    }
+
+    /// Convert milliseconds timestamp to Date
+    static func dateFromMillis(_ millis: Int64) -> Date {
+        return Date(timeIntervalSince1970: Double(millis) / 1000.0)
+    }
+
+    /// Convert Date to milliseconds timestamp
+    static func millisFromDate(_ date: Date) -> Int64 {
+        return Int64(date.timeIntervalSince1970 * 1000)
+    }
+}