@sriinnu/runic 2.0.0 → 2.11.2

package/Packages/Silo/Sources/Silo/BrowserCookieClient.swift

@@ -1,326 +0,0 @@
-import Foundation
-
-#if canImport(FoundationNetworking)
-import FoundationNetworking
-#endif
-
-/// High-level API for enumerating and reading browser cookies.
-public struct BrowserCookieClient: Sendable {
-    public enum MutationError: LocalizedError, Sendable {
-        case duplicateCookie(details: String)
-        case missingCookie(details: String)
-
-        public var errorDescription: String? {
-            switch self {
-            case let .duplicateCookie(details):
-                return "Cookie already exists: \(details)"
-            case let .missingCookie(details):
-                return "Cookie not found: \(details)"
-            }
-        }
-    }
-
-    public struct Configuration: Sendable {
-        public var homeDirectories: [URL]
-        public var decryptionFailurePolicy: BrowserCookieDecryptionFailurePolicy
-
-        public init(
-            homeDirectories: [URL] = Self.defaultHomeDirectories(),
-            decryptionFailurePolicy: BrowserCookieDecryptionFailurePolicy = .bestEffort)
-        {
-            self.homeDirectories = homeDirectories
-            self.decryptionFailurePolicy = decryptionFailurePolicy
-        }
-
-        public static func defaultHomeDirectories() -> [URL] {
-            var dirs: [URL] = []
-            #if os(macOS) || os(iOS)
-            dirs.append(FileManager.default.homeDirectoryForCurrentUser)
-            #elseif os(Linux) || os(Windows)
-            if let home = ProcessInfo.processInfo.environment["HOME"] {
-                dirs.append(URL(fileURLWithPath: home))
-            }
-            #endif
-            return dirs
-        }
-    }
-
-    public let configuration: Configuration
-
-    public init(configuration: Configuration = Configuration()) {
-        self.configuration = configuration
-    }
-
-    /// Returns cookie stores for a specific browser.
-    public func stores(for browser: Browser) -> [BrowserCookieStore] {
-        Self.backend(for: browser).stores(for: browser, configuration: self.configuration)
-    }
-
-    /// Returns cookie stores for multiple browsers.
-    public func stores(in browsers: [Browser]) -> [BrowserCookieStore] {
-        browsers.flatMap { self.stores(for: $0) }
-    }
-
-    /// Loads cookie records from multiple browsers.
-    public func records(
-        matching query: BrowserCookieQuery,
-        in browsers: [Browser]) throws -> [BrowserCookieStoreRecords]
-    {
-        try browsers.flatMap { try self.records(matching: query, in: $0) }
-    }
-
-    /// Loads cookie records from a specific browser.
-    public func records(
-        matching query: BrowserCookieQuery,
-        in browser: Browser) throws -> [BrowserCookieStoreRecords]
-    {
-        let stores = self.stores(for: browser)
-        return try stores.compactMap { store in
-            let records = try self.records(matching: query, in: store)
-            guard !records.isEmpty else { return nil }
-            return BrowserCookieStoreRecords(store: store, records: records)
-        }
-    }
-
-    /// Loads cookie records from a specific cookie store.
-    public func records(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieStore) throws -> [BrowserCookieRecord]
-    {
-        let records = try Self.backend(for: store.browser).records(
-            matching: query,
-            in: store,
-            configuration: self.configuration)
-        return try Self.apply(query: query, to: records)
-    }
-
-    /// Loads HTTPCookie values from a specific store.
-    public func cookies(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieStore) throws -> [HTTPCookie]
-    {
-        let records = try self.records(matching: query, in: store)
-        return Self.makeHTTPCookies(records, origin: query.origin)
-    }
-
-    /// Loads HTTPCookie values from multiple browser stores.
-    public func cookies(
-        matching query: BrowserCookieQuery,
-        in browser: Browser) throws -> [HTTPCookie]
-    {
-        let sources = try self.records(matching: query, in: browser)
-        return sources.flatMap { $0.cookies(origin: query.origin) }
-    }
-
-    /// Loads HTTPCookie values from multiple browsers.
-    public func cookies(
-        matching query: BrowserCookieQuery,
-        in browsers: [Browser]) throws -> [HTTPCookie]
-    {
-        let sources = try self.records(matching: query, in: browsers)
-        return sources.flatMap { $0.cookies(origin: query.origin) }
-    }
-
-    /// Convert cookie records into HTTPCookie values.
-    public static func makeHTTPCookies(
-        _ records: [BrowserCookieRecord],
-        origin: BrowserCookieOriginStrategy = .domainBased) -> [HTTPCookie]
-    {
-        records.compactMap { record in
-            let host = record.domain.trimmingCharacters(in: .whitespacesAndNewlines)
-            guard !host.isEmpty else { return nil }
-            let domain = record.isHostOnly ? host : ".\(host)"
-            var props: [HTTPCookiePropertyKey: Any] = [
-                .domain: domain,
-                .name: record.name,
-                .path: record.path,
-                .value: record.value,
-            ]
-            if record.isSecure {
-                props[.secure] = "TRUE"
-            }
-            if record.isHTTPOnly {
-                props[HTTPCookiePropertyKey("HttpOnly")] = "TRUE"
-            }
-            if let expires = record.expires {
-                props[.expires] = expires
-            }
-            if let sameSite = record.sameSite {
-                props[HTTPCookiePropertyKey("SameSite")] = sameSite.propertyValue
-            }
-            if let originURL = origin.resolve(domain: host) {
-                props[.originURL] = originURL
-            }
-            return HTTPCookie(properties: props)
-        }
-    }
-
-    private static func backend(for browser: Browser) -> BrowserCookieBackend {
-        BrowserCookieBackendRegistry.backend(for: browser)
-    }
-
-    static func apply(
-        query: BrowserCookieQuery,
-        to records: [BrowserCookieRecord]) throws -> [BrowserCookieRecord]
-    {
-        var filtered = records
-
-        if !query.includeExpired {
-            filtered = filtered.filter { record in
-                guard let expires = record.expires else { return true }
-                return expires >= query.referenceDate
-            }
-        }
-
-        if query.excludeSession {
-            filtered = filtered.filter { !$0.isSession }
-        }
-
-        if let minExpiry = query.minExpiryDate {
-            filtered = filtered.filter { record in
-                guard let expires = record.expires else { return false }
-                return expires >= minExpiry
-            }
-        }
-
-        if let maxExpiry = query.maxExpiryDate {
-            filtered = filtered.filter { record in
-                guard let expires = record.expires else { return false }
-                return expires <= maxExpiry
-            }
-        }
-
-        if let secureOnly = query.secureOnly {
-            filtered = filtered.filter { $0.isSecure == secureOnly }
-        }
-
-        if let httpOnlyOnly = query.httpOnlyOnly {
-            filtered = filtered.filter { $0.isHTTPOnly == httpOnlyOnly }
-        }
-
-        if let sameSite = query.sameSite {
-            filtered = filtered.filter { $0.sameSite == sameSite }
-        }
-
-        if !query.paths.isEmpty {
-            filtered = filtered.filter { record in
-                Self.matchesPath(record.path, patterns: query.paths, match: query.pathMatch)
-            }
-        }
-
-        if query.useRegex, let pattern = query.pathPattern, !pattern.isEmpty {
-            let regex: NSRegularExpression
-            do {
-                regex = try NSRegularExpression(pattern: pattern, options: [])
-            } catch {
-                throw BrowserCookieQueryError.invalidPathPattern(pattern)
-            }
-            filtered = filtered.filter { record in
-                let range = NSRange(record.path.startIndex..<record.path.endIndex, in: record.path)
-                return regex.firstMatch(in: record.path, options: [], range: range) != nil
-            }
-        }
-
-        if !query.domains.isEmpty {
-            filtered = filtered.filter { record in
-                Self.matchesDomain(record.domain, patterns: query.domains, match: query.domainMatch)
-            }
-        }
-
-        if query.useRegex, let pattern = query.domainPattern, !pattern.isEmpty {
-            let regex: NSRegularExpression
-            do {
-                regex = try NSRegularExpression(pattern: pattern, options: [.caseInsensitive])
-            } catch {
-                throw BrowserCookieQueryError.invalidDomainPattern(pattern)
-            }
-            filtered = filtered.filter { record in
-                let range = NSRange(record.domain.startIndex..<record.domain.endIndex, in: record.domain)
-                return regex.firstMatch(in: record.domain, options: [], range: range) != nil
-            }
-        }
-
-        return filtered
-    }
-
-    private static func matchesDomain(
-        _ domain: String,
-        patterns: [String],
-        match: BrowserCookieDomainMatch) -> Bool
-    {
-        let host = domain.lowercased()
-        for pattern in patterns {
-            let trimmed = pattern.trimmingCharacters(in: .whitespacesAndNewlines)
-            if trimmed.isEmpty { continue }
-            let normalized = trimmed.hasPrefix(".") ? String(trimmed.dropFirst()) : trimmed
-            let target = normalized.lowercased()
-            switch match {
-            case .contains:
-                if host.contains(target) { return true }
-            case .suffix:
-                if host == target || host.hasSuffix(".\(target)") { return true }
-            case .exact:
-                if host == target { return true }
-            }
-        }
-        return false
-    }
-
-    private static func matchesPath(
-        _ path: String,
-        patterns: [String],
-        match: BrowserCookiePathMatch) -> Bool
-    {
-        for pattern in patterns {
-            if pattern.isEmpty { continue }
-            switch match {
-            case .contains:
-                if path.contains(pattern) { return true }
-            case .prefix:
-                if path.hasPrefix(pattern) { return true }
-            case .exact:
-                if path == pattern { return true }
-            }
-        }
-        return false
-    }
-}
-
-public extension BrowserCookieClient {
-    func records(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieMockStore) throws -> [BrowserCookieRecord]
-    {
-        try store.records(matching: query)
-    }
-
-    func cookies(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieMockStore) throws -> [HTTPCookie]
-    {
-        let records = try store.records(matching: query)
-        return Self.makeHTTPCookies(records, origin: query.origin)
-    }
-
-    func create(_ record: BrowserCookieRecord, in store: BrowserCookieMockStore) throws {
-        try store.create(record)
-    }
-
-    func update(_ record: BrowserCookieRecord, in store: BrowserCookieMockStore) throws {
-        try store.update(record)
-    }
-
-    func upsert(_ record: BrowserCookieRecord, in store: BrowserCookieMockStore) {
-        store.upsert(record)
-    }
-
-    @discardableResult
-    func delete(_ record: BrowserCookieRecord, in store: BrowserCookieMockStore) -> Bool {
-        store.delete(record)
-    }
-
-    @discardableResult
-    func delete(matching query: BrowserCookieQuery, in store: BrowserCookieMockStore) throws -> Int {
-        try store.delete(matching: query)
-    }
-}

package/Packages/Silo/Sources/Silo/BrowserCookieExport.swift

@@ -1,154 +0,0 @@
-import Foundation
-
-public struct BrowserCookieExportRecord: Codable, Sendable {
-    public let domain: String
-    public let name: String
-    public let path: String
-    public let value: String
-    public let expires: Date?
-    public let createdAt: Date?
-    public let lastAccessedAt: Date?
-    public let isSecure: Bool
-    public let isHTTPOnly: Bool
-    public let isHostOnly: Bool?
-    public let sameSite: BrowserCookieSameSite?
-    public let priority: BrowserCookiePriority?
-    public let partitionKey: String?
-    public let isSameParty: Bool?
-
-    public init(record: BrowserCookieRecord) {
-        self.domain = record.domain
-        self.name = record.name
-        self.path = record.path
-        self.value = record.value
-        self.expires = record.expires
-        self.createdAt = record.createdAt
-        self.lastAccessedAt = record.lastAccessedAt
-        self.isSecure = record.isSecure
-        self.isHTTPOnly = record.isHTTPOnly
-        self.isHostOnly = record.isHostOnly
-        self.sameSite = record.sameSite
-        self.priority = record.priority
-        self.partitionKey = record.partitionKey
-        self.isSameParty = record.isSameParty
-    }
-}
-
-public struct BrowserCookieStoreExport: Codable, Sendable {
-    public let browser: Browser
-    public let profileId: String
-    public let profileName: String
-    public let kind: BrowserCookieStoreKind
-    public let label: String
-    public let records: [BrowserCookieExportRecord]
-
-    public init(store: BrowserCookieStore, records: [BrowserCookieRecord]) {
-        self.browser = store.browser
-        self.profileId = store.profile.id
-        self.profileName = store.profile.name
-        self.kind = store.kind
-        self.label = store.label
-        self.records = records.map(BrowserCookieExportRecord.init(record:))
-    }
-}
-
-public struct BrowserCookieExport: Codable, Sendable {
-    public let schemaVersion: Int
-    public let generatedAt: Date
-    public let stores: [BrowserCookieStoreExport]
-
-    public init(
-        schemaVersion: Int = 1,
-        generatedAt: Date = Date(),
-        stores: [BrowserCookieStoreExport])
-    {
-        self.schemaVersion = schemaVersion
-        self.generatedAt = generatedAt
-        self.stores = stores
-    }
-
-    public func jsonData(
-        prettyPrinted: Bool = true,
-        dateEncodingStrategy: JSONEncoder.DateEncodingStrategy = .iso8601) throws -> Data
-    {
-        let encoder = JSONEncoder()
-        encoder.dateEncodingStrategy = dateEncodingStrategy
-        if prettyPrinted {
-            encoder.outputFormatting = [.prettyPrinted, .sortedKeys]
-        }
-        return try encoder.encode(self)
-    }
-
-    private enum CodingKeys: String, CodingKey {
-        case schemaVersion
-        case generatedAt
-        case stores
-    }
-
-    public init(from decoder: Decoder) throws {
-        let container = try decoder.container(keyedBy: CodingKeys.self)
-        self.schemaVersion = (try? container.decode(Int.self, forKey: .schemaVersion)) ?? 1
-        self.generatedAt = try container.decode(Date.self, forKey: .generatedAt)
-        self.stores = try container.decode([BrowserCookieStoreExport].self, forKey: .stores)
-    }
-
-    public func encode(to encoder: Encoder) throws {
-        var container = encoder.container(keyedBy: CodingKeys.self)
-        try container.encode(schemaVersion, forKey: .schemaVersion)
-        try container.encode(generatedAt, forKey: .generatedAt)
-        try container.encode(stores, forKey: .stores)
-    }
-}
-
-public extension BrowserCookieClient {
-    func export(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieStore) throws -> BrowserCookieExport
-    {
-        let records = try self.records(matching: query, in: store)
-        let exportStore = BrowserCookieStoreExport(store: store, records: records)
-        return BrowserCookieExport(stores: [exportStore])
-    }
-
-    func export(
-        matching query: BrowserCookieQuery,
-        in browser: Browser) throws -> BrowserCookieExport
-    {
-        let sources = try self.records(matching: query, in: browser)
-        let stores = sources.map { BrowserCookieStoreExport(store: $0.store, records: $0.records) }
-        return BrowserCookieExport(stores: stores)
-    }
-
-    func export(
-        matching query: BrowserCookieQuery,
-        in browsers: [Browser]) throws -> BrowserCookieExport
-    {
-        let sources = try self.records(matching: query, in: browsers)
-        let stores = sources.map { BrowserCookieStoreExport(store: $0.store, records: $0.records) }
-        return BrowserCookieExport(stores: stores)
-    }
-
-    func exportJSON(
-        matching query: BrowserCookieQuery,
-        in store: BrowserCookieStore,
-        prettyPrinted: Bool = true) throws -> Data
-    {
-        try self.export(matching: query, in: store).jsonData(prettyPrinted: prettyPrinted)
-    }
-
-    func exportJSON(
-        matching query: BrowserCookieQuery,
-        in browser: Browser,
-        prettyPrinted: Bool = true) throws -> Data
-    {
-        try self.export(matching: query, in: browser).jsonData(prettyPrinted: prettyPrinted)
-    }
-
-    func exportJSON(
-        matching query: BrowserCookieQuery,
-        in browsers: [Browser],
-        prettyPrinted: Bool = true) throws -> Data
-    {
-        try self.export(matching: query, in: browsers).jsonData(prettyPrinted: prettyPrinted)
-    }
-}

package/Packages/Silo/Sources/Silo/BrowserCookieImport.swift

@@ -1,119 +0,0 @@
-import Foundation
-
-public struct BrowserCookieImportOptions: Sendable {
-    /// Default host-only behavior when the JSON payload does not specify it.
-    public var defaultHostOnly: Bool
-
-    public init(defaultHostOnly: Bool = true) {
-        self.defaultHostOnly = defaultHostOnly
-    }
-}
-
-public struct BrowserCookieImport: Sendable {
-    public let schemaVersion: Int
-    public let generatedAt: Date
-    public let stores: [BrowserCookieStoreRecords]
-
-    public init(schemaVersion: Int = 1, generatedAt: Date = Date(), stores: [BrowserCookieStoreRecords]) {
-        self.schemaVersion = schemaVersion
-        self.generatedAt = generatedAt
-        self.stores = stores
-    }
-
-    public var records: [BrowserCookieRecord] {
-        self.stores.flatMap(\.records)
-    }
-
-    public var browsers: [Browser] {
-        var seen: Set<Browser> = []
-        var ordered: [Browser] = []
-        for store in self.stores {
-            if seen.insert(store.store.browser).inserted {
-                ordered.append(store.store.browser)
-            }
-        }
-        return ordered
-    }
-
-    public init(
-        export: BrowserCookieExport,
-        options: BrowserCookieImportOptions = BrowserCookieImportOptions())
-    {
-        self.schemaVersion = export.schemaVersion
-        self.generatedAt = export.generatedAt
-        self.stores = export.stores.map { storeExport in
-            let store = BrowserCookieStore(
-                browser: storeExport.browser,
-                profile: BrowserProfile(id: storeExport.profileId, name: storeExport.profileName),
-                kind: storeExport.kind,
-                label: storeExport.label,
-                databaseURL: nil)
-            let records = storeExport.records.map { exportRecord in
-                Self.makeRecord(from: exportRecord, options: options)
-            }
-            return BrowserCookieStoreRecords(store: store, records: records)
-        }
-    }
-
-    public init(
-        data: Data,
-        dateDecodingStrategy: JSONDecoder.DateDecodingStrategy = .iso8601,
-        options: BrowserCookieImportOptions = BrowserCookieImportOptions()) throws
-    {
-        let decoder = JSONDecoder()
-        decoder.dateDecodingStrategy = dateDecodingStrategy
-        let export = try decoder.decode(BrowserCookieExport.self, from: data)
-        self.init(export: export, options: options)
-    }
-
-    private static func makeRecord(
-        from exportRecord: BrowserCookieExportRecord,
-        options: BrowserCookieImportOptions) -> BrowserCookieRecord
-    {
-        let hostOnlyOverride = hostOnlyOverride(
-            domain: exportRecord.domain,
-            isHostOnly: exportRecord.isHostOnly,
-            defaultHostOnly: options.defaultHostOnly)
-
-        return BrowserCookieRecord(
-            domain: exportRecord.domain,
-            name: exportRecord.name,
-            path: exportRecord.path,
-            value: exportRecord.value,
-            expires: exportRecord.expires,
-            createdAt: exportRecord.createdAt,
-            lastAccessedAt: exportRecord.lastAccessedAt,
-            isSecure: exportRecord.isSecure,
-            isHTTPOnly: exportRecord.isHTTPOnly,
-            isHostOnly: hostOnlyOverride,
-            sameSite: exportRecord.sameSite,
-            priority: exportRecord.priority,
-            partitionKey: exportRecord.partitionKey,
-            isSameParty: exportRecord.isSameParty)
-    }
-
-    private static func hostOnlyOverride(
-        domain: String,
-        isHostOnly: Bool?,
-        defaultHostOnly: Bool) -> Bool?
-    {
-        if let isHostOnly {
-            return isHostOnly
-        }
-        let trimmed = domain.trimmingCharacters(in: .whitespacesAndNewlines)
-        if trimmed.hasPrefix(".") {
-            return nil
-        }
-        return defaultHostOnly
-    }
-}
-
-public extension BrowserCookieClient {
-    func importJSON(
-        _ data: Data,
-        dateDecodingStrategy: JSONDecoder.DateDecodingStrategy = .iso8601,
-        options: BrowserCookieImportOptions = BrowserCookieImportOptions()) throws -> BrowserCookieImport
-    {
-        try BrowserCookieImport(data: data, dateDecodingStrategy: dateDecodingStrategy, options: options)
-    }
-}