Refactor C++ loader: extract cache and addon registry, resolve TODOs

packages/host/cpp/AddonRegistry.cpp

@@ -0,0 +1,226 @@
+#include "AddonRegistry.hpp"
+#include <cctype>  // for std::isalnum
+
+#ifndef NODE_API_DEFAULT_MODULE_API_VERSION
+#define NODE_API_DEFAULT_MODULE_API_VERSION 8
+#endif
+
+using namespace facebook;
+
+namespace {
+napi_status napi_emplace_named_property_object(napi_env env,
+                                               napi_value object,
+                                               const char *utf8Name,
+                                               napi_value *outObject) {
+  bool propertyFound = false;
+  napi_status status = napi_has_named_property(env, object, utf8Name, &propertyFound);
+  assert(napi_ok == status);
+
+  assert(nullptr != outObject);
+  if (propertyFound) {
+    status = napi_get_named_property(env, object, utf8Name, outObject);
+  } else {
+    // Need to create it first
+    status = napi_create_object(env, outObject);
+    assert(napi_ok == status);
+
+    status = napi_set_named_property(env, object, utf8Name, *outObject);
+  }
+
+  return status;
+}
+
+bool endsWith(const std::string_view &str, const std::string_view &suffix) {
+#if __cplusplus >= 202002L // __cpp_lib_starts_ends_with
+  return str.ends_with(suffix);
+#else
+  return str.size() >= suffix.size()
+    && std::equal(suffix.rbegin(), suffix.rend(), str.rbegin());
+#endif
+}
+
+std::string_view stripSuffix(const std::string_view &str, const std::string_view &suffix) {
+  if (endsWith(str, suffix)) {
+    return str.substr(0, str.size() - suffix.size());
+  } else {
+    return str;
+  }
+}
+
+void sanitizeLibraryNameInplace(std::string &name) {
+  // Strip the extension (if present)
+  // NOTE: This is needed when working with updated Babel plugin
+  name = stripSuffix(name, ".node");
+
+  for (char &c : name) {
+    if (!std::isalnum(c)) {
+      c = '-';
+    }
+  }
+}
+} // namespace
+
+namespace callstack::nodeapihost {
+
+AddonRegistry::NodeAddon& AddonRegistry::loadAddon(std::string packageName,
+                                                   std::string subpath) {
+  const std::string fqan = packageName + subpath.substr(1);
+  auto [it, inserted] =
+      trackedAddons_.try_emplace(fqan, NodeAddon(packageName, subpath));
+  NodeAddon &addon = it->second;
+
+  sanitizeLibraryNameInplace(packageName);
+  sanitizeLibraryNameInplace(subpath);
+  const std::string libraryName = packageName + subpath;
+
+  if (inserted || !it->second.isLoaded()) {
+#if defined(__APPLE__)
+    const std::string libraryPath = "@rpath/" + libraryName + ".framework/" + libraryName;
+    tryLoadAddonAsDynamicLib(addon, libraryPath);
+#elif defined(__ANDROID__)
+    const std::string libraryPath = "lib" + libraryName + ".so";
+    tryLoadAddonAsDynamicLib(addon, libraryPath);
+#else
+    abort();
+#endif
+  }
+
+  return addon;
+}
+
+bool AddonRegistry::tryLoadAddonAsDynamicLib(NodeAddon &addon, const std::string &path) {
+  {
+    // There can be only a SINGLE pending module (the same limitation
+    // has Node.js since Jan 28, 2014 commit 76b9846, see link below).
+    // We MUST clear it before attempting to load next addon.
+    // https://github.com/nodejs/node/blob/76b98462e589a69d9fd48ccb9fb5f6e96b539715/src/node.cc#L1949)
+    assert(nullptr == pendingRegistration_);
+  }
+
+  // Load addon as dynamic library
+  typename LoaderPolicy::Module library = LoaderPolicy::loadLibrary(path.c_str());
+  if (nullptr != library) {
+    addon.moduleApiVersion_ = NODE_API_DEFAULT_MODULE_API_VERSION;
+    if (nullptr != pendingRegistration_) {
+      // there is a pending addon that used the deprecated `napi_register_module()`
+      addon.initFun_ = pendingRegistration_;
+    } else {
+      // pending addon remains empty, we should look for the symbols...
+      typename LoaderPolicy::Symbol initFn = LoaderPolicy::getSymbol(library, "napi_register_module_v1");
+      if (nullptr != initFn) {
+        addon.initFun_ = (napi_addon_register_func)initFn;
+        // This solves https://github.com/callstackincubator/react-native-node-api-modules/issues/4
+        typename LoaderPolicy::Symbol getVersionFn = LoaderPolicy::getSymbol(library, "node_api_module_get_api_version_v1");
+        if (nullptr != getVersionFn) {
+          addon.moduleApiVersion_ = ((node_api_addon_get_api_version_func)getVersionFn)();
+        }
+      }
+    }
+
+    if (nullptr != addon.initFun_) {
+      addon.moduleHandle_ = (void *)library;
+      addon.loadedFilePath_ = path;
+    }
+  }
+
+  // We MUST clear the `pendingAddon_`, even when the module failed to load!
+  // See: https://github.com/nodejs/node/commit/a60056df3cad2867d337fc1d7adeebe66f89031a
+  pendingRegistration_ = nullptr;
+  return addon.isLoaded();
+}
+
+jsi::Value AddonRegistry::instantiateAddonInRuntime(jsi::Runtime &rt, NodeAddon &addon) {
+  // We should check if the module has already been initialized
+  assert(true == addon.isLoaded());
+  assert(addon.moduleApiVersion_ > 0 && addon.moduleApiVersion_ <= 10);
+
+  napi_status status = napi_ok;
+  napi_env env = reinterpret_cast<napi_env>(rt.createNodeApiEnv(addon.moduleApiVersion_));
+
+  // Create the "exports" object
+  napi_value exports;
+  status = napi_create_object(env, &exports);
+  assert(napi_ok == status);
+
+  // Call the addon init function to populate the "exports" object
+  // Allowing it to replace the value entirely by its return value
+  // TODO: Check the return value (see Node.js specs)
+  exports = addon.initFun_(env, exports);
+
+  // "Compute" the Fully Qualified Addon Path
+  const std::string fqap = addon.packageName_ + addon.subpath_.substr(1);
+
+  {
+    napi_value descriptor;
+    status = createAddonDescriptor(env, exports, &descriptor);
+    assert(napi_ok == status);
+
+    napi_value global;
+    napi_get_global(env, &global);
+    assert(napi_ok == status);
+
+    status = storeAddonByFullPath(env, global, fqap, descriptor);
+    assert(napi_ok == status);
+  }
+
+  return lookupAddonByFullPath(rt, fqap);
+}
+
+bool AddonRegistry::handleOldNapiModuleRegister(napi_addon_register_func addonInitFunc) {
+  assert(nullptr == pendingRegistration_);
+  pendingRegistration_ = addonInitFunc;
+  return true;
+}
+
+napi_status AddonRegistry::createAddonDescriptor(napi_env env, napi_value exports, napi_value *outDescriptor) {
+  // Create the descriptor object
+  assert(nullptr != outDescriptor);
+  napi_status status = napi_create_object(env, outDescriptor);
+
+  // Point the `env` property to the current `napi_env`
+  if (napi_ok == status) {
+    napi_value env_value;
+    status = napi_create_external(env, env, nullptr, nullptr, &env_value);
+    if (napi_ok == status) {
+      status = napi_set_named_property(env, *outDescriptor, "env", env_value);
+    }
+  }
+
+  // Cache the addons exports in descriptor's `exports` property
+  if (napi_ok == status) {
+    status = napi_set_named_property(env, *outDescriptor, "exports", exports);
+  }
+
+  return status;
+}
+
+napi_status AddonRegistry::storeAddonByFullPath(napi_env env, napi_value global, const std::string &fqap, napi_value descriptor) {
+  // Get the internal registry object
+  napi_value registryObject;
+  napi_status status = napi_emplace_named_property_object(env, global, kInternalRegistryKey, &registryObject);
+  assert(napi_ok == status);
+
+  status = napi_set_named_property(env, registryObject, fqap.c_str(), descriptor);
+  return status;
+}
+
+jsi::Value AddonRegistry::lookupAddonByFullPath(jsi::Runtime &rt, const std::string &fqap) {
+  // Get the internal registry object
+  jsi::Object global = rt.global();
+  if (!global.hasProperty(rt, kInternalRegistryKey)) {
+    // Create it first
+    jsi::Object registryObject = jsi::Object(rt);
+    global.setProperty(rt, kInternalRegistryKey, registryObject);
+  }
+  jsi::Value registryValue = global.getProperty(rt, kInternalRegistryKey);
+  jsi::Object registryObject = registryValue.asObject(rt);
+
+  // Lookup by addon path
+  jsi::Value addonValue(nullptr);
+  if (registryObject.hasProperty(rt, fqap.c_str())) {
+    addonValue = registryObject.getProperty(rt, fqap.c_str());
+  }
+  return addonValue;
+}
+
+} // namespace callstack::nodeapihost

packages/host/cpp/AddonRegistry.hpp

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <unordered_map>
+#include <jsi/jsi.h>
+#include <node_api.h>
+#include "AddonLoaders.hpp"
+
+namespace callstack::nodeapihost {
+
+class AddonRegistry {
+public:
+  struct NodeAddon {
+    NodeAddon(std::string packageName, std::string subpath)
+      : packageName_(packageName)
+      , subpath_(subpath)
+    {}
+
+    inline bool isLoaded() const { return nullptr != initFun_; }
+
+    std::string packageName_;
+    std::string subpath_;
+    std::string loadedFilePath_;
+    void *moduleHandle_ = nullptr;
+    napi_addon_register_func initFun_ = nullptr;
+    int32_t moduleApiVersion_;
+  };
+
+  NodeAddon& loadAddon(std::string packageName, std::string subpath);
+  facebook::jsi::Value instantiateAddonInRuntime(facebook::jsi::Runtime &rt, NodeAddon &addon);
+  bool handleOldNapiModuleRegister(napi_addon_register_func addonInitFunc);
+
+  using LoaderPolicy = PosixLoader; // FIXME: HACK: This is temporary workaround
+                                    // for my lazyness (works on iOS and Android)
+private:
+  bool tryLoadAddonAsDynamicLib(NodeAddon &addon, const std::string &path);
+  napi_status createAddonDescriptor(napi_env env, napi_value exports, napi_value *outDescriptor);
+  napi_status storeAddonByFullPath(napi_env env, napi_value global, const std::string &fqap, napi_value descriptor);
+  facebook::jsi::Value lookupAddonByFullPath(facebook::jsi::Runtime &rt, const std::string &fqap);
+
+  static constexpr const char *kInternalRegistryKey = "$NodeApiHost";
+  std::unordered_map<std::string, NodeAddon> trackedAddons_;
+  napi_addon_register_func pendingRegistration_;
+};
+
+} // namespace callstack::nodeapihost