expo-modules-core 1.2.6 → 1.3.0

package/ios/Swift/Functions/ConcurrentFunctionDefinition.swift

@@ -28,15 +28,22 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
 
   var takesOwner: Bool = false
 
-  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> Void) {
-    let arguments: [Any]
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> Void) {
+    var arguments: [Any]
 
     do {
+      try validateArgumentsNumber(function: self, received: args.count)
+
       arguments = concat(
-        arguments: try cast(arguments: args, forFunction: self),
+        arguments: args,
         withOwner: owner,
-        forFunction: self
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
       )
+
+      // All `JavaScriptValue` args must be preliminarly converted on the JS thread, before we jump to the function's queue.
+      arguments = try cast(jsValues: args, forFunction: self, appContext: appContext)
     } catch let error as Exception {
       callback(.failure(error))
       return
@@ -50,9 +57,12 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
       let result: Result<Any, Exception>
 
       do {
+        // Convert arguments to the types desired by the function.
+        let finalArguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
         // TODO: Right now we force cast the tuple in all types of functions, but we should throw another exception here.
         // swiftlint:disable force_cast
-        let argumentsTuple = try Conversions.toTuple(arguments) as! Args
+        let argumentsTuple = try Conversions.toTuple(finalArguments) as! Args
         let returnValue = try await body(argumentsTuple)
 
         result = .success(returnValue)
@@ -68,18 +78,24 @@ public final class ConcurrentFunctionDefinition<Args, FirstArgType, ReturnType>:
 
   // MARK: - JavaScriptObjectBuilder
 
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createAsyncFunction(name, argsCount: argumentsCount) { [weak self, name] this, args, resolve, reject in
-      guard let self = self else {
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createAsyncFunction(name, argsCount: argumentsCount) {
+      [weak appContext, weak self, name] this, args, resolve, reject in
+
+      guard let appContext else {
+        let exception = Exceptions.AppContextLost()
+        return reject(exception.code, exception.description, nil)
+      }
+      guard let self else {
         let exception = NativeFunctionUnavailableException(name)
         return reject(exception.code, exception.description, nil)
       }
-      self.call(by: this, withArguments: args) { result in
+      self.call(by: this, withArguments: args, appContext: appContext) { result in
         switch result {
-        case .failure(let error):
-          reject(error.code, error.description, nil)
-        case .success(let value):
-          resolve(value)
+          case .failure(let error):
+            reject(error.code, error.description, nil)
+          case .success(let value):
+            resolve(value)
         }
       }
     }

package/ios/Swift/Functions/SyncFunctionComponent.swift

@@ -10,9 +10,10 @@ internal protocol AnySyncFunctionComponent: AnyFunction {
      - owner: An object that calls this function. If the `takesOwner` property is true
        and type of the first argument matches the owner type, it's being passed as the argument.
      - args: An array of arguments to pass to the function. The arguments must be of the same type as in the underlying closure.
+     - appContext: An app context where the function is executed.
    - Returns: A value returned by the called function when succeeded or an error when it failed.
    */
-  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any
 }
 
 /**
@@ -49,9 +50,9 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   var takesOwner: Bool = false
 
-  func call(by owner: AnyObject?, withArguments args: [Any], callback: @escaping (FunctionCallResult) -> ()) {
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext, callback: @escaping (FunctionCallResult) -> ()) {
     do {
-      let result = try call(by: owner, withArguments: args)
+      let result = try call(by: owner, withArguments: args, appContext: appContext)
       callback(.success(Conversions.convertFunctionResult(result)))
     } catch let error as Exception {
       callback(.failure(error))
@@ -62,16 +63,26 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   // MARK: - AnySyncFunctionComponent
 
-  func call(by owner: AnyObject?, withArguments args: [Any]) throws -> Any {
+  func call(by owner: AnyObject?, withArguments args: [Any], appContext: AppContext) throws -> Any {
     do {
-      let arguments = concat(
-        arguments: try cast(arguments: args, forFunction: self),
+      try validateArgumentsNumber(function: self, received: args.count)
+
+      var arguments = concat(
+        arguments: args,
         withOwner: owner,
-        forFunction: self
+        withPromise: nil,
+        forFunction: self,
+        appContext: appContext
       )
+
+      // Convert JS values to non-JS native types.
+      arguments = try cast(jsValues: arguments, forFunction: self, appContext: appContext)
+
+      // Convert arguments to the types desired by the function.
+      arguments = try cast(arguments: arguments, forFunction: self, appContext: appContext)
+
       let argumentsTuple = try Conversions.toTuple(arguments) as! Args
-      let result = try body(argumentsTuple)
-      return Conversions.convertFunctionResult(result)
+      return try body(argumentsTuple)
     } catch let error as Exception {
       throw FunctionCallException(name).causedBy(error)
     } catch {
@@ -81,17 +92,17 @@ public final class SyncFunctionComponent<Args, FirstArgType, ReturnType>: AnySyn
 
   // MARK: - JavaScriptObjectBuilder
 
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
+  func build(appContext: AppContext) throws -> JavaScriptObject {
     // We intentionally capture a strong reference to `self`, otherwise the "detached" objects would
     // immediately lose the reference to the definition and thus the underlying native function.
     // It may potentially cause memory leaks, but at the time of writing this comment,
     // the native definition instance deallocates correctly when the JS VM triggers the garbage collector.
-    return runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak runtime, self] this, args in
-      guard let runtime = runtime else {
-        throw Exceptions.RuntimeLost()
+    return try appContext.runtime.createSyncFunction(name, argsCount: argumentsCount) { [weak appContext, self] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
       }
-      let result = try self.call(by: this, withArguments: args)
-      return Conversions.convertFunctionResult(result, runtime: runtime)
+      let result = try self.call(by: this, withArguments: args, appContext: appContext)
+      return Conversions.convertFunctionResult(result, appContext: appContext, dynamicType: ~ReturnType.self)
     }
   }
 }

package/ios/Swift/JavaScriptFunction.swift

@@ -0,0 +1,68 @@
+// Copyright 2023-present 650 Industries. All rights reserved.
+
+/**
+ Represents a JavaScript function that can be called by the native code and that must return the given generic `ReturnType`.
+ */
+public final class JavaScriptFunction<ReturnType>: AnyArgument, AnyJavaScriptValue {
+  /**
+   Raw representation of the JavaScript function that doesn't impose any restrictions on the returned type.
+   */
+  private let rawFunction: RawJavaScriptFunction
+
+  /**
+   Weak reference to the app context that is necessary to convert some arguments associated with the context (e.g. shared objects).
+   */
+  private weak var appContext: AppContext?
+
+  init(rawFunction: RawJavaScriptFunction, appContext: AppContext) {
+    self.rawFunction = rawFunction
+    self.appContext = appContext
+  }
+
+  // MARK: - Calling
+
+  /**
+   Calls the function with the given `this` object and arguments.
+   */
+  public func call(_ arguments: Any..., usingThis this: JavaScriptObject? = nil) throws -> ReturnType {
+    return try call(withArguments: arguments, asConstructor: false, usingThis: this)
+  }
+
+  /**
+   Calls the function as a constructor with the given arguments. It's like calling a function with the `new` keyword.
+   */
+  public func callAsConstructor(_ arguments: Any...) throws -> ReturnType {
+    return try call(withArguments: arguments, asConstructor: true, usingThis: nil)
+  }
+
+  /**
+   Universal function that calls the function with given arguments, this object and whether to call it as a constructor.
+   */
+  private func call(withArguments arguments: [Any] = [], asConstructor: Bool = false, usingThis this: JavaScriptObject? = nil) throws -> ReturnType {
+    guard let appContext else {
+      throw AppContextLostException()
+    }
+    let value = rawFunction.call(withArguments: arguments, thisObject: this, asConstructor: false)
+    let dynamicType = ~ReturnType.self
+
+    guard let result = try dynamicType.cast(jsValue: value, appContext: appContext) as? ReturnType else {
+      throw UnexpectedReturnType(dynamicType.description)
+    }
+    return result
+  }
+
+  // MARK: - AnyJavaScriptValue
+
+  internal static func convert(from value: JavaScriptValue, appContext: AppContext) throws -> Self {
+    guard value.kind == .function else {
+      throw Conversions.ConvertingException<JavaScriptFunction<ReturnType>>(value)
+    }
+    return Self(rawFunction: value.getFunction(), appContext: appContext)
+  }
+}
+
+private final class UnexpectedReturnType: GenericException<String> {
+  override var reason: String {
+    return "The function returned a value that cannot be converted to \(param)"
+  }
+}

package/ios/Swift/JavaScriptUtils.swift

@@ -10,12 +10,12 @@
  - Returns: A new value converted according to the dynamic type.
  - Throws: Rethrows various exceptions that could be thrown by the dynamic types.
  */
-internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
+internal func cast(_ value: Any, toType type: AnyDynamicType, appContext: AppContext) throws -> Any {
   // TODO: Accept JavaScriptValue and JavaScriptObject as argument types.
   if !(type is DynamicTypedArrayType), let value = value as? JavaScriptValue {
-    return try type.cast(value.getRaw())
+    return try type.cast(value.getRaw(), appContext: appContext)
   }
-  return try type.cast(value)
+  return try type.cast(value, appContext: appContext)
 }
 
 /**
@@ -23,46 +23,85 @@ internal func cast(_ value: Any, toType type: AnyDynamicType) throws -> Any {
  - Parameters:
    - arguments: An array of arguments to be cast.
    - function: A function for which to cast the arguments.
+   - appContext: A context of the app.
  - Returns: An array of arguments after casting. Its size is the same as the input arrays.
  - Throws: `InvalidArgsNumberException` when the number of arguments is not equal to the actual number
  of function's arguments (without an owner and promise). Rethrows exceptions thrown by `cast(_:toType:)`.
  */
-internal func cast(arguments: [Any], forFunction function: AnyFunction) throws -> [Any] {
-  let requiredArgumentsCount = function.requiredArgumentsCount
-  let argumentTypeOffset = function.takesOwner ? 1 : 0
-
-  if arguments.count < requiredArgumentsCount || arguments.count > function.argumentsCount {
-    throw InvalidArgsNumberException((
-      received: arguments.count,
-      expected: function.argumentsCount,
-      required: requiredArgumentsCount
-    ))
-  }
+internal func cast(arguments: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
   return try arguments.enumerated().map { index, argument in
-    let argumentType = function.dynamicArgumentTypes[index + argumentTypeOffset]
+    let argumentType = function.dynamicArgumentTypes[index]
 
     do {
-      return try cast(argument, toType: argumentType)
+      return try cast(argument, toType: argumentType, appContext: appContext)
     } catch {
       throw ArgumentCastException((index: index, type: argumentType)).causedBy(error)
     }
   }
 }
 
+/**
+ Casts an array of JavaScript values to non-JavaScript types.
+ */
+internal func cast(jsValues: [Any], forFunction function: AnyFunction, appContext: AppContext) throws -> [Any] {
+  // TODO: Replace `[Any]` with `[JavaScriptValue]` once we make sure only JS values are passed here
+  return try jsValues.enumerated().map { index, jsValue in
+    let type = function.dynamicArgumentTypes[index]
+
+    do {
+      // Temporarily some values might already be cast to primitive types, so make sure we cast only `JavaScriptValue` and leave the others as they are.
+      if let jsValue = jsValue as? JavaScriptValue {
+        return try type.cast(jsValue: jsValue, appContext: appContext)
+      } else {
+        return jsValue
+      }
+    } catch {
+      throw ArgumentCastException((index: index, type: type)).causedBy(error)
+    }
+  }
+}
+
+/**
+ Validates whether the number of received arguments is enough to call the given function.
+ Throws `InvalidArgsNumberException` otherwise.
+ */
+internal func validateArgumentsNumber(function: AnyFunction, received: Int) throws {
+  let argumentsCount = function.argumentsCount
+  let requiredArgumentsCount = function.requiredArgumentsCount
+
+  if received < requiredArgumentsCount || received > argumentsCount {
+    throw InvalidArgsNumberException((
+      received: received,
+      expected: argumentsCount,
+      required: requiredArgumentsCount
+    ))
+  }
+}
+
 /**
  Ensures the provided array of arguments matches the number of arguments expected by the function.
  - If the function takes the owner, it's added to the beginning.
  - If the array is still too small, missing arguments are very likely to be optional so it puts `nil` in their place.
  */
-internal func concat(arguments: [Any], withOwner owner: AnyObject?, forFunction function: AnyFunction) -> [Any] {
+internal func concat(
+  arguments: [Any],
+  withOwner owner: AnyObject?,
+  withPromise promise: Promise?,
+  forFunction function: AnyFunction,
+  appContext: AppContext
+) -> [Any] {
   var result = arguments
 
-  if function.takesOwner, let owner = try? function.dynamicArgumentTypes.first?.cast(owner) {
+  if function.takesOwner {
     result = [owner] + arguments
   }
   if arguments.count < function.argumentsCount {
     result += Array(repeating: Any?.none as Any, count: function.argumentsCount - arguments.count)
   }
+  // Add promise to the array of arguments if necessary.
+  if let promise {
+    result += [promise]
+  }
   return result
 }
 

package/ios/Swift/ModuleHolder.swift

@@ -62,24 +62,28 @@ public final class ModuleHolder {
   // MARK: Calling functions
 
   func call(function functionName: String, args: [Any], _ callback: @escaping (FunctionCallResult) -> () = { _ in }) {
+    guard let appContext else {
+      callback(.failure(Exceptions.AppContextLost()))
+      return
+    }
     guard let function = definition.functions[functionName] else {
       callback(.failure(FunctionNotFoundException((functionName: functionName, moduleName: self.name))))
       return
     }
-    function.call(by: self, withArguments: args, callback: callback)
+    function.call(by: self, withArguments: args, appContext: appContext, callback: callback)
   }
 
   @discardableResult
   func callSync(function functionName: String, args: [Any]) -> Any? {
-    guard let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
+    guard let appContext, let function = definition.functions[functionName] as? AnySyncFunctionComponent else {
       return nil
     }
     do {
-      let arguments = try cast(arguments: args, forFunction: function)
-      let result = try function.call(by: self, withArguments: arguments)
+      let arguments = try cast(arguments: args, forFunction: function, appContext: appContext)
+      let result = try function.call(by: self, withArguments: arguments, appContext: appContext)
 
       if let result = result as? SharedObject {
-        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: appContext!.runtime!, nativeObject: result)
+        let jsObject = SharedObjectRegistry.ensureSharedJavaScriptObject(runtime: try appContext.runtime, nativeObject: result)
         return jsObject
       }
       return result
@@ -98,11 +102,16 @@ public final class ModuleHolder {
    */
   private func createJavaScriptModuleObject() -> JavaScriptObject? {
     // It might be impossible to create any object at the moment (e.g. remote debugging, app context destroyed)
-    guard let runtime = appContext?.runtime else {
+    guard let appContext else {
+      return nil
+    }
+    do {
+      log.info("Creating JS object for module '\(name)'")
+      return try definition.build(appContext: appContext)
+    } catch {
+      log.error("Building the module object failed: \(error)")
       return nil
     }
-    log.info("Creating JS object for module '\(name)'")
-    return definition.build(inRuntime: runtime)
   }
 
   // MARK: Listening to native events
@@ -131,10 +140,13 @@ public final class ModuleHolder {
    Modifies module's listeners count and calls `onStartObserving` or `onStopObserving` accordingly.
    */
   func modifyListenersCount(_ count: Int) {
+    guard let appContext else {
+      return
+    }
     if count > 0 && listenersCount == 0 {
-      definition.functions["startObserving"]?.call(withArguments: [])
+      definition.functions["startObserving"]?.call(withArguments: [], appContext: appContext)
     } else if count < 0 && listenersCount + count <= 0 {
-      definition.functions["stopObserving"]?.call(withArguments: [])
+      definition.functions["stopObserving"]?.call(withArguments: [], appContext: appContext)
     }
     listenersCount = max(0, listenersCount + count)
   }

package/ios/Swift/Modules/ModuleDefinition.swift

@@ -65,8 +65,14 @@ public final class ModuleDefinition: ObjectDefinition {
     return self
   }
 
-  public override func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = super.build(inRuntime: runtime)
+  public override func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try super.build(appContext: appContext)
+
+    if let viewManager {
+      let reactComponentPrototype = try appContext.runtime.createObject()
+      try viewManager.decorateWithFunctions(object: reactComponentPrototype, appContext: appContext)
+      object.setProperty("ViewPrototype", value: reactComponentPrototype)
+    }
 
     // Give the module object a name. It's used for compatibility reasons, see `EventEmitter.ts`.
     object.defineProperty("__expo_module_name__", value: name, options: [])

package/ios/Swift/Objects/JavaScriptObjectBuilder.swift

@@ -7,7 +7,7 @@ internal protocol JavaScriptObjectDecorator {
   /**
    Decorates an existing `JavaScriptObject`.
    */
-  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime)
+  func decorate(object: JavaScriptObject, appContext: AppContext) throws
 }
 
 /**
@@ -15,23 +15,23 @@ internal protocol JavaScriptObjectDecorator {
  */
 internal protocol JavaScriptObjectBuilder: JavaScriptObjectDecorator {
   /**
-   Creates a decorated `JavaScriptObject` in the given runtime.
+   Creates a decorated `JavaScriptObject` in the given app context.
    */
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+  func build(appContext: AppContext) throws -> JavaScriptObject
 }
 
 /**
  Provides the default behavior of `JavaScriptObjectBuilder`.
- The `build(inRuntime:)` creates a plain object and uses `decorate(object:)` for decoration.
+ The `build(appContext:)` creates a plain object and uses `decorate(object:appContext:)` for decoration.
  */
 extension JavaScriptObjectBuilder {
-  func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = runtime.createObject()
-    decorate(object: object, inRuntime: runtime)
+  func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try appContext.runtime.createObject()
+    try decorate(object: object, appContext: appContext)
     return object
   }
 
-  func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
+  func decorate(object: JavaScriptObject, appContext: AppContext) throws {
     // no-op by default
   }
 }

package/ios/Swift/Objects/ObjectDefinition.swift

@@ -61,43 +61,45 @@ public class ObjectDefinition: AnyDefinition, JavaScriptObjectBuilder {
 
   // MARK: - JavaScriptObjectBuilder
 
-  public func build(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let object = runtime.createObject()
-    decorate(object: object, inRuntime: runtime)
+  public func build(appContext: AppContext) throws -> JavaScriptObject {
+    let object = try appContext.runtime.createObject()
+    try decorate(object: object, appContext: appContext)
     return object
   }
 
-  public func decorate(object: JavaScriptObject, inRuntime runtime: JavaScriptRuntime) {
-    decorateWithConstants(runtime: runtime, object: object)
-    decorateWithFunctions(runtime: runtime, object: object)
-    decorateWithProperties(runtime: runtime, object: object)
-    decorateWithClasses(runtime: runtime, object: object)
+  public func decorate(object: JavaScriptObject, appContext: AppContext) throws {
+    let runtime = try appContext.runtime
+
+    decorateWithConstants(object: object)
+    try decorateWithFunctions(object: object, appContext: appContext)
+    try decorateWithProperties(object: object, appContext: appContext)
+    try decorateWithClasses(object: object, appContext: appContext)
   }
 
   // MARK: - Internals
 
-  internal func decorateWithConstants(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithConstants(object: JavaScriptObject) {
     for (key, value) in getConstants() {
       object.setProperty(key, value: value)
     }
   }
 
-  internal func decorateWithFunctions(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithFunctions(object: JavaScriptObject, appContext: AppContext) throws {
     for fn in functions.values {
-      object.setProperty(fn.name, value: fn.build(inRuntime: runtime))
+      object.setProperty(fn.name, value: try fn.build(appContext: appContext))
     }
   }
 
-  internal func decorateWithProperties(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithProperties(object: JavaScriptObject, appContext: AppContext) throws {
     for property in properties.values {
-      let descriptor = property.buildDescriptor(inRuntime: runtime)
+      let descriptor = try property.buildDescriptor(appContext: appContext)
       object.defineProperty(property.name, descriptor: descriptor)
     }
   }
 
-  internal func decorateWithClasses(runtime: JavaScriptRuntime, object: JavaScriptObject) {
+  internal func decorateWithClasses(object: JavaScriptObject, appContext: AppContext) throws {
     for klass in classes.values {
-      object.setProperty(klass.name, value: klass.build(inRuntime: runtime))
+      object.setProperty(klass.name, value: try klass.build(appContext: appContext))
     }
   }
 }

package/ios/Swift/Objects/PropertyComponent.swift

@@ -9,7 +9,7 @@ protocol AnyPropertyComponent {
   /**
    Creates the JavaScript object representing the property descriptor.
    */
-  func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject
+  func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject
 }
 
 public final class PropertyComponent<OwnerType>: AnyDefinition, AnyPropertyComponent {
@@ -119,60 +119,66 @@ public final class PropertyComponent<OwnerType>: AnyDefinition, AnyPropertyCompo
 
   // MARK: - Internals
 
-  internal func getValue<ValueType>(owner: OwnerType? = nil) throws -> ValueType? {
+  internal func getValue<ValueType>(owner: OwnerType? = nil, appContext: AppContext) throws -> ValueType? {
     let owner = owner as? AnyObject
-    let value = try getter?.call(by: owner, withArguments: [])
+    let value = try getter?.call(by: owner, withArguments: [], appContext: appContext)
     return value as? ValueType
   }
 
-  internal func setValue(_ value: Any, owner: OwnerType? = nil) {
+  internal func setValue(_ value: Any, owner: OwnerType? = nil, appContext: AppContext) {
     let owner = owner as? AnyObject
-    _ = try? setter?.call(by: owner, withArguments: [value])
+    _ = try? setter?.call(by: owner, withArguments: [value], appContext: appContext)
   }
 
   /**
    Creates the JavaScript function that will be used as a getter of the property.
    */
-  internal func buildGetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 0) { [weak self, name] this, args in
-      guard let self = self else {
+  internal func buildGetter(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createSyncFunction(name, argsCount: 0) { [weak appContext, weak self, name] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
+      }
+      guard let self else {
         throw NativePropertyUnavailableException(name)
       }
       guard let getter = self.getter else {
         return
       }
-      return try getter.call(by: this, withArguments: args)
+      return try getter.call(by: this, withArguments: args, appContext: appContext)
     }
   }
 
   /**
    Creates the JavaScript function that will be used as a setter of the property.
    */
-  internal func buildSetter(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    return runtime.createSyncFunction(name, argsCount: 1) { [weak self, name] this, args in
-      guard let self = self else {
+  internal func buildSetter(appContext: AppContext) throws -> JavaScriptObject {
+    return try appContext.runtime.createSyncFunction(name, argsCount: 1) { [weak appContext, weak self, name] this, args in
+      guard let appContext else {
+        throw Exceptions.AppContextLost()
+      }
+      guard let self else {
         throw NativePropertyUnavailableException(name)
       }
       guard let setter = self.setter else {
         return
       }
-      return try setter.call(by: this, withArguments: args)
+      return try setter.call(by: this, withArguments: args, appContext: appContext)
     }
   }
 
   /**
    Creates the JavaScript object representing the property descriptor.
    */
-  internal func buildDescriptor(inRuntime runtime: JavaScriptRuntime) -> JavaScriptObject {
-    let descriptor = runtime.createObject()
+  internal func buildDescriptor(appContext: AppContext) throws -> JavaScriptObject {
+    let descriptor = try appContext.runtime.createObject()
 
     descriptor.setProperty("enumerable", value: true)
 
     if getter != nil {
-      descriptor.setProperty("get", value: buildGetter(inRuntime: runtime))
+      descriptor.setProperty("get", value: try buildGetter(appContext: appContext))
     }
     if setter != nil {
-      descriptor.setProperty("set", value: buildSetter(inRuntime: runtime))
+      descriptor.setProperty("set", value: try buildSetter(appContext: appContext))
     }
     return descriptor
   }

package/ios/Swift/Records/AnyField.swift

@@ -19,5 +19,5 @@ internal protocol AnyFieldInternal: AnyField {
    */
   var isRequired: Bool { get }
 
-  func set(_ newValue: Any?) throws
+  func set(_ newValue: Any?, appContext: AppContext) throws
 }

package/ios/Swift/Records/Field.swift

@@ -74,12 +74,12 @@ public final class Field<Type>: AnyFieldInternal {
   /**
    Sets the wrapped value with a value of `Any` type.
    */
-  internal func set(_ newValue: Any?) throws {
+  internal func set(_ newValue: Any?, appContext: AppContext) throws {
     if newValue == nil && (!isOptional || isRequired) {
       throw FieldRequiredException(key!)
     }
     do {
-      if let value = try fieldType.cast(newValue) as? Type {
+      if let value = try fieldType.cast(newValue, appContext: appContext) as? Type {
         wrappedValue = value
       }
     } catch {