objc-js 0.0.14 → 1.0.0

package/src/native/memory-utils.h

@@ -0,0 +1,197 @@
+#ifndef MEMORY_UTILS_H
+#define MEMORY_UTILS_H
+
+#include "debug.h"
+#include "protocol-storage.h"
+#include <Foundation/Foundation.h>
+
+// MARK: - InvocationDataGuard RAII Wrapper
+
+/**
+ * RAII wrapper for InvocationData to ensure proper cleanup.
+ * 
+ * This class manages the lifetime of InvocationData*, ensuring that:
+ * 1. The NSInvocation is released
+ * 2. The InvocationData is deleted
+ * 3. Cleanup happens even when exceptions are thrown
+ * 
+ * Usage:
+ *   auto data = new InvocationData();
+ *   InvocationDataGuard guard(data);
+ *   // ... use data ...
+ *   guard.release();  // Transfer ownership on success
+ * 
+ * If release() is not called, cleanup happens in destructor.
+ */
+class InvocationDataGuard {
+public:
+  explicit InvocationDataGuard(InvocationData* data) : data_(data), released_(false) {
+#if NOBJC_DEBUG
+    if (data_) {
+      NOBJC_LOG("InvocationDataGuard: acquired data=%p, selector=%s", 
+                data_, data_->selectorName.c_str());
+    }
+#endif
+  }
+  
+  // Non-copyable
+  InvocationDataGuard(const InvocationDataGuard&) = delete;
+  InvocationDataGuard& operator=(const InvocationDataGuard&) = delete;
+  
+  // Movable
+  InvocationDataGuard(InvocationDataGuard&& other) noexcept 
+      : data_(other.data_), released_(other.released_) {
+    other.data_ = nullptr;
+    other.released_ = true;
+  }
+  
+  InvocationDataGuard& operator=(InvocationDataGuard&& other) noexcept {
+    if (this != &other) {
+      cleanup();
+      data_ = other.data_;
+      released_ = other.released_;
+      other.data_ = nullptr;
+      other.released_ = true;
+    }
+    return *this;
+  }
+  
+  ~InvocationDataGuard() {
+    cleanup();
+  }
+  
+  /**
+   * Release ownership of the data without cleanup.
+   * Call this when you're transferring ownership elsewhere (e.g., to a callback).
+   * @return The raw pointer (caller takes ownership)
+   */
+  InvocationData* release() {
+    released_ = true;
+    InvocationData* ptr = data_;
+    data_ = nullptr;
+#if NOBJC_DEBUG
+    if (ptr) {
+      NOBJC_LOG("InvocationDataGuard: released ownership of data=%p", ptr);
+    }
+#endif
+    return ptr;
+  }
+  
+  /**
+   * Get the raw pointer without releasing ownership.
+   */
+  InvocationData* get() const { return data_; }
+  
+  /**
+   * Check if the guard has valid data.
+   */
+  explicit operator bool() const { return data_ != nullptr && !released_; }
+  
+  /**
+   * Arrow operator for convenient access.
+   */
+  InvocationData* operator->() const { return data_; }
+  
+private:
+  void cleanup() {
+    if (data_ && !released_) {
+#if NOBJC_DEBUG
+      NOBJC_LOG("InvocationDataGuard: cleaning up data=%p, selector=%s", 
+                data_, data_->selectorName.c_str());
+#endif
+      // Release the NSInvocation if present
+      if (data_->invocation) {
+        [data_->invocation release];
+        data_->invocation = nil;
+      }
+      
+      // Delete the data
+      delete data_;
+      data_ = nullptr;
+    }
+  }
+  
+  InvocationData* data_;
+  bool released_;
+};
+
+// MARK: - Cleanup Callback for CallJSCallback
+
+/**
+ * Helper function to clean up InvocationData after a JS callback completes.
+ * This is called from CallJSCallback to ensure proper cleanup regardless of
+ * success or failure.
+ * 
+ * @param data The InvocationData to clean up (takes ownership)
+ */
+inline void CleanupInvocationData(InvocationData* data) {
+  if (!data) return;
+  
+#if NOBJC_DEBUG
+  NOBJC_LOG("CleanupInvocationData: cleaning up selector=%s", 
+            data->selectorName.c_str());
+#endif
+  
+  // Signal completion if we have synchronization primitives
+  SignalInvocationComplete(data);
+  
+  // Release the invocation
+  if (data->invocation) {
+    [data->invocation release];
+    data->invocation = nil;
+  }
+  
+  // Delete the data
+  delete data;
+}
+
+// MARK: - ScopeGuard for Generic Cleanup
+
+/**
+ * Generic scope guard for executing cleanup code on scope exit.
+ * 
+ * Usage:
+ *   auto guard = MakeScopeGuard([&] { cleanup_code(); });
+ *   // ... do work ...
+ *   guard.dismiss();  // Don't run cleanup on success
+ */
+template<typename Func>
+class ScopeGuard {
+public:
+  explicit ScopeGuard(Func&& func) : func_(std::forward<Func>(func)), active_(true) {}
+  
+  ScopeGuard(ScopeGuard&& other) noexcept 
+      : func_(std::move(other.func_)), active_(other.active_) {
+    other.active_ = false;
+  }
+  
+  ~ScopeGuard() {
+    if (active_) {
+      try {
+        func_();
+      } catch (...) {
+        // Suppress exceptions in destructor
+#if NOBJC_DEBUG
+        NOBJC_ERROR("ScopeGuard: exception during cleanup (suppressed)");
+#endif
+      }
+    }
+  }
+  
+  void dismiss() { active_ = false; }
+  
+  // Non-copyable
+  ScopeGuard(const ScopeGuard&) = delete;
+  ScopeGuard& operator=(const ScopeGuard&) = delete;
+  
+private:
+  Func func_;
+  bool active_;
+};
+
+template<typename Func>
+ScopeGuard<Func> MakeScopeGuard(Func&& func) {
+  return ScopeGuard<Func>(std::forward<Func>(func));
+}
+
+#endif // MEMORY_UTILS_H

package/src/native/method-forwarding.mm

@@ -1,8 +1,13 @@
 #include "method-forwarding.h"
 #include "debug.h"
+#include "forwarding-common.h"
+#include "memory-utils.h"
 #include "ObjcObject.h"
+#include "protocol-manager.h"
 #include "protocol-storage.h"
 #include "type-conversion.h"
+
+using nobjc::ProtocolManager;
 #include <CoreFoundation/CoreFoundation.h>
 #include <Foundation/Foundation.h>
 #include <napi.h>
@@ -12,8 +17,13 @@
 
 // This function runs on the JavaScript thread
 // Handles both protocol implementation and subclass method forwarding
+// NOTE: This function takes ownership of data and must clean it up
 void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
                     InvocationData *data) {
+  // Use RAII to ensure cleanup even if we return early or throw
+  // The guard will release the invocation and delete data
+  InvocationDataGuard guard(data);
+  
   if (!data) {
     NOBJC_ERROR("InvocationData is null in CallJSCallback");
     return;
@@ -26,20 +36,15 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   if (jsCallback.IsEmpty()) {
     NOBJC_ERROR("jsCallback is null/empty in CallJSCallback for selector %s",
           data->selectorName.c_str());
-    if (data->invocation) {
-      [data->invocation release];
-    }
     SignalInvocationComplete(data);
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NSInvocation *invocation = data->invocation;
   if (!invocation) {
     NOBJC_ERROR("NSInvocation is null in CallJSCallback");
     SignalInvocationComplete(data);
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NOBJC_LOG("CallJSCallback: About to get method signature");
@@ -50,9 +55,7 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
     NOBJC_ERROR("Failed to get method signature for selector %s",
           data->selectorName.c_str());
     SignalInvocationComplete(data);
-    [invocation release];
-    delete data;
-    return;
+    return;  // guard cleans up
   }
 
   NOBJC_LOG("CallJSCallback: Method signature: %s, numArgs: %lu", 
@@ -124,10 +127,7 @@ void CallJSCallback(Napi::Env env, Napi::Function jsCallback,
   SignalInvocationComplete(data);
   NOBJC_LOG("CallJSCallback: Signaled completion for %s", data->selectorName.c_str());
 
-  // Clean up the invocation data
-  // Release the invocation that we retained in ForwardInvocation
-  [invocation release];
-  delete data;
+  // guard destructor cleans up invocation and data
 }
 
 // MARK: - Fallback Helper
@@ -177,19 +177,23 @@ BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
   void *ptr = (__bridge void *)self;
 
   // Check if this is one of our implemented methods
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
+  bool found = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) {
+    auto it = map.find(ptr);
+    if (it != map.end()) {
       NSString *selectorString = NSStringFromSelector(selector);
       if (selectorString != nil) {
         std::string selName = [selectorString UTF8String];
         auto callbackIt = it->second.callbacks.find(selName);
         if (callbackIt != it->second.callbacks.end()) {
-          return YES;
+          return true;
         }
       }
     }
+    return false;
+  });
+
+  if (found) {
+    return YES;
   }
 
   // For methods we don't implement, check if NSObject responds to them
@@ -201,15 +205,21 @@ BOOL RespondsToSelector(id self, SEL _cmd, SEL selector) {
 NSMethodSignature *MethodSignatureForSelector(id self, SEL _cmd, SEL selector) {
   void *ptr = (__bridge void *)self;
 
-  std::lock_guard<std::mutex> lock(g_implementations_mutex);
-  auto it = g_implementations.find(ptr);
-  if (it != g_implementations.end()) {
-    NSString *selectorString = NSStringFromSelector(selector);
-    std::string selName = [selectorString UTF8String];
-    auto encIt = it->second.typeEncodings.find(selName);
-    if (encIt != it->second.typeEncodings.end()) {
-      return [NSMethodSignature signatureWithObjCTypes:encIt->second.c_str()];
+  NSMethodSignature *sig = ProtocolManager::Instance().WithLock([ptr, selector](auto& map) -> NSMethodSignature* {
+    auto it = map.find(ptr);
+    if (it != map.end()) {
+      NSString *selectorString = NSStringFromSelector(selector);
+      std::string selName = [selectorString UTF8String];
+      auto encIt = it->second.typeEncodings.find(selName);
+      if (encIt != it->second.typeEncodings.end()) {
+        return [NSMethodSignature signatureWithObjCTypes:encIt->second.c_str()];
+      }
     }
+    return nil;
+  });
+  
+  if (sig != nil) {
+    return sig;
   }
   // Fall back to superclass for methods we don't implement
   return [NSObject instanceMethodSignatureForSelector:selector];
@@ -223,222 +233,141 @@ void ForwardInvocation(id self, SEL _cmd, NSInvocation *invocation) {
   }
 
   // Retain the invocation to keep it alive during async call
-  // retainArguments only retains the arguments, not the invocation itself
   [invocation retainArguments];
-  [invocation retain]; // Keep invocation alive until callback completes
+  [invocation retain];
 
   SEL selector = [invocation selector];
   NSString *selectorString = NSStringFromSelector(selector);
   if (!selectorString) {
     NOBJC_ERROR("Failed to convert selector to string");
+    [invocation release];
     return;
   }
 
   std::string selectorName = [selectorString UTF8String];
-
-  // Store self pointer for later lookups
   void *ptr = (__bridge void *)self;
 
-  // Get thread-safe data (TSFN, typeEncoding, js_thread)
-  // DO NOT access any N-API values here - we may not be on the JS thread!
-  Napi::ThreadSafeFunction tsfn;
-  std::string typeEncoding;
-  pthread_t js_thread;
-  bool isElectron;
-  {
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
-    auto it = g_implementations.find(ptr);
-    if (it == g_implementations.end()) {
-      NOBJC_WARN("Protocol implementation not found for instance %p", self);
-      return;
-    }
-
-    auto callbackIt = it->second.callbacks.find(selectorName);
-    if (callbackIt == it->second.callbacks.end()) {
-      NOBJC_WARN("Callback not found for selector %s", selectorName.c_str());
-      return;
-    }
-
-    // Get the ThreadSafeFunction - this is thread-safe by design
-    // IMPORTANT: We must Acquire() to increment the ref count, because copying
-    // a ThreadSafeFunction does NOT increment it. If DeallocImplementation
-    // runs and calls Release() on the original, our copy would become invalid.
-    tsfn = callbackIt->second;
-    napi_status acq_status = tsfn.Acquire();
-    if (acq_status != napi_ok) {
-      NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s",
-            selectorName.c_str());
-      return;
-    }
-
-    // Get the type encoding for return value handling
-    auto encIt = it->second.typeEncodings.find(selectorName);
-    if (encIt != it->second.typeEncodings.end()) {
-      typeEncoding = encIt->second;
-    }
-
-    // Get the JS thread ID to check if we're on the same thread
-    js_thread = it->second.js_thread;
-    isElectron = it->second.isElectron;
-  }
-
-  // Check if we're on the JS thread
-  bool is_js_thread = pthread_equal(pthread_self(), js_thread);
-
-  // IMPORTANT: We call directly on the JS thread so return values are set
-  // synchronously; otherwise we use a ThreadSafeFunction to marshal work.
-  // EXCEPTION: In Electron, we ALWAYS use TSFN even on the JS thread because
-  // Electron's V8 context isn't properly set up for direct handle creation.
+  // Set up callbacks for protocol-specific storage access
+  ForwardingCallbacks callbacks;
+  callbacks.callbackType = CallbackType::Protocol;
+
+  // Lookup context and acquire TSFN
+  callbacks.lookupContext = [](void *lookupKey,
+                               const std::string &selName) -> std::optional<ForwardingContext> {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> std::optional<ForwardingContext> {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        NOBJC_WARN("Protocol implementation not found for instance %p", lookupKey);
+        return std::nullopt;
+      }
 
-  // Create invocation data
-  auto data = new InvocationData();
-  data->invocation = invocation;
-  data->selectorName = selectorName;
-  data->typeEncoding = typeEncoding;
-  data->callbackType = CallbackType::Protocol;
+      auto callbackIt = it->second.callbacks.find(selName);
+      if (callbackIt == it->second.callbacks.end()) {
+        NOBJC_WARN("Callback not found for selector %s", selName.c_str());
+        return std::nullopt;
+      }
 
-  napi_status status;
+      // Acquire the TSFN
+      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      napi_status acq_status = tsfn.Acquire();
+      if (acq_status != napi_ok) {
+        NOBJC_WARN("Failed to acquire ThreadSafeFunction for selector %s", selName.c_str());
+        return std::nullopt;
+      }
 
-  if (is_js_thread && !isElectron) {
-    // We're on the JS thread in Node/Bun (NOT Electron)
-    // Call directly to ensure return values are set synchronously.
-    data->completionMutex = nullptr;
-    data->completionCv = nullptr;
-    data->isComplete = nullptr;
+      ForwardingContext ctx;
+      ctx.tsfn = tsfn;
+      ctx.js_thread = it->second.js_thread;
+      ctx.env = it->second.env;
+      ctx.skipDirectCallForElectron = it->second.isElectron;
+      ctx.instancePtr = nullptr;   // Not used for protocols
+      ctx.superClassPtr = nullptr; // Not used for protocols
+
+      // Cache the JS callback reference to avoid mutex re-acquisition
+      auto jsCallbackIt = it->second.jsCallbacks.find(selName);
+      if (jsCallbackIt != it->second.jsCallbacks.end()) {
+        ctx.cachedJsCallback = &jsCallbackIt->second;
+      }
 
-    tsfn.Release();
+      auto encIt = it->second.typeEncodings.find(selName);
+      if (encIt != it->second.typeEncodings.end()) {
+        ctx.typeEncoding = encIt->second;
+      }
 
-    Napi::Function jsFn;
-    napi_env stored_env;
-    {
-      std::lock_guard<std::mutex> lock(g_implementations_mutex);
-      auto it = g_implementations.find(ptr);
-      if (it == g_implementations.end()) {
-        NOBJC_WARN("Protocol implementation not found for instance %p (JS thread path)", self);
-        [invocation release];
-        delete data;
-        return;
+      return ctx;
+    });
+  };
+
+  // Get JS function for direct call path
+  callbacks.getJSFunction = [](void *lookupKey, const std::string &selName,
+                               Napi::Env /*env*/) -> Napi::Function {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> Napi::Function {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        return Napi::Function();
       }
 
-      auto jsCallbackIt = it->second.jsCallbacks.find(selectorName);
+      auto jsCallbackIt = it->second.jsCallbacks.find(selName);
       if (jsCallbackIt == it->second.jsCallbacks.end()) {
-        NOBJC_WARN("JS callback not found for selector %s (JS thread path)",
-              selectorName.c_str());
-        [invocation release];
-        delete data;
-        return;
+        return Napi::Function();
       }
 
-      stored_env = it->second.env;
-      jsFn = jsCallbackIt->second.Value();
-    }
-
-    // Safely call the JS callback with proper V8 context setup
-    // Wrap in try-catch to handle invalid env (e.g., in Electron when context
-    // is destroyed)
-    try {
-      Napi::Env callEnv(stored_env);
-      
-      // Create a HandleScope to properly manage V8 handles
-      // This is critical for Electron which may have multiple V8 contexts
-      Napi::HandleScope scope(callEnv);
-      
-      CallJSCallback(callEnv, jsFn, data);
-      // CallJSCallback releases invocation and deletes data.
-    } catch (const std::exception &e) {
-      NOBJC_ERROR("Error calling JS callback directly (likely invalid env in Electron): %s", e.what());
-      NOBJC_LOG("Falling back to ThreadSafeFunction for selector %s", selectorName.c_str());
-      
-      // Fallback to TSFN if direct call fails (e.g., invalid env in Electron)
-      // We need to re-acquire the TSFN
-      {
-        std::lock_guard<std::mutex> lock(g_implementations_mutex);
-        auto it = g_implementations.find(ptr);
-        if (it != g_implementations.end()) {
-          auto callbackIt = it->second.callbacks.find(selectorName);
-          if (callbackIt != it->second.callbacks.end()) {
-            tsfn = callbackIt->second;
-            napi_status acq_status = tsfn.Acquire();
-            if (acq_status == napi_ok) {
-              // Use helper function for fallback
-              if (FallbackToTSFN(tsfn, data, selectorName)) {
-                return; // Data cleaned up in callback
-              }
-            }
-          }
-        }
+      return jsCallbackIt->second.Value();
+    });
+  };
+
+  // Re-acquire TSFN for fallback path
+  callbacks.reacquireTSFN = [](void *lookupKey,
+                               const std::string &selName) -> std::optional<Napi::ThreadSafeFunction> {
+    return ProtocolManager::Instance().WithLock([lookupKey, &selName](auto& map) -> std::optional<Napi::ThreadSafeFunction> {
+      auto it = map.find(lookupKey);
+      if (it == map.end()) {
+        return std::nullopt;
       }
-      
-      // If fallback also failed, clean up manually
-      [invocation release];
-      delete data;
-    }
-  } else {
-    // We're on a different thread (e.g., Cocoa callback from
-    // ASAuthorizationController) Use NonBlockingCall + runloop pumping to avoid
-    // deadlocks
-    std::mutex completionMutex;
-    std::condition_variable completionCv;
-    bool isComplete = false;
-
-    data->completionMutex = &completionMutex;
-    data->completionCv = &completionCv;
-    data->isComplete = &isComplete;
-
-    status = tsfn.NonBlockingCall(data, CallJSCallback);
-    tsfn.Release();
-
-    if (status != napi_ok) {
-      NOBJC_ERROR("Failed to call ThreadSafeFunction for selector %s (status: %d)",
-            selectorName.c_str(), status);
-      [invocation release];
-      delete data;
-      return;
-    }
 
-    // Wait for callback by pumping CFRunLoop
-    // This allows the event loop to process our callback
-    CFTimeInterval timeout = 0.001; // 1ms per iteration
+      auto callbackIt = it->second.callbacks.find(selName);
+      if (callbackIt == it->second.callbacks.end()) {
+        return std::nullopt;
+      }
 
-    while (true) {
-      {
-        std::unique_lock<std::mutex> lock(completionMutex);
-        if (isComplete) {
-          break;
-        }
+      Napi::ThreadSafeFunction tsfn = callbackIt->second;
+      napi_status acq_status = tsfn.Acquire();
+      if (acq_status != napi_ok) {
+        return std::nullopt;
       }
-      CFRunLoopRunInMode(kCFRunLoopDefaultMode, timeout, true);
-    }
-    // Data cleaned up in callback
-  }
 
-  // Return value (if any) has been set on the invocation
+      return tsfn;
+    });
+  };
+
+  ForwardInvocationCommon(invocation, selectorName, ptr, callbacks);
 }
 
 // Deallocation implementation
 void DeallocImplementation(id self, SEL _cmd) {
   @autoreleasepool {
-    // Remove the implementation from the global map
-    std::lock_guard<std::mutex> lock(g_implementations_mutex);
+    // Remove the implementation from the manager
     void *ptr = (__bridge void *)self;
-    auto it = g_implementations.find(ptr);
-    if (it != g_implementations.end()) {
-      // Release all ThreadSafeFunctions and JS callbacks
-      // Do this carefully to avoid issues during shutdown
-      try {
-        for (auto &pair : it->second.callbacks) {
-          // Release the ThreadSafeFunction
-          pair.second.Release();
+    ProtocolManager::Instance().WithLock([ptr, self](auto& map) {
+      auto it = map.find(ptr);
+      if (it != map.end()) {
+        // Release all ThreadSafeFunctions and JS callbacks
+        // Do this carefully to avoid issues during shutdown
+        try {
+          for (auto &pair : it->second.callbacks) {
+            // Release the ThreadSafeFunction
+            pair.second.Release();
+          }
+          it->second.callbacks.clear();
+          it->second.jsCallbacks.clear();
+          it->second.typeEncodings.clear();
+        } catch (...) {
+          // Ignore errors during cleanup
+          NOBJC_WARN("Exception during callback cleanup for instance %p", self);
         }
-        it->second.callbacks.clear();
-        it->second.jsCallbacks.clear();
-        it->second.typeEncodings.clear();
-      } catch (...) {
-        // Ignore errors during cleanup
-        NOBJC_WARN("Exception during callback cleanup for instance %p", self);
+        map.erase(it);
       }
-      g_implementations.erase(it);
-    }
+    });
   }
 
   // Call the superclass dealloc