feat: draft first implementation of AddonRegistry

This change implements the AddonRegistry by recycling as much code from CxxNodeApiHostModule as possible. It solves #4 and partially #30

Author: Mariusz Pasinski

packages/react-native-node-api-modules/cpp/AddonRegistry.cpp

@@ -0,0 +1,189 @@
+#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;
+}
+
+void sanitizeLibraryNameInplace(std::string &name) {
+#if USING_PATCHED_BABEL_PLUGIN
+  // Strip the extension (if present)
+  // NOTE: This is needed when working with updated Babel plugin
+  if (auto pos = name.find(".node"); std::string::npos != pos) {
+    name = name.substr(0, pos);
+  }
+#endif
+
+  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) {
+  // Load addon as dynamic library
+  typename LoaderPolicy::Module library = LoaderPolicy::loadLibrary(path.c_str());
+  if (nullptr != library) {
+    // 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;
+      addon.moduleApiVersion_ = NODE_API_DEFAULT_MODULE_API_VERSION;
+      // 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;
+    }
+  }
+}
+
+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);
+}
+
+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/react-native-node-api-modules/cpp/AddonRegistry.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <unordered_map>
+#include <jsi/jsi.h>
+#include <node_api.h>
+#include "AddonLoaders.hpp"
+
+// HACK: Feature flag that enables backwards-compatible code until PR is finished
+#define USING_PATCHED_BABEL_PLUGIN  1
+
+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);
+
+  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_;
+};
+
+} // namespace callstack::nodeapihost