one 2.0.0-beta.130.1 → 2.0.0-beta.131.1

package/ios/Nitro/HybridOneProtectedStore.swift

@@ -0,0 +1,246 @@
+import Foundation
+import LocalAuthentication
+import NitroModules
+import Security
+
+final class HybridOneProtectedStore: HybridOneProtectedStoreSpec {
+  private static let service = "One.ProtectedStore"
+
+  func createItem(key: String, value: String, policy: ProtectedStorePolicy) throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        try Self.validate(key: key, operation: "createItem")
+        let flags: SecAccessControlCreateFlags = policy == .userpresence
+          ? .userPresence : .biometryCurrentSet
+        var accessError: Unmanaged<CFError>?
+        guard let access = SecAccessControlCreateWithFlags(
+          nil, kSecAttrAccessibleWhenUnlockedThisDeviceOnly, flags, &accessError
+        ) else {
+          let detail = accessError?.takeRetainedValue().localizedDescription ?? "access control is unavailable"
+          throw oneNativeError("E_PROTECTED_STORE_AUTH", "ProtectedStore.createItem: \(detail)")
+        }
+        var attributes = Self.query(key: key)
+        attributes[kSecValueData as String] = Data(value.utf8)
+        attributes[kSecAttrAccessControl as String] = access
+        attributes[kSecAttrLabel as String] = policy.stringValue
+        let status = SecItemAdd(attributes as CFDictionary, nil)
+        if status == errSecDuplicateItem {
+          throw oneNativeError("E_PROTECTED_STORE_EXISTS", "ProtectedStore.createItem: key already exists")
+        }
+        guard status == errSecSuccess else {
+          throw Self.failure("createItem", status)
+        }
+        promise.resolve()
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+
+  func getItem(key: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<String?> {
+    let promise = Promise<String?>()
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        try Self.validate(key: key, reason: reason, operation: "getItem")
+        guard try Self.exists(key: key, operation: "getItem") else {
+          promise.resolve(withResult: nil)
+          return
+        }
+        let context = Self.context(reason: reason)
+        Self.verify(context: context, policy: policy, reason: reason, operation: "getItem") {
+          error in
+          if let error { promise.reject(withError: error); return }
+          do {
+            guard let item = try Self.read(key: key, context: context, operation: "getItem") else {
+              promise.resolve(withResult: nil)
+              return
+            }
+            try Self.requirePolicy(item.policy, policy, operation: "getItem")
+            promise.resolve(withResult: item.value)
+          } catch {
+            promise.reject(withError: error)
+          }
+        }
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+
+  func updateItem(key: String, value: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        try Self.validate(key: key, reason: reason, operation: "updateItem")
+        guard try Self.exists(key: key, operation: "updateItem") else {
+          throw oneNativeError("E_PROTECTED_STORE_NOT_FOUND", "ProtectedStore.updateItem: key is missing")
+        }
+        let context = Self.context(reason: reason)
+        Self.verify(context: context, policy: policy, reason: reason, operation: "updateItem") {
+          error in
+          if let error { promise.reject(withError: error); return }
+          do {
+            guard let item = try Self.read(key: key, context: context, operation: "updateItem") else {
+              throw oneNativeError("E_PROTECTED_STORE_NOT_FOUND", "ProtectedStore.updateItem: key is missing")
+            }
+            try Self.requirePolicy(item.policy, policy, operation: "updateItem")
+            var lookup = Self.query(key: key)
+            lookup[kSecUseAuthenticationContext as String] = context
+            let status = SecItemUpdate(
+              lookup as CFDictionary, [kSecValueData as String: Data(value.utf8)] as CFDictionary)
+            if status == errSecItemNotFound {
+              throw oneNativeError("E_PROTECTED_STORE_NOT_FOUND", "ProtectedStore.updateItem: key is missing")
+            }
+            guard status == errSecSuccess else { throw Self.failure("updateItem", status) }
+            promise.resolve()
+          } catch {
+            promise.reject(withError: error)
+          }
+        }
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+
+  func deleteItem(key: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<Void> {
+    let promise = Promise<Void>()
+    DispatchQueue.global(qos: .userInitiated).async {
+      do {
+        try Self.validate(key: key, reason: reason, operation: "deleteItem")
+        guard try Self.exists(key: key, operation: "deleteItem") else {
+          let status = SecItemDelete(Self.query(key: key) as CFDictionary)
+          if status == errSecSuccess || status == errSecItemNotFound { promise.resolve() }
+          else { promise.reject(withError: Self.failure("deleteItem", status)) }
+          return
+        }
+        let context = Self.context(reason: reason)
+        Self.verify(context: context, policy: policy, reason: reason, operation: "deleteItem") {
+          error in
+          if let error { promise.reject(withError: error); return }
+          var lookup = Self.query(key: key)
+          lookup[kSecUseAuthenticationContext as String] = context
+          let status = SecItemDelete(lookup as CFDictionary)
+          if status != errSecSuccess && status != errSecItemNotFound {
+            promise.reject(withError: Self.failure("deleteItem", status))
+          } else { promise.resolve() }
+        }
+      } catch {
+        promise.reject(withError: error)
+      }
+    }
+    return promise
+  }
+
+  private static func query(key: String) -> [String: Any] {
+    [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: service,
+      kSecAttrAccount as String: key,
+    ]
+  }
+
+  private static func context(reason: String) -> LAContext {
+    let context = LAContext()
+    context.localizedReason = reason
+    return context
+  }
+
+  private static func exists(key: String, operation: String) throws -> Bool {
+    let context = LAContext()
+    context.interactionNotAllowed = true
+    var lookup = query(key: key)
+    lookup[kSecReturnAttributes as String] = true
+    lookup[kSecMatchLimit as String] = kSecMatchLimitOne
+    lookup[kSecUseAuthenticationContext as String] = context
+    var item: CFTypeRef?
+    let status = SecItemCopyMatching(lookup as CFDictionary, &item)
+    if status == errSecItemNotFound { return false }
+    if status == errSecSuccess || status == errSecInteractionNotAllowed || status == errSecAuthFailed {
+      return true
+    }
+    throw failure(operation, status)
+  }
+
+  private static func read(
+    key: String, context: LAContext, operation: String
+  ) throws -> (value: String, policy: ProtectedStorePolicy)? {
+    var lookup = query(key: key)
+    lookup[kSecReturnData as String] = true
+    lookup[kSecReturnAttributes as String] = true
+    lookup[kSecMatchLimit as String] = kSecMatchLimitOne
+    lookup[kSecUseAuthenticationContext as String] = context
+    var item: CFTypeRef?
+    let status = SecItemCopyMatching(lookup as CFDictionary, &item)
+    if status == errSecItemNotFound { return nil }
+    guard status == errSecSuccess else { throw failure(operation, status, read: true) }
+    guard let attributes = item as? [String: Any],
+      let data = attributes[kSecValueData as String] as? Data,
+      let value = String(data: data, encoding: .utf8),
+      let label = attributes[kSecAttrLabel as String] as? String,
+      let storedPolicy = ProtectedStorePolicy(fromString: label) else {
+      throw oneNativeError("E_PROTECTED_STORE_GET", "ProtectedStore.\(operation): invalid item")
+    }
+    return (value, storedPolicy)
+  }
+
+  private static func requirePolicy(
+    _ stored: ProtectedStorePolicy, _ requested: ProtectedStorePolicy, operation: String
+  ) throws {
+    guard stored == requested else {
+      throw oneNativeError("E_PROTECTED_STORE_POLICY", "ProtectedStore.\(operation): policy does not match the item")
+    }
+  }
+
+  private static func verify(
+    context: LAContext, policy: ProtectedStorePolicy, reason: String, operation: String,
+    completion: @escaping (Error?) -> Void
+  ) {
+    let laPolicy: LAPolicy = policy == .userpresence
+      ? .deviceOwnerAuthentication : .deviceOwnerAuthenticationWithBiometrics
+    if policy == .biometrycurrentset { context.localizedFallbackTitle = "" }
+    context.evaluatePolicy(laPolicy, localizedReason: reason) { success, error in
+      if success {
+        context.interactionNotAllowed = true
+        completion(nil)
+        return
+      }
+      let code: String
+      switch (error as? LAError)?.code {
+      case .userCancel, .appCancel, .systemCancel, .userFallback:
+        code = "E_PROTECTED_STORE_CANCELLED"
+      default:
+        code = "E_PROTECTED_STORE_AUTH"
+      }
+      completion(oneNativeError(code, "ProtectedStore.\(operation): \(error?.localizedDescription ?? "authentication failed")"))
+    }
+  }
+
+  private static func validate(key: String, reason: String? = nil, operation: String) throws {
+    guard let usage = Bundle.main.object(forInfoDictionaryKey: "NSFaceIDUsageDescription") as? String,
+      !usage.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+      throw oneNativeError(
+        "E_PROTECTED_STORE_MANIFEST", "ProtectedStore.\(operation): set native.app.ios.faceIdUsageDescription")
+    }
+    guard !key.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty else {
+      throw oneNativeError("E_PROTECTED_STORE_INPUT", "ProtectedStore.\(operation): key is required")
+    }
+    if let reason, reason.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+      throw oneNativeError("E_PROTECTED_STORE_INPUT", "ProtectedStore.\(operation): reason is required")
+    }
+  }
+
+  private static func failure(_ operation: String, _ status: OSStatus, read: Bool = false) -> RuntimeError {
+    let code: String
+    switch status {
+    case errSecUserCanceled: code = "E_PROTECTED_STORE_CANCELLED"
+    case errSecAuthFailed, errSecInteractionNotAllowed: code = "E_PROTECTED_STORE_AUTH"
+    default: code = "E_PROTECTED_STORE_\(read || operation == "getItem" ? "GET" : "WRITE")"
+    }
+    return oneNativeError(code, "ProtectedStore.\(operation): keychain status \(status)")
+  }
+}

package/nitrogen/generated/android/One+autolinking.cmake

@@ -56,6 +56,7 @@ target_sources(
   ../nitrogen/generated/shared/c++/HybridOneNetworkSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOneNotificationsSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOnePhotoLibrarySpec.cpp
+  ../nitrogen/generated/shared/c++/HybridOneProtectedStoreSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOneSecureStoreSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOneShareSpec.cpp
   ../nitrogen/generated/shared/c++/HybridOneSpeechSpec.cpp

package/nitrogen/generated/ios/One-Swift-Cxx-Bridge.cpp

@@ -31,6 +31,7 @@
 #include "HybridOneNetworkSpecSwift.hpp"
 #include "HybridOneNotificationsSpecSwift.hpp"
 #include "HybridOnePhotoLibrarySpecSwift.hpp"
+#include "HybridOneProtectedStoreSpecSwift.hpp"
 #include "HybridOneSecureStoreSpecSwift.hpp"
 #include "HybridOneShareSpecSwift.hpp"
 #include "HybridOneSpeechSpecSwift.hpp"
@@ -784,6 +785,22 @@ namespace margelo::nitro::one::bridge::swift {
     };
   }
 
+  // pragma MARK: std::shared_ptr<HybridOneProtectedStoreSpec>
+  std::shared_ptr<HybridOneProtectedStoreSpec> create_std__shared_ptr_HybridOneProtectedStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
+    One::HybridOneProtectedStoreSpec_cxx swiftPart = One::HybridOneProtectedStoreSpec_cxx::fromUnsafe(swiftUnsafePointer);
+    return std::make_shared<margelo::nitro::one::HybridOneProtectedStoreSpecSwift>(swiftPart);
+  }
+  void* NON_NULL get_std__shared_ptr_HybridOneProtectedStoreSpec_(std__shared_ptr_HybridOneProtectedStoreSpec_ cppType) {
+    std::shared_ptr<margelo::nitro::one::HybridOneProtectedStoreSpecSwift> swiftWrapper = std::dynamic_pointer_cast<margelo::nitro::one::HybridOneProtectedStoreSpecSwift>(cppType);
+    #ifdef NITRO_DEBUG
+    if (swiftWrapper == nullptr) [[unlikely]] {
+      throw std::runtime_error("Class \"HybridOneProtectedStoreSpec\" is not implemented in Swift!");
+    }
+    #endif
+    One::HybridOneProtectedStoreSpec_cxx& swiftPart = swiftWrapper->getSwiftPart();
+    return swiftPart.toUnsafe();
+  }
+
   // pragma MARK: std::shared_ptr<HybridOneSecureStoreSpec>
   std::shared_ptr<HybridOneSecureStoreSpec> create_std__shared_ptr_HybridOneSecureStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept {
     One::HybridOneSecureStoreSpec_cxx swiftPart = One::HybridOneSecureStoreSpec_cxx::fromUnsafe(swiftUnsafePointer);

package/nitrogen/generated/ios/One-Swift-Cxx-Bridge.hpp

@@ -130,6 +130,8 @@ namespace margelo::nitro::one { class HybridOneNetworkSpec; }
 namespace margelo::nitro::one { class HybridOneNotificationsSpec; }
 // Forward declaration of `HybridOnePhotoLibrarySpec` to properly resolve imports.
 namespace margelo::nitro::one { class HybridOnePhotoLibrarySpec; }
+// Forward declaration of `HybridOneProtectedStoreSpec` to properly resolve imports.
+namespace margelo::nitro::one { class HybridOneProtectedStoreSpec; }
 // Forward declaration of `HybridOneSecureStoreSpec` to properly resolve imports.
 namespace margelo::nitro::one { class HybridOneSecureStoreSpec; }
 // Forward declaration of `HybridOneShareSpec` to properly resolve imports.
@@ -270,6 +272,8 @@ namespace One { class HybridOneNetworkSpec_cxx; }
 namespace One { class HybridOneNotificationsSpec_cxx; }
 // Forward declaration of `HybridOnePhotoLibrarySpec_cxx` to properly resolve imports.
 namespace One { class HybridOnePhotoLibrarySpec_cxx; }
+// Forward declaration of `HybridOneProtectedStoreSpec_cxx` to properly resolve imports.
+namespace One { class HybridOneProtectedStoreSpec_cxx; }
 // Forward declaration of `HybridOneSecureStoreSpec_cxx` to properly resolve imports.
 namespace One { class HybridOneSecureStoreSpec_cxx; }
 // Forward declaration of `HybridOneShareSpec_cxx` to properly resolve imports.
@@ -340,6 +344,7 @@ namespace One { class HybridOneUpdatesSpec_cxx; }
 #include "HybridOneNetworkSpec.hpp"
 #include "HybridOneNotificationsSpec.hpp"
 #include "HybridOnePhotoLibrarySpec.hpp"
+#include "HybridOneProtectedStoreSpec.hpp"
 #include "HybridOneSecureStoreSpec.hpp"
 #include "HybridOneShareSpec.hpp"
 #include "HybridOneSpeechSpec.hpp"
@@ -3229,17 +3234,17 @@ namespace margelo::nitro::one::bridge::swift {
     return Func_void_std__optional_std__string__Wrapper(std::move(value));
   }
 
-  // pragma MARK: std::shared_ptr<HybridOneSecureStoreSpec>
+  // pragma MARK: std::shared_ptr<HybridOneProtectedStoreSpec>
   /**
-   * Specialized version of `std::shared_ptr<HybridOneSecureStoreSpec>`.
+   * Specialized version of `std::shared_ptr<HybridOneProtectedStoreSpec>`.
    */
-  using std__shared_ptr_HybridOneSecureStoreSpec_ = std::shared_ptr<HybridOneSecureStoreSpec>;
-  std::shared_ptr<HybridOneSecureStoreSpec> create_std__shared_ptr_HybridOneSecureStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
-  void* NON_NULL get_std__shared_ptr_HybridOneSecureStoreSpec_(std__shared_ptr_HybridOneSecureStoreSpec_ cppType);
+  using std__shared_ptr_HybridOneProtectedStoreSpec_ = std::shared_ptr<HybridOneProtectedStoreSpec>;
+  std::shared_ptr<HybridOneProtectedStoreSpec> create_std__shared_ptr_HybridOneProtectedStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridOneProtectedStoreSpec_(std__shared_ptr_HybridOneProtectedStoreSpec_ cppType);
 
-  // pragma MARK: std::weak_ptr<HybridOneSecureStoreSpec>
-  using std__weak_ptr_HybridOneSecureStoreSpec_ = std::weak_ptr<HybridOneSecureStoreSpec>;
-  inline std__weak_ptr_HybridOneSecureStoreSpec_ weakify_std__shared_ptr_HybridOneSecureStoreSpec_(const std::shared_ptr<HybridOneSecureStoreSpec>& strong) noexcept { return strong; }
+  // pragma MARK: std::weak_ptr<HybridOneProtectedStoreSpec>
+  using std__weak_ptr_HybridOneProtectedStoreSpec_ = std::weak_ptr<HybridOneProtectedStoreSpec>;
+  inline std__weak_ptr_HybridOneProtectedStoreSpec_ weakify_std__shared_ptr_HybridOneProtectedStoreSpec_(const std::shared_ptr<HybridOneProtectedStoreSpec>& strong) noexcept { return strong; }
 
   // pragma MARK: Result<std::shared_ptr<Promise<std::optional<std::string>>>>
   using Result_std__shared_ptr_Promise_std__optional_std__string____ = Result<std::shared_ptr<Promise<std::optional<std::string>>>>;
@@ -3250,6 +3255,18 @@ namespace margelo::nitro::one::bridge::swift {
     return Result<std::shared_ptr<Promise<std::optional<std::string>>>>::withError(error);
   }
 
+  // pragma MARK: std::shared_ptr<HybridOneSecureStoreSpec>
+  /**
+   * Specialized version of `std::shared_ptr<HybridOneSecureStoreSpec>`.
+   */
+  using std__shared_ptr_HybridOneSecureStoreSpec_ = std::shared_ptr<HybridOneSecureStoreSpec>;
+  std::shared_ptr<HybridOneSecureStoreSpec> create_std__shared_ptr_HybridOneSecureStoreSpec_(void* NON_NULL swiftUnsafePointer) noexcept;
+  void* NON_NULL get_std__shared_ptr_HybridOneSecureStoreSpec_(std__shared_ptr_HybridOneSecureStoreSpec_ cppType);
+
+  // pragma MARK: std::weak_ptr<HybridOneSecureStoreSpec>
+  using std__weak_ptr_HybridOneSecureStoreSpec_ = std::weak_ptr<HybridOneSecureStoreSpec>;
+  inline std__weak_ptr_HybridOneSecureStoreSpec_ weakify_std__shared_ptr_HybridOneSecureStoreSpec_(const std::shared_ptr<HybridOneSecureStoreSpec>& strong) noexcept { return strong; }
+
   // pragma MARK: Result<std::optional<std::string>>
   using Result_std__optional_std__string__ = Result<std::optional<std::string>>;
   inline Result_std__optional_std__string__ create_Result_std__optional_std__string__(const std::optional<std::string>& value) noexcept {

package/nitrogen/generated/ios/One-Swift-Cxx-Umbrella.hpp

@@ -148,6 +148,8 @@ namespace margelo::nitro::one { class HybridOneNetworkSpec; }
 namespace margelo::nitro::one { class HybridOneNotificationsSpec; }
 // Forward declaration of `HybridOnePhotoLibrarySpec` to properly resolve imports.
 namespace margelo::nitro::one { class HybridOnePhotoLibrarySpec; }
+// Forward declaration of `HybridOneProtectedStoreSpec` to properly resolve imports.
+namespace margelo::nitro::one { class HybridOneProtectedStoreSpec; }
 // Forward declaration of `HybridOneSecureStoreSpec` to properly resolve imports.
 namespace margelo::nitro::one { class HybridOneSecureStoreSpec; }
 // Forward declaration of `HybridOneShareSpec` to properly resolve imports.
@@ -234,6 +236,8 @@ namespace margelo::nitro::one { struct OneUpdatesFetchResult; }
 namespace margelo::nitro::one { enum class OneUpdatesFetchType; }
 // Forward declaration of `PhotoLibraryPermissionStatus` to properly resolve imports.
 namespace margelo::nitro::one { enum class PhotoLibraryPermissionStatus; }
+// Forward declaration of `ProtectedStorePolicy` to properly resolve imports.
+namespace margelo::nitro::one { enum class ProtectedStorePolicy; }
 // Forward declaration of `ReminderInfo` to properly resolve imports.
 namespace margelo::nitro::one { struct ReminderInfo; }
 // Forward declaration of `ReminderInput` to properly resolve imports.
@@ -336,6 +340,7 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "HybridOneNetworkSpec.hpp"
 #include "HybridOneNotificationsSpec.hpp"
 #include "HybridOnePhotoLibrarySpec.hpp"
+#include "HybridOneProtectedStoreSpec.hpp"
 #include "HybridOneSecureStoreSpec.hpp"
 #include "HybridOneShareSpec.hpp"
 #include "HybridOneSpeechSpec.hpp"
@@ -379,6 +384,7 @@ namespace margelo::nitro::one { enum class UserInterfaceSizeClass; }
 #include "OneUpdatesFetchResult.hpp"
 #include "OneUpdatesFetchType.hpp"
 #include "PhotoLibraryPermissionStatus.hpp"
+#include "ProtectedStorePolicy.hpp"
 #include "ReminderInfo.hpp"
 #include "ReminderInput.hpp"
 #include "ResolvedDocumentPickerOptions.hpp"
@@ -461,6 +467,8 @@ namespace One { class HybridOneNetworkSpec_cxx; }
 namespace One { class HybridOneNotificationsSpec_cxx; }
 // Forward declaration of `HybridOnePhotoLibrarySpec_cxx` to properly resolve imports.
 namespace One { class HybridOnePhotoLibrarySpec_cxx; }
+// Forward declaration of `HybridOneProtectedStoreSpec_cxx` to properly resolve imports.
+namespace One { class HybridOneProtectedStoreSpec_cxx; }
 // Forward declaration of `HybridOneSecureStoreSpec_cxx` to properly resolve imports.
 namespace One { class HybridOneSecureStoreSpec_cxx; }
 // Forward declaration of `HybridOneShareSpec_cxx` to properly resolve imports.

package/nitrogen/generated/ios/OneAutolinking.mm

@@ -26,6 +26,7 @@
 #include "HybridOneFetchSpecSwift.hpp"
 #include "HybridOneAppleAuthSpecSwift.hpp"
 #include "HybridOneLocalAuthenticationSpecSwift.hpp"
+#include "HybridOneProtectedStoreSpecSwift.hpp"
 #include "HybridOneLocationSpecSwift.hpp"
 #include "HybridOneFileSystemSpecSwift.hpp"
 #include "HybridOneAudioSpecSwift.hpp"
@@ -159,6 +160,13 @@
       return hybridObject;
     }
   );
+  HybridObjectRegistry::registerHybridObjectConstructor(
+    "OneProtectedStore",
+    []() -> std::shared_ptr<HybridObject> {
+      std::shared_ptr<HybridOneProtectedStoreSpec> hybridObject = One::OneAutolinking::createOneProtectedStore();
+      return hybridObject;
+    }
+  );
   HybridObjectRegistry::registerHybridObjectConstructor(
     "OneLocation",
     []() -> std::shared_ptr<HybridObject> {

package/nitrogen/generated/ios/OneAutolinking.swift

@@ -204,6 +204,18 @@ public final class OneAutolinking {
     return HybridOneLocalAuthentication.self is any RecyclableView.Type
   }
 
+  public static func createOneProtectedStore() -> bridge.std__shared_ptr_HybridOneProtectedStoreSpec_ {
+    let hybridObject = HybridOneProtectedStore()
+    return { () -> bridge.std__shared_ptr_HybridOneProtectedStoreSpec_ in
+      let __cxxWrapped = hybridObject.getCxxWrapper()
+      return __cxxWrapped.getCxxPart()
+    }()
+  }
+
+  public static func isOneProtectedStoreRecyclable() -> Bool {
+    return HybridOneProtectedStore.self is any RecyclableView.Type
+  }
+
   public static func createOneLocation() -> bridge.std__shared_ptr_HybridOneLocationSpec_ {
     let hybridObject = HybridOneLocation()
     return { () -> bridge.std__shared_ptr_HybridOneLocationSpec_ in

package/nitrogen/generated/ios/c++/HybridOneProtectedStoreSpecSwift.cpp

@@ -0,0 +1,11 @@
+///
+/// HybridOneProtectedStoreSpecSwift.cpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#include "HybridOneProtectedStoreSpecSwift.hpp"
+
+namespace margelo::nitro::one {
+} // namespace margelo::nitro::one

package/nitrogen/generated/ios/c++/HybridOneProtectedStoreSpecSwift.hpp

@@ -0,0 +1,110 @@
+///
+/// HybridOneProtectedStoreSpecSwift.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include "HybridOneProtectedStoreSpec.hpp"
+
+// Forward declaration of `HybridOneProtectedStoreSpec_cxx` to properly resolve imports.
+namespace One { class HybridOneProtectedStoreSpec_cxx; }
+
+// Forward declaration of `ProtectedStorePolicy` to properly resolve imports.
+namespace margelo::nitro::one { enum class ProtectedStorePolicy; }
+
+#include <NitroModules/Promise.hpp>
+#include <string>
+#include "ProtectedStorePolicy.hpp"
+#include <optional>
+
+#include "One-Swift-Cxx-Umbrella.hpp"
+
+namespace margelo::nitro::one {
+
+  /**
+   * The C++ part of HybridOneProtectedStoreSpec_cxx.swift.
+   *
+   * HybridOneProtectedStoreSpecSwift (C++) accesses HybridOneProtectedStoreSpec_cxx (Swift), and might
+   * contain some additional bridging code for C++ <> Swift interop.
+   *
+   * Since this obviously introduces an overhead, I hope at some point in
+   * the future, HybridOneProtectedStoreSpec_cxx can directly inherit from the C++ class HybridOneProtectedStoreSpec
+   * to simplify the whole structure and memory management.
+   */
+  class HybridOneProtectedStoreSpecSwift: public virtual HybridOneProtectedStoreSpec {
+  public:
+    // Constructor from a Swift instance
+    explicit HybridOneProtectedStoreSpecSwift(const One::HybridOneProtectedStoreSpec_cxx& swiftPart):
+      HybridObject(HybridOneProtectedStoreSpec::TAG),
+      _swiftPart(swiftPart) { }
+
+  public:
+    // Get the Swift part
+    inline One::HybridOneProtectedStoreSpec_cxx& getSwiftPart() noexcept {
+      return _swiftPart;
+    }
+
+  public:
+    inline size_t getExternalMemorySize() noexcept override {
+      return _swiftPart.getMemorySize();
+    }
+    bool equals(const std::shared_ptr<HybridObject>& other) override {
+      if (auto otherCast = std::dynamic_pointer_cast<HybridOneProtectedStoreSpecSwift>(other)) {
+        return _swiftPart.equals(otherCast->_swiftPart);
+      }
+      return false;
+    }
+    void dispose() noexcept override {
+      _swiftPart.dispose();
+    }
+    std::string toString() override {
+      return _swiftPart.toString();
+    }
+
+  public:
+    // Properties
+
+
+  public:
+    // Methods
+    inline std::shared_ptr<Promise<void>> createItem(const std::string& key, const std::string& value, ProtectedStorePolicy policy) override {
+      auto __result = _swiftPart.createItem(key, value, static_cast<int>(policy));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<std::optional<std::string>>> getItem(const std::string& key, const std::string& reason, ProtectedStorePolicy policy) override {
+      auto __result = _swiftPart.getItem(key, reason, static_cast<int>(policy));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> updateItem(const std::string& key, const std::string& value, const std::string& reason, ProtectedStorePolicy policy) override {
+      auto __result = _swiftPart.updateItem(key, value, reason, static_cast<int>(policy));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> deleteItem(const std::string& key, const std::string& reason, ProtectedStorePolicy policy) override {
+      auto __result = _swiftPart.deleteItem(key, reason, static_cast<int>(policy));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+
+  private:
+    One::HybridOneProtectedStoreSpec_cxx _swiftPart;
+  };
+
+} // namespace margelo::nitro::one

package/nitrogen/generated/ios/swift/HybridOneProtectedStoreSpec.swift

@@ -0,0 +1,58 @@
+///
+/// HybridOneProtectedStoreSpec.swift
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+import NitroModules
+
+/// See ``HybridOneProtectedStoreSpec``
+public protocol HybridOneProtectedStoreSpec_protocol: HybridObject {
+  // Properties
+
+
+  // Methods
+  func createItem(key: String, value: String, policy: ProtectedStorePolicy) throws -> Promise<Void>
+  func getItem(key: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<String?>
+  func updateItem(key: String, value: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<Void>
+  func deleteItem(key: String, reason: String, policy: ProtectedStorePolicy) throws -> Promise<Void>
+}
+
+public extension HybridOneProtectedStoreSpec_protocol {
+  /// Default implementation of ``HybridObject.toString``
+  func toString() -> String {
+    return "[HybridObject OneProtectedStore]"
+  }
+}
+
+/// See ``HybridOneProtectedStoreSpec``
+open class HybridOneProtectedStoreSpec_base {
+  private weak var cxxWrapper: HybridOneProtectedStoreSpec_cxx? = nil
+  public init() { }
+  public func getCxxWrapper() -> HybridOneProtectedStoreSpec_cxx {
+  #if DEBUG
+    guard self is any HybridOneProtectedStoreSpec else {
+      fatalError("`self` is not a `HybridOneProtectedStoreSpec`! Did you accidentally inherit from `HybridOneProtectedStoreSpec_base` instead of `HybridOneProtectedStoreSpec`?")
+    }
+  #endif
+    if let cxxWrapper = self.cxxWrapper {
+      return cxxWrapper
+    } else {
+      let cxxWrapper = HybridOneProtectedStoreSpec_cxx(self as! any HybridOneProtectedStoreSpec)
+      self.cxxWrapper = cxxWrapper
+      return cxxWrapper
+    }
+  }
+}
+
+/**
+ * A Swift base-protocol representing the OneProtectedStore HybridObject.
+ * Implement this protocol to create Swift-based instances of OneProtectedStore.
+ * ```swift
+ * class HybridOneProtectedStore : HybridOneProtectedStoreSpec {
+ *   // ...
+ * }
+ * ```
+ */
+public typealias HybridOneProtectedStoreSpec = HybridOneProtectedStoreSpec_protocol & HybridOneProtectedStoreSpec_base