feat: add pro backend build request functions

CMakeLists.txt

@@ -46,12 +46,30 @@ if(MSVC)
   add_compile_definitions(NOMINMAX)
 endif()
 
+
+
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${CMAKE_JS_SRC})
-target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_JS_INC} "include/" "${CMAKE_CURRENT_SOURCE_DIR}/node_modules/node-addon-api" "${CMAKE_CURRENT_SOURCE_DIR}/node_modules" "${CMAKE_CURRENT_SOURCE_DIR}/node_modules/node-api-headers/include")
+
+# Mark the node-addon-api headers as system so the -Werror=switch-enum does not apply to them
+target_include_directories(${PROJECT_NAME}
+    SYSTEM PRIVATE
+    ${CMAKE_JS_INC}
+    ${CMAKE_CURRENT_SOURCE_DIR}/node_modules/node-addon-api
+    ${CMAKE_CURRENT_SOURCE_DIR}/node_modules
+    ${CMAKE_CURRENT_SOURCE_DIR}/node_modules/node-api-headers/include
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE  "include/" )
 
 set_target_properties(${PROJECT_NAME} PROPERTIES PREFIX "" SUFFIX ".node")
 target_link_libraries(${PROJECT_NAME} PRIVATE ${CMAKE_JS_LIB} ${LIBSESSION_STATIC_BUNDLE_LIBS})
 
+
+if(UNIX AND NOT APPLE)
+    target_compile_options(${PROJECT_NAME} PRIVATE -Werror=switch-enum)
+endif()
+
+
 if(MSVC AND CMAKE_JS_NODELIB_DEF AND CMAKE_JS_NODELIB_TARGET)
   # Generate node.lib
   execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF} /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})

include/utilities.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <fmt/format.h>
 #include <napi.h>
 
 #include <chrono>
@@ -23,6 +24,12 @@ namespace session::nodeapi {
 
 using namespace std::literals;
 
+#ifdef _MSC_VER
+#define UNREACHABLE() __assume(0)
+#else
+#define UNREACHABLE() __builtin_unreachable()
+#endif
+
 inline auto cat = oxen::log::Cat("nodeapi");
 
 static void checkOrThrow(bool condition, const char* msg) {
@@ -239,6 +246,21 @@ struct toJs_impl<std::chrono::sys_seconds> {
     }
 };
 
+template <>
+struct toJs_impl<std::chrono::milliseconds> {
+    auto operator()(const Napi::Env& env, std::chrono::milliseconds t) const {
+        return Napi::Number::New(env, t.count());
+    }
+};
+
+template <>
+struct toJs_impl<std::chrono::sys_time<std::chrono::milliseconds>> {
+    auto operator()(
+            const Napi::Env& env, std::chrono::sys_time<std::chrono::milliseconds> t) const {
+        return Napi::Number::New(env, t.time_since_epoch().count());
+    }
+};
+
 // Returns {"url": "...", "key": buffer} object; both values will be Null if the pic is not set.
 
 template <>
@@ -383,7 +405,7 @@ template <std::size_t N>
 std::array<uint8_t, N> from_hex_to_array(std::string x) {
     std::string as_hex = oxenc::from_hex(x);
     if (as_hex.size() != N) {
-        throw std::invalid_argument(std::format(
+        throw std::invalid_argument(fmt::format(
                 "from_hex_to_array: Decoded hex size mismatch: expected {}, got {}",
                 N,
                 as_hex.size()));
@@ -410,7 +432,7 @@ concept HasSize = requires(T t) {
 template <HasSize T>
 void assert_length(const T& x, size_t n, std::string_view base_identifier) {
     if (x.size() != n) {
-        throw std::invalid_argument(std::format(
+        throw std::invalid_argument(fmt::format(
                 "assert_length: expected {}, got {} for {}", n, x.size(), base_identifier));
     }
 }

src/pro/pro.cpp

@@ -1,15 +1,16 @@
 #include "pro/pro.hpp"
 
 namespace session::nodeapi {
+
 std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_PAYMENT_PROVIDER v) {
     switch (v) {
         case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_NIL: return "NIL";
         case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_GOOGLE_PLAY_STORE: return "GOOGLE_PLAY_STORE";
         case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_IOS_APP_STORE: return "IOS_APP_STORE";
         case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_COUNT:
-            // TODO: do we want to assert this cant happen? or should it be allowed?
-            return "Count";
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PAYMENT_PROVIDER_COUNT");
     }
+    UNREACHABLE();
 }
 
 std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_PAYMENT_STATUS v) {
@@ -20,42 +21,89 @@ std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_PAYMENT_STATUS v) {
         case SESSION_PRO_BACKEND_PAYMENT_STATUS_EXPIRED: return "EXPIRED";
         case SESSION_PRO_BACKEND_PAYMENT_STATUS_REFUNDED: return "REFUNDED";
         case SESSION_PRO_BACKEND_PAYMENT_STATUS_COUNT:
-            // TODO: do we want to assert this cant happen? or should it be allowed?
-            return "COUNT";
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PAYMENT_STATUS_COUNT");
     }
+    UNREACHABLE();
 }
 
-std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_PLAN v) {
+std::string_view proBackendEnumToString(SESSION_PRO_BACKEND_PLAN v) {
     switch (v) {
         case SESSION_PRO_BACKEND_PLAN_NIL: return "NIL";
         case SESSION_PRO_BACKEND_PLAN_ONE_MONTH: return "ONE_MONTH";
         case SESSION_PRO_BACKEND_PLAN_THREE_MONTHS: return "THREE_MONTHS";
         case SESSION_PRO_BACKEND_PLAN_TWELVE_MONTHS: return "TWELVE_MONTHS";
         case SESSION_PRO_BACKEND_PLAN_COUNT:
-            // TODO: do we want to assert this cant happen? or should it be allowed?
-            return "COUNT";
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PLAN_COUNT");
     }
+    UNREACHABLE();
 }
 
-std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_USER_PRO_STATUS v) {
+std::string_view proBackendEnumToString(SESSION_PRO_BACKEND_USER_PRO_STATUS v) {
     switch (v) {
         case SESSION_PRO_BACKEND_USER_PRO_STATUS_NEVER_BEEN_PRO: return "NEVER_BEEN_PRO";
         case SESSION_PRO_BACKEND_USER_PRO_STATUS_ACTIVE: return "ACTIVE";
         case SESSION_PRO_BACKEND_USER_PRO_STATUS_EXPIRED: return "EXPIRED";
         case SESSION_PRO_BACKEND_USER_PRO_STATUS_COUNT:
-            // TODO: do we want to assert this cant happen? or should it be allowed?
-            return "COUNT";
+            throw std::invalid_argument("SESSION_PRO_BACKEND_USER_PRO_STATUS_COUNT");
     }
+    UNREACHABLE();
 }
 
 std::string_view ProBackendEnumToString(SESSION_PRO_BACKEND_GET_PRO_STATUS_ERROR_REPORT v) {
     switch (v) {
         case SESSION_PRO_BACKEND_GET_PRO_STATUS_ERROR_REPORT_SUCCESS: return "SUCCESS";
         case SESSION_PRO_BACKEND_GET_PRO_STATUS_ERROR_REPORT_GENERIC_ERROR: return "GENERIC_ERROR";
         case SESSION_PRO_BACKEND_GET_PRO_STATUS_ERROR_REPORT_COUNT:
-            // TODO: do we want to assert this cant happen? or should it be allowed?
-            return "COUNT";
+            throw std::invalid_argument("SESSION_PRO_BACKEND_GET_PRO_STATUS_ERROR_REPORT_COUNT");
+    }
+    UNREACHABLE();
+}
+
+std::string_view proBackendEnumPlanToString(SESSION_PRO_BACKEND_PLAN v) {
+    switch (v) {
+        case SESSION_PRO_BACKEND_PLAN_NIL: return "NIL";
+        case SESSION_PRO_BACKEND_PLAN_ONE_MONTH: return "ONE_MONTH";
+        case SESSION_PRO_BACKEND_PLAN_THREE_MONTHS: return "THREE_MONTHS";
+        case SESSION_PRO_BACKEND_PLAN_TWELVE_MONTHS: return "TWELVE_MONTHS";
+        case SESSION_PRO_BACKEND_PLAN_COUNT:
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PLAN_COUNT");
+    }
+    UNREACHABLE();
+}
+
+std::string_view proBackendEnumPaymentProviderToString(SESSION_PRO_BACKEND_PAYMENT_PROVIDER v) {
+    switch (v) {
+        // Note: we want those to map ProOriginatingPlatform keys
+        case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_NIL: return "Nil";
+        case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_GOOGLE_PLAY_STORE: return "GooglePlayStore";
+        case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_IOS_APP_STORE: return "iOSAppStore";
+        case SESSION_PRO_BACKEND_PAYMENT_PROVIDER_COUNT:
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PAYMENT_PROVIDER_COUNT");
+    }
+    UNREACHABLE();
+}
+
+std::string_view proBackendEnumPaymentStatusToString(SESSION_PRO_BACKEND_PAYMENT_STATUS v) {
+    switch (v) {
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_NIL: return "NIL";
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_UNREDEEMED: return "UNREDEEMED";
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_REDEEMED: return "REDEEMED";
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_EXPIRED: return "EXPIRED";
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_REFUNDED: return "REFUNDED";
+        case SESSION_PRO_BACKEND_PAYMENT_STATUS_COUNT:
+            throw std::invalid_argument("SESSION_PRO_BACKEND_PAYMENT_STATUS_COUNT");
     }
+    UNREACHABLE();
 }
 
+std::string_view proBackendEnumToString(session::ProFeaturesForMsgStatus v) {
+    switch (v) {
+        case session::ProFeaturesForMsgStatus::Success: return "SUCCESS";
+        case session::ProFeaturesForMsgStatus::UTFDecodingError: return "UTF_DECODING_ERROR";
+        case session::ProFeaturesForMsgStatus::ExceedsCharacterLimit:
+            return "EXCEEDS_CHARACTER_LIMIT";
+    }
+    UNREACHABLE();
 }
+
+}  // namespace session::nodeapi

src/user_config.cpp

@@ -281,8 +281,7 @@ Napi::Value UserConfigWrapper::generateProMasterKey(const Napi::CallbackInfo& in
         assert_length(ed25519_seed_cpp_hex, 64, "generateProMasterKey");
         auto converted = from_hex_to_vector(ed25519_seed_cpp_hex);
 
-        auto pro_master_key_hex =
-                session::ed25519::ed25519_pro_key_pair_for_ed25519_seed(converted);
+        auto pro_master_key_hex = session::ed25519::ed25519_pro_privkey_for_ed25519_seed(converted);
         auto obj = Napi::Object::New(info.Env());
         obj["proMasterKey"] = toJs(info.Env(), pro_master_key_hex);