apple_kit

Apple-native services for Radroots iOS and macOS apps
git clone https://radroots.dev/git/apple_kit.git
Log | Files | Refs | README

RadrootsInMemorySecureStore.swift (2253B)

      1 import Foundation
      2 import RadrootsKit
      3 
      4 public final class RadrootsInMemorySecureStore: RadrootsSecureStore, @unchecked Sendable {
      5     private struct Entry: Sendable {
      6         let value: Data
      7         let policy: RadrootsSecretAccessPolicy
      8     }
      9 
     10     private let lock = NSLock()
     11     private var entries: [RadrootsSecureStoreKey: Entry]
     12 
     13     public init() {
     14         self.entries = [:]
     15     }
     16 
     17     public func put(
     18         _ value: Data,
     19         for key: RadrootsSecureStoreKey,
     20         policy: RadrootsSecretAccessPolicy
     21     ) throws {
     22         let normalizedKey = try key.normalized()
     23         lock.lock()
     24         defer { lock.unlock() }
     25         entries[normalizedKey] = Entry(value: value, policy: policy)
     26     }
     27 
     28     public func contains(_ key: RadrootsSecureStoreKey) throws -> Bool {
     29         let normalizedKey = try key.normalized()
     30         lock.lock()
     31         defer { lock.unlock() }
     32         return entries[normalizedKey] != nil
     33     }
     34 
     35     public func get(_ key: RadrootsSecureStoreKey) throws -> Data? {
     36         let normalizedKey = try key.normalized()
     37         lock.lock()
     38         defer { lock.unlock() }
     39         return entries[normalizedKey]?.value
     40     }
     41 
     42     public func delete(_ key: RadrootsSecureStoreKey) throws {
     43         let normalizedKey = try key.normalized()
     44         lock.lock()
     45         defer { lock.unlock() }
     46         entries.removeValue(forKey: normalizedKey)
     47     }
     48 
     49     public func deleteNamespace(_ namespace: String) throws {
     50         let normalizedNamespace = try RadrootsSecureStoreKey.normalizedNamespace(namespace)
     51         lock.lock()
     52         defer { lock.unlock() }
     53         entries = entries.filter { key, _ in
     54             key.namespace != normalizedNamespace
     55         }
     56     }
     57 
     58     public func policy(for key: RadrootsSecureStoreKey) throws -> RadrootsSecretAccessPolicy? {
     59         let normalizedKey = try key.normalized()
     60         lock.lock()
     61         defer { lock.unlock() }
     62         return entries[normalizedKey]?.policy
     63     }
     64 
     65     public func keys() -> [RadrootsSecureStoreKey] {
     66         lock.lock()
     67         defer { lock.unlock() }
     68         return entries.keys.sorted {
     69             if $0.namespace == $1.namespace {
     70                 return $0.name < $1.name
     71             }
     72             return $0.namespace < $1.namespace
     73         }
     74     }
     75 }