nwinread 1.1.0 → 1.2.0

package/native/eventlogasync.cc

@@ -0,0 +1,687 @@
+#include <node_api.h>
+#include <windows.h>
+#include <winevt.h>
+#include <vector>
+#include <string>
+#include <cassert>
+#include <thread>
+#include <mutex>
+#include <memory>
+#include <atomic>
+#include <functional>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+#pragma comment(lib, "wevtapi.lib")
+
+enum ReadMode {
+  FROM_BEGINNING = 0,
+  FROM_END = 1,
+  FROM_WATERMARK = 2
+};
+
+// Estructura para mantener el estado de la suscripción
+struct SubscriptionContext {
+  napi_env env;
+  napi_ref callback_ref;
+  napi_ref error_callback_ref;
+  napi_threadsafe_function tsfn;
+  napi_threadsafe_function error_tsfn;
+  EVT_HANDLE subscription;
+  std::atomic<bool> should_stop;
+  uint64_t last_record_id;
+  std::vector<int32_t> event_ids;
+  
+  SubscriptionContext() : env(nullptr), callback_ref(nullptr), error_callback_ref(nullptr),
+                         tsfn(nullptr), error_tsfn(nullptr), subscription(nullptr), 
+                         should_stop(false), last_record_id(0) {}
+};
+
+// Array global para mantener las suscripciones activas
+static std::vector<std::shared_ptr<SubscriptionContext>> active_subscriptions;
+static std::mutex subscriptions_mutex;
+
+// Funciones de conversión UTF-8 <-> Wide
+std::wstring Utf8ToWide(const std::string& str) {
+  if (str.empty()) return std::wstring();
+  
+  int size = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, NULL, 0);
+  if (size == 0) return std::wstring();
+  
+  std::wstring w(size - 1, 0);  // size -1 para excluir el terminador nulo
+  MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, &w[0], size);
+  return w;
+}
+
+std::string WideToUtf8(const std::wstring& wstr) {
+  if (wstr.empty()) return std::string();
+  
+  int size = WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, NULL, 0, NULL, NULL);
+  if (size == 0) return std::string();
+  
+  std::string str(size - 1, 0);  // size-1 para quitar el null terminator
+  WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &str[0], size, NULL, NULL);
+  return str;
+}
+
+// Estructura para pasar datos al callback JavaScript
+struct CallbackData {
+  std::string xml;
+  uint64_t record_id;
+  bool is_error;
+  std::string error_msg;
+  DWORD error_code;
+  
+  CallbackData() : record_id(0), is_error(false), error_code(0) {}
+};
+
+// Callback para threadsafe function (eventos)
+void CallJS(napi_env env, napi_value js_callback, void* context, void* data) {
+  if (data == nullptr || js_callback == nullptr) return;
+  
+  std::unique_ptr<CallbackData> callback_data(static_cast<CallbackData*>(data));
+  
+  napi_status status;
+  napi_value event_obj, xml_val, record_id_val;
+  
+  // Crear objeto de evento
+  status = napi_create_object(env, &event_obj);
+  if (status != napi_ok) return;
+  
+  // Agregar XML
+  status = napi_create_string_utf8(env, callback_data->xml.c_str(), 
+                                   callback_data->xml.length(), &xml_val);
+  if (status == napi_ok) {
+    napi_set_named_property(env, event_obj, "xml", xml_val);
+  }
+  
+  // Agregar record ID
+  status = napi_create_double(env, (double)callback_data->record_id, &record_id_val);
+  if (status == napi_ok) {
+    napi_set_named_property(env, event_obj, "recordId", record_id_val);
+  }
+  
+  // Llamar al callback JavaScript con manejo de excepciones
+  napi_value global, result;
+  status = napi_get_global(env, &global);
+  if (status == napi_ok) {
+    status = napi_call_function(env, global, js_callback, 1, &event_obj, &result);
+    if (status != napi_ok) {
+      // Limpiar cualquier excepción pendiente
+      bool pending;
+      if (napi_is_exception_pending(env, &pending) == napi_ok && pending) {
+        napi_value exception;
+        napi_get_and_clear_last_exception(env, &exception);
+      }
+    }
+  }
+}
+
+// Callback para errores
+void CallJSError(napi_env env, napi_value js_callback, void* context, void* data) {
+  if (data == nullptr || js_callback == nullptr) return;
+  
+  std::unique_ptr<CallbackData> callback_data(static_cast<CallbackData*>(data));
+  
+  napi_status status;
+  napi_value error_obj, msg_val, code_val;
+  
+  // Crear objeto de error
+  status = napi_create_object(env, &error_obj);
+  if (status != napi_ok) return;
+  
+  // Agregar mensaje
+  status = napi_create_string_utf8(env, callback_data->error_msg.c_str(), 
+                                   callback_data->error_msg.length(), &msg_val);
+  if (status == napi_ok) {
+    napi_set_named_property(env, error_obj, "message", msg_val);
+  }
+  
+  // Agregar código de error
+  status = napi_create_int32(env, callback_data->error_code, &code_val);
+  if (status == napi_ok) {
+    napi_set_named_property(env, error_obj, "code", code_val);
+  }
+  
+  // Llamar al callback JavaScript de error con manejo de excepciones
+  napi_value global, result;
+  status = napi_get_global(env, &global);
+  if (status == napi_ok) {
+    status = napi_call_function(env, global, js_callback, 1, &error_obj, &result);
+    if (status != napi_ok) {
+      // Limpiar cualquier excepción pendiente
+      bool pending;
+      if (napi_is_exception_pending(env, &pending) == napi_ok && pending) {
+        napi_value exception;
+        napi_get_and_clear_last_exception(env, &exception);
+      }
+    }
+  }
+}
+
+// Callback de Windows Event Log (se ejecuta cuando llegan eventos)
+DWORD WINAPI SubscriptionCallback(EVT_SUBSCRIBE_NOTIFY_ACTION action, 
+                                  PVOID pContext, 
+                                  EVT_HANDLE hEvent) {
+  if (action != EvtSubscribeActionDeliver) {
+    return ERROR_SUCCESS;
+  }
+
+  SubscriptionContext* ctx = static_cast<SubscriptionContext*>(pContext);
+  if (ctx == nullptr || ctx->should_stop.load()) {
+    return ERROR_SUCCESS;
+  }
+  
+  DWORD bufferUsed = 0;
+  DWORD propCount = 0;
+  
+  // Primera llamada para obtener el tamaño del buffer
+  EvtRender(NULL, hEvent, EvtRenderEventXml, 0, NULL, &bufferUsed, &propCount);
+  
+  if (bufferUsed == 0) {
+    return ERROR_SUCCESS;
+  }
+  
+  std::vector<wchar_t> buffer(bufferUsed / sizeof(wchar_t));
+  
+  // Segunda llamada para obtener los datos
+  if (EvtRender(NULL, hEvent, EvtRenderEventXml, bufferUsed, 
+                buffer.data(), &bufferUsed, &propCount)) {
+    
+    
+    std::wstring xml(buffer.data());
+    std::string xmlUtf8 = WideToUtf8(xml);
+    
+    // Extraer EventRecordID del XML
+    uint64_t recordId = 0;
+    size_t pos = xml.find(L"<EventRecordID>");
+    if (pos != std::wstring::npos) {
+      size_t end = xml.find(L"</EventRecordID>", pos);
+      if (end != std::wstring::npos) {
+        std::wstring recordIdStr = xml.substr(pos + 15, end - (pos + 15));
+        try {
+          recordId = std::stoull(recordIdStr);
+          ctx->last_record_id = recordId;
+        } catch (...) {
+          // Mantener valor anterior si hay error
+        }
+      }
+    }
+    // Crear datos para el callback
+    CallbackData* callback_data = new CallbackData();
+    callback_data->xml = xmlUtf8;
+    callback_data->record_id = recordId;
+    
+    // Enviar evento al JavaScript callback
+    napi_status status = napi_call_threadsafe_function(ctx->tsfn, callback_data, napi_tsfn_blocking);
+    if (status != napi_ok) {
+      delete callback_data;
+    }
+  } else {
+    // Error al renderizar el evento
+    DWORD errorCode = GetLastError();
+    
+    CallbackData* error_data = new CallbackData();
+    error_data->is_error = true;
+    error_data->error_msg = "Failed to render event";
+    error_data->error_code = errorCode;
+    
+    napi_status status = napi_call_threadsafe_function(ctx->error_tsfn, error_data, napi_tsfn_blocking);
+    if (status != napi_ok) {
+      delete error_data;
+    }
+  }
+  
+  return ERROR_SUCCESS;
+}
+
+// Función para crear el query XPath
+std::wstring BuildXPathQuery(const std::vector<int32_t>& eventIds, uint64_t watermark) {
+  std::wstring query;
+  
+  // Construir filtro de Event IDs si se proporcionaron
+  std::wstring eventIdFilter;
+  if (!eventIds.empty()) {
+    eventIdFilter = L"System/EventID=";
+    for (size_t i = 0; i < eventIds.size(); i++) {
+      if (i > 0) {
+        eventIdFilter += L" or System/EventID=";
+      }
+      eventIdFilter += std::to_wstring(eventIds[i]);
+    }
+  }
+  // Construir filtro de watermark si es necesario
+  std::wstring watermarkFilter;
+  if (watermark > 0) {
+    watermarkFilter = L"System/EventRecordID > " + std::to_wstring(watermark);
+  }
+  
+  // Combinar filtros
+  if (!eventIdFilter.empty() || !watermarkFilter.empty()) {
+    query = L"*[";
+    
+    if (!eventIdFilter.empty() && !watermarkFilter.empty()) {
+      query += L"(" + eventIdFilter + L") and (" + watermarkFilter + L")";
+    } else if (!eventIdFilter.empty()) {
+      query += eventIdFilter;
+    } else {
+      query += watermarkFilter;
+    }
+    
+    query += L"]";
+  }
+  
+  return query;
+}
+
+// Función JavaScript para iniciar suscripción asíncrona
+napi_value SubscribeEventLog(napi_env env, napi_callback_info info) {
+  
+  napi_status status;
+  size_t argc = 6;
+  napi_value args[6];
+  
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  assert(status == napi_ok);
+  
+  
+  if (argc < 4) {
+    napi_throw_type_error(env, nullptr, "Expected 4-6 arguments: (channel, watermark, eventCallback, errorCallback, eventIds?, mode?)");
+    return nullptr;
+  }
+  
+  // Extraer channel
+  size_t channel_len;
+  status = napi_get_value_string_utf8(env, args[0], nullptr, 0, &channel_len);
+  assert(status == napi_ok);
+  
+  std::string channel(channel_len, '\0');
+  status = napi_get_value_string_utf8(env, args[0], &channel[0], channel_len + 1, &channel_len);
+  assert(status == napi_ok);
+  
+  
+  // Extraer watermark
+  int64_t watermark;
+  status = napi_get_value_int64(env, args[1], &watermark);
+  assert(status == napi_ok);
+  
+  
+  // Los callbacks son args[2] y args[3]
+  napi_value event_callback = args[2];
+  napi_value error_callback = args[3];
+  
+  // Validar que son funciones
+  napi_valuetype callback_type, error_callback_type;
+  status = napi_typeof(env, event_callback, &callback_type);
+  assert(status == napi_ok);
+  status = napi_typeof(env, error_callback, &error_callback_type);
+  assert(status == napi_ok);
+  
+  if (callback_type != napi_function || error_callback_type != napi_function) {
+    napi_throw_type_error(env, nullptr, "Event callback and error callback must be functions");
+    return nullptr;
+  }
+  
+  // Procesar eventIds opcionales
+  std::vector<int32_t> eventIds;
+  if (argc >= 5) {
+    napi_valuetype valueType;
+    status = napi_typeof(env, args[4], &valueType);
+    
+    if (valueType != napi_null && valueType != napi_undefined) {
+      bool isArray;
+      status = napi_is_array(env, args[4], &isArray);
+      assert(status == napi_ok);
+      
+      if (isArray) {
+        uint32_t arrayLength;
+        status = napi_get_array_length(env, args[4], &arrayLength);
+        assert(status == napi_ok);
+        
+        for (uint32_t i = 0; i < arrayLength; i++) {
+          napi_value element;
+          status = napi_get_element(env, args[4], i, &element);
+          assert(status == napi_ok);
+          
+          int32_t eventId;
+          status = napi_get_value_int32(env, element, &eventId);
+          if (status == napi_ok && eventId > 0) {
+            eventIds.push_back(eventId);
+          }
+        }
+      }
+    }
+  }
+  
+  // Procesar modo opcional (argumento 6)
+  int32_t mode = FROM_END; // Default: solo eventos futuros
+  if (argc >= 6) {
+    napi_valuetype valueType;
+    status = napi_typeof(env, args[5], &valueType);
+    
+    if (valueType == napi_number) {
+      status = napi_get_value_int32(env, args[5], &mode);
+      if (status != napi_ok) {
+        mode = FROM_END; // Fallback
+      }
+    }
+  }
+  
+  
+  // Crear contexto de suscripción
+  auto ctx = std::make_shared<SubscriptionContext>();
+  ctx->env = env;
+  ctx->last_record_id = watermark > 0 ? watermark : 0;
+  ctx->event_ids = eventIds;
+  
+  // Crear referencias persistentes a los callbacks
+  status = napi_create_reference(env, event_callback, 1, &ctx->callback_ref);
+  assert(status == napi_ok);
+  status = napi_create_reference(env, error_callback, 1, &ctx->error_callback_ref);
+  assert(status == napi_ok);
+  
+  // Crear threadsafe functions
+  napi_value tsfn_name, error_tsfn_name;
+  status = napi_create_string_utf8(env, "EventLogSubscription", NAPI_AUTO_LENGTH, &tsfn_name);
+  assert(status == napi_ok);
+  status = napi_create_string_utf8(env, "EventLogSubscriptionError", NAPI_AUTO_LENGTH, &error_tsfn_name);
+  assert(status == napi_ok);
+  
+  status = napi_create_threadsafe_function(
+    env, event_callback, nullptr, tsfn_name, 0, 1, nullptr, nullptr, 
+    ctx.get(), CallJS, &ctx->tsfn);
+  assert(status == napi_ok);
+  
+  status = napi_create_threadsafe_function(
+    env, error_callback, nullptr, error_tsfn_name, 0, 1, nullptr, nullptr, 
+    ctx.get(), CallJSError, &ctx->error_tsfn);
+  assert(status == napi_ok);
+  
+  // Construir query XPath y determinar flags de suscripción basado en el modo
+  std::wstring query;
+  DWORD subscribeFlags = EvtSubscribeToFutureEvents; // Default
+  EVT_HANDLE bookmark = NULL;
+  
+  // DEBUG: Imprimir información inicial
+  
+  switch (mode) {
+    case FROM_BEGINNING:
+      // Para BEGINNING: usar oldest record, sin filtro de watermark
+      subscribeFlags = EvtSubscribeStartAtOldestRecord;
+      query = BuildXPathQuery(eventIds, 0); // Sin filtro de watermark
+      break;
+      
+    case FROM_END:
+      // Para END: eventos futuros, sin filtro de watermark
+      subscribeFlags = EvtSubscribeToFutureEvents;
+      query = BuildXPathQuery(eventIds, 0); // Sin filtro de watermark
+      break;
+      
+    case FROM_WATERMARK:
+      // Para WATERMARK: crear bookmark XML y usar EvtSubscribeStartAfterBookmark
+      subscribeFlags = EvtSubscribeStartAfterBookmark;
+      query = BuildXPathQuery(eventIds, 0); // Sin filtro de watermark en query
+      
+      // Crear bookmark directamente desde XML (método más eficiente)
+      if (watermark > 0) {
+        std::wstring channelW = Utf8ToWide(channel);
+        std::wstring watermarkStr = std::to_wstring(watermark);
+        
+        // NUEVO ENFOQUE: Buscar eventos >= watermark para crear bookmark válido
+        
+        // Crear una query que busque eventos mayor o igual al watermark
+        std::wstring queryStr = Utf8ToWide("*[System/EventRecordID >= " + std::to_string(watermark) + "]");
+        EVT_HANDLE queryHandle = EvtQuery(NULL, channelW.c_str(), queryStr.c_str(), 
+                                         EvtQueryChannelPath | EvtQueryForwardDirection);
+        
+        if (queryHandle) {
+          // Intentar leer al menos un evento para posicionar la query
+          EVT_HANDLE events[1];
+          DWORD returned;
+          if (EvtNext(queryHandle, 1, events, INFINITE, 0, &returned) && returned > 0) {
+            // Crear bookmark desde la posición actual de la query
+            bookmark = EvtCreateBookmark(NULL);
+            if (bookmark) {
+              // Actualizar bookmark con la posición actual
+              if (EvtUpdateBookmark(bookmark, events[0])) {
+                // Bookmark creado correctamente
+              } else {
+                EvtClose(bookmark);
+                bookmark = NULL;
+              }
+            }
+            EvtClose(events[0]);
+          } else {
+            // No hay eventos >= watermark, usar eventos futuros
+          }
+          EvtClose(queryHandle);
+        } else {
+          // Error en query, usar eventos futuros como fallback
+        }
+        
+        if (!bookmark) {
+          // Si no se pudo crear el bookmark, usar eventos futuros
+          subscribeFlags = EvtSubscribeToFutureEvents;
+        }
+      } else {
+        subscribeFlags = EvtSubscribeToFutureEvents;
+      }
+      break;
+      
+    default:
+      // Fallback: eventos futuros sin filtro
+      subscribeFlags = EvtSubscribeToFutureEvents;
+      query = BuildXPathQuery(eventIds, 0);
+      break;
+  }
+  
+  if (!query.empty()) {
+  } else {
+  }
+  
+  // Crear suscripción
+  ctx->subscription = EvtSubscribe(
+    NULL,
+    NULL,
+    Utf8ToWide(channel).c_str(),
+    query.empty() ? NULL : query.c_str(),
+    bookmark, // Usar bookmark en lugar de NULL
+    ctx.get(),
+    (EVT_SUBSCRIBE_CALLBACK)SubscriptionCallback,
+    subscribeFlags
+  );
+  
+  if (ctx->subscription) {
+    // Suscripción creada exitosamente - agregar a lista de suscripciones activas
+    {
+      std::lock_guard<std::mutex> lock(subscriptions_mutex);
+      active_subscriptions.push_back(ctx);
+    }
+  } else {
+    DWORD error = GetLastError();
+    // Limpiar recursos antes de fallar
+    napi_delete_reference(env, ctx->callback_ref);
+    napi_delete_reference(env, ctx->error_callback_ref);
+    napi_release_threadsafe_function(ctx->tsfn, napi_tsfn_abort);
+    napi_release_threadsafe_function(ctx->error_tsfn, napi_tsfn_abort);
+    
+    std::string errorMsg = "EvtSubscribe failed with error code: " + std::to_string(error);
+    napi_throw_error(env, nullptr, errorMsg.c_str());
+    return nullptr;
+  }
+  
+  // Limpiar bookmark si se creó
+  if (bookmark) {
+    EvtClose(bookmark);
+  }
+
+  if (ctx->subscription) {
+    // Suscripción creada exitosamente - agregar a lista de suscripciones activas
+    size_t subscription_id;
+    {
+      std::lock_guard<std::mutex> lock(subscriptions_mutex);
+      active_subscriptions.push_back(ctx);
+      subscription_id = active_subscriptions.size() - 1;
+    }
+    
+    // Retornar ID de la suscripción
+    napi_value subscription_id_val;
+    status = napi_create_double(env, (double)subscription_id, &subscription_id_val);
+    assert(status == napi_ok);
+    
+    return subscription_id_val;
+  } else {
+    DWORD error = GetLastError();
+    // Limpiar recursos antes de fallar
+    napi_delete_reference(env, ctx->callback_ref);
+    napi_delete_reference(env, ctx->error_callback_ref);
+    napi_release_threadsafe_function(ctx->tsfn, napi_tsfn_abort);
+    napi_release_threadsafe_function(ctx->error_tsfn, napi_tsfn_abort);
+    
+    std::string errorMsg = "EvtSubscribe failed with error code: " + std::to_string(error);
+    napi_throw_error(env, nullptr, errorMsg.c_str());
+    return nullptr;
+  }
+}
+
+// Función JavaScript para detener suscripción
+napi_value UnsubscribeEventLog(napi_env env, napi_callback_info info) {
+  napi_status status;
+  size_t argc = 1;
+  napi_value args[1];
+  
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  assert(status == napi_ok);
+  
+  if (argc < 1) {
+    napi_throw_type_error(env, nullptr, "Expected 1 argument: subscription_id");
+    return nullptr;
+  }
+  
+  double subscription_id_double;
+  status = napi_get_value_double(env, args[0], &subscription_id_double);
+  assert(status == napi_ok);
+  
+  size_t subscription_id = (size_t)subscription_id_double;
+  
+  std::lock_guard<std::mutex> lock(subscriptions_mutex);
+  
+  if (subscription_id >= active_subscriptions.size() || 
+      !active_subscriptions[subscription_id]) {
+    napi_throw_type_error(env, nullptr, "Invalid subscription ID");
+    return nullptr;
+  }
+  
+  auto ctx = active_subscriptions[subscription_id];
+  
+  // Marcar para detener
+  ctx->should_stop.store(true);
+  
+  // Cerrar suscripción de Windows
+  if (ctx->subscription) {
+    EvtClose(ctx->subscription);
+    ctx->subscription = nullptr;
+  }
+  
+  // Limpiar recursos de N-API
+  if (ctx->callback_ref) {
+    napi_delete_reference(env, ctx->callback_ref);
+    ctx->callback_ref = nullptr;
+  }
+  
+  if (ctx->error_callback_ref) {
+    napi_delete_reference(env, ctx->error_callback_ref);
+    ctx->error_callback_ref = nullptr;
+  }
+  
+  // Liberar threadsafe functions
+  if (ctx->tsfn) {
+    napi_release_threadsafe_function(ctx->tsfn, napi_tsfn_abort);
+    ctx->tsfn = nullptr;
+  }
+  
+  if (ctx->error_tsfn) {
+    napi_release_threadsafe_function(ctx->error_tsfn, napi_tsfn_abort);
+    ctx->error_tsfn = nullptr;
+  }
+  
+  // Remover de la lista
+  active_subscriptions[subscription_id].reset();
+  
+  // Retornar éxito
+  napi_value result;
+  status = napi_get_boolean(env, true, &result);
+  assert(status == napi_ok);
+  
+  return result;
+}
+
+// Función para obtener el último record ID de una suscripción
+napi_value GetLastRecordId(napi_env env, napi_callback_info info) {
+  napi_status status;
+  size_t argc = 1;
+  napi_value args[1];
+  
+  status = napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  assert(status == napi_ok);
+  
+  if (argc < 1) {
+    napi_throw_type_error(env, nullptr, "Expected 1 argument: subscription_id");
+    return nullptr;
+  }
+  
+  double subscription_id_double;
+  status = napi_get_value_double(env, args[0], &subscription_id_double);
+  assert(status == napi_ok);
+  
+  size_t subscription_id = (size_t)subscription_id_double;
+  
+  std::lock_guard<std::mutex> lock(subscriptions_mutex);
+  
+  if (subscription_id >= active_subscriptions.size() || 
+      !active_subscriptions[subscription_id]) {
+    napi_throw_type_error(env, nullptr, "Invalid subscription ID");
+    return nullptr;
+  }
+  
+  auto ctx = active_subscriptions[subscription_id];
+  
+  napi_value result;
+  status = napi_create_double(env, (double)ctx->last_record_id, &result);
+  assert(status == napi_ok);
+  
+  return result;
+}
+
+// Inicialización del módulo
+napi_value Init(napi_env env, napi_value exports) {
+  napi_status status;
+  napi_value subscribe_fn, unsubscribe_fn, get_last_record_fn;
+  
+  // Crear función de suscripción
+  status = napi_create_function(env, nullptr, 0, SubscribeEventLog, nullptr, &subscribe_fn);
+  assert(status == napi_ok);
+  
+  // Crear función de cancelar suscripción
+  status = napi_create_function(env, nullptr, 0, UnsubscribeEventLog, nullptr, &unsubscribe_fn);
+  assert(status == napi_ok);
+  
+  // Crear función para obtener último record ID
+  status = napi_create_function(env, nullptr, 0, GetLastRecordId, nullptr, &get_last_record_fn);
+  assert(status == napi_ok);
+  
+  // Exportar funciones
+  status = napi_set_named_property(env, exports, "subscribe", subscribe_fn);
+  assert(status == napi_ok);
+  
+  status = napi_set_named_property(env, exports, "unsubscribe", unsubscribe_fn);
+  assert(status == napi_ok);
+  
+  status = napi_set_named_property(env, exports, "getLastRecordId", get_last_record_fn);
+  assert(status == napi_ok);
+  
+  return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, Init)