@emnapi/node-binding 0.31.0

package/README.md

@@ -0,0 +1 @@
+See [https://github.com/toyobayashi/emnapi](https://github.com/toyobayashi/emnapi)

package/binding.gyp

@@ -0,0 +1,31 @@
+{
+  "variables": {
+    "module_name": "emnapi_node_binding",
+    "module_path": "./dist"
+  },
+  'targets': [
+    {
+      'target_name': '<(module_name)',
+      'sources': [
+        'src/binding.cpp',
+      ],
+    },
+    {
+      'target_name': '<(module_name)_napi',
+      'sources': [
+        'src/napi.c',
+      ],
+    },
+    {
+      "target_name": "action_after_build",
+      "type": "none",
+      "dependencies": [ "<(module_name)", '<(module_name)_napi' ],
+      "copies": [
+        {
+          "files": [ "<(PRODUCT_DIR)/<(module_name).node", "<(PRODUCT_DIR)/<(module_name)_napi.node" ],
+          "destination": "<(module_path)"
+        }
+      ]
+    }
+  ]
+}

package/index.d.ts

@@ -0,0 +1,29 @@
+export declare interface AsyncContext {
+  asyncId: number
+  triggerAsyncId: number
+}
+
+export declare interface NapiResult<T> {
+  status: number
+  value: T
+  error?: any
+}
+
+export declare namespace node {
+  export function emitAsyncInit (resource: object, name: string, triggerAsyncId: number): AsyncContext
+  export function emitAsyncDestroy (asyncContext: AsyncContext): void
+  // export function openCallbackScope (resource: object, asyncContext: AsyncContext): bigint
+  // export function closeCallbackScope (callbackScope: bigint): void
+  export function makeCallback<P extends any[], T> (resource: object, cb: (...args: P) => T, argv: P, asyncContext: AsyncContext): T
+}
+
+export declare namespace napi {
+  export function asyncInit (resource: object | undefined | null, name: string): NapiResult<bigint>
+  export function asyncDestroy (asyncContextPointer: bigint): NapiResult<undefined>
+  export function makeCallback<P extends any[], T> (
+    asyncContextPointer: bigint,
+    recv: any,
+    func: (...args: P) => T,
+    argv: P
+  ): NapiResult<T>
+}

package/index.js

@@ -0,0 +1,6 @@
+'use strict'
+
+module.exports = {
+  node: require('./dist/emnapi_node_binding.node'),
+  napi: require('./dist/emnapi_node_binding_napi.node')
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@emnapi/node-binding",
+  "version": "0.31.0",
+  "description": "Bridge connecting emnapi and Node.js native implementation",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "build": "node-gyp rebuild"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toyobayashi/emnapi.git"
+  },
+  "author": "toyobayashi",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/toyobayashi/emnapi/issues"
+  },
+  "homepage": "https://github.com/toyobayashi/emnapi#readme",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/binding.cpp

@@ -0,0 +1,98 @@
+#include <vector>
+#include <node.h>
+
+namespace emnapi_node_binding {
+
+namespace {
+
+void EmitAsyncInit(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> resource = args[0].As<v8::Object>();
+  v8::Local<v8::String> name = args[1].As<v8::String>();
+  double trigger_async_id = args[2].As<v8::Number>()->Value();
+
+  node::async_context result_context = node::EmitAsyncInit(isolate, resource, name, trigger_async_id);
+
+  v8::Local<v8::Object> result = v8::Object::New(isolate);
+  v8::Local<v8::String> async_id_key = v8::String::NewFromUtf8(isolate, "asyncId").ToLocalChecked();
+  v8::Local<v8::String> trigger_async_id_key = v8::String::NewFromUtf8(isolate, "triggerAsyncId").ToLocalChecked();
+  v8::Local<v8::Number> result_async_id = v8::Number::New(isolate, result_context.async_id);
+  v8::Local<v8::Number> result_trigger_async_id = v8::Number::New(isolate, result_context.trigger_async_id);
+  result->Set(context, async_id_key, result_async_id).ToChecked();
+  result->Set(context, trigger_async_id_key, result_trigger_async_id).ToChecked();
+
+  args.GetReturnValue().Set(result);
+}
+
+inline node::async_context FromAsyncContextObject(v8::Isolate* isolate,
+                                                  v8::Local<v8::Object> async_context_object) {
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  double async_id = async_context_object
+    ->Get(context, v8::String::NewFromUtf8(isolate, "asyncId").ToLocalChecked()).ToLocalChecked()
+    .As<v8::Number>()->Value();
+  double trigger_async_id = async_context_object
+    ->Get(context, v8::String::NewFromUtf8(isolate, "triggerAsyncId").ToLocalChecked()).ToLocalChecked()
+    .As<v8::Number>()->Value();
+  
+  return { async_id, trigger_async_id };
+}
+
+void EmitAsyncDestroy(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::Local<v8::Object> async_context_object = args[0].As<v8::Object>();
+  node::EmitAsyncDestroy(isolate, FromAsyncContextObject(isolate, async_context_object));
+  args.GetReturnValue().Set(v8::Undefined(isolate));
+}
+
+/* void OpenCallbackScope(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::Local<v8::Object> resource = args[0].As<v8::Object>();
+  v8::Local<v8::Object> async_context_object = args[1].As<v8::Object>();
+
+  node::CallbackScope* callback_scope = new node::CallbackScope(
+      isolate, resource, FromAsyncContextObject(isolate, async_context_object));
+
+  args.GetReturnValue().Set(v8::BigInt::New(isolate, reinterpret_cast<int64_t>(callback_scope)));
+}
+
+void CloseCallbackScope(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::Local<v8::BigInt> scope = args[0].As<v8::BigInt>();
+
+  node::CallbackScope* callback_scope = reinterpret_cast<node::CallbackScope*>(scope->Int64Value());
+  delete callback_scope;
+
+  args.GetReturnValue().Set(v8::Undefined(isolate));
+} */
+
+void MakeCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  v8::Isolate* isolate = args.GetIsolate();
+  v8::Local<v8::Context> context = isolate->GetCurrentContext();
+  v8::Local<v8::Object> resource = args[0].As<v8::Object>();
+  v8::Local<v8::Function> cb = args[1].As<v8::Function>();
+  v8::Local<v8::Array> argv = args[2].As<v8::Array>();
+  v8::Local<v8::Object> async_context_object = args[3].As<v8::Object>();
+
+  uint32_t argc = argv->Length();
+  std::vector<v8::Local<v8::Value>> vec_argv(argc);
+  for (uint32_t i = 0; i < argc; ++i) {
+    vec_argv[i] = argv->Get(context, i).ToLocalChecked();
+  }
+
+  v8::MaybeLocal<v8::Value> ret = node::MakeCallback(isolate, resource, cb, argc, vec_argv.data(), FromAsyncContextObject(isolate, async_context_object));
+
+  args.GetReturnValue().Set(ret.FromMaybe(v8::Local<v8::Value>()));
+}
+
+}
+
+NODE_MODULE_INIT() {
+  NODE_SET_METHOD(exports, "emitAsyncInit", EmitAsyncInit);
+  NODE_SET_METHOD(exports, "emitAsyncDestroy", EmitAsyncDestroy);
+  // NODE_SET_METHOD(exports, "openCallbackScope", OpenCallbackScope);
+  // NODE_SET_METHOD(exports, "closeCallbackScope", CloseCallbackScope);
+  NODE_SET_METHOD(exports, "makeCallback", MakeCallback);
+}
+
+}

package/src/napi.c

@@ -0,0 +1,130 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <node_api.h>
+
+#ifdef NDEBUG
+#define	NAPI_ASSERT(the_call) (the_call)
+#else
+#define NAPI_ASSERT(the_call) (assert(napi_ok == (the_call)))
+#endif
+
+static napi_value napi_async_init_js(napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  size_t argc = 2;
+  napi_async_context ctx;
+  napi_value ret;
+  napi_status status;
+  napi_value status_value, ret_value;
+  napi_valuetype type;
+  napi_value resource = NULL;
+  NAPI_ASSERT(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NAPI_ASSERT(napi_typeof(env, argv[0], &type));
+  if (type != napi_undefined && type != napi_null) {
+    resource = argv[0];
+  }
+  status = napi_async_init(env, resource, argv[1], &ctx);
+  NAPI_ASSERT(napi_create_object(env, &ret));
+  NAPI_ASSERT(napi_create_int32(env, status, &status_value));
+  NAPI_ASSERT(napi_create_bigint_int64(env, (int64_t) ctx, &ret_value));
+  NAPI_ASSERT(napi_set_named_property(env, ret, "status", status_value));
+  NAPI_ASSERT(napi_set_named_property(env, ret, "value", ret_value));
+  return ret;
+}
+
+static napi_value napi_async_destroy_js(napi_env env, napi_callback_info info) {
+  napi_value argv[1];
+  size_t argc = 1;
+  int64_t ctx;
+  napi_value ret;
+  napi_status status;
+  napi_value status_value, ret_value;
+  bool lossless;
+  NAPI_ASSERT(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NAPI_ASSERT(napi_get_value_bigint_int64(env, *argv, &ctx, &lossless));
+  status = napi_async_destroy(env, (napi_async_context) ctx);
+  NAPI_ASSERT(napi_create_object(env, &ret));
+  NAPI_ASSERT(napi_create_int32(env, status, &status_value));
+  NAPI_ASSERT(napi_get_undefined(env, &ret_value));
+  NAPI_ASSERT(napi_set_named_property(env, ret, "status", status_value));
+  NAPI_ASSERT(napi_set_named_property(env, ret, "value", ret_value));
+  return ret;
+}
+
+static napi_value napi_make_callback_js(napi_env env, napi_callback_info info) {
+  napi_value argv[4];
+  size_t argc = 4;
+  int64_t ctx = 0;
+  napi_value ret;
+  napi_status status;
+  napi_value status_value, ret_value;
+  bool lossless;
+  napi_value arr;
+  uint32_t len = 0;
+  napi_value* callback_argv = NULL;
+  napi_value err = NULL;
+
+  NAPI_ASSERT(napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+  NAPI_ASSERT(napi_get_value_bigint_int64(env, *argv, &ctx, &lossless));
+  arr = argv[3];
+  NAPI_ASSERT(napi_get_array_length(env, arr, &len));
+  if (len != 0) {
+    callback_argv = (napi_value*) malloc(len * sizeof(napi_value));
+  } 
+  for (uint32_t i = 0; i < len; ++i) {
+    NAPI_ASSERT(napi_get_element(env, arr, i, callback_argv + i));
+  }
+  NAPI_ASSERT(napi_get_and_clear_last_exception(env, &err));
+  err = NULL;
+  status = napi_make_callback(env, (napi_async_context) ctx, argv[1], argv[2], len, callback_argv, &ret_value);
+  if (callback_argv != NULL) {
+    free(callback_argv);
+  }
+  if (status == napi_pending_exception) {
+    NAPI_ASSERT(napi_get_and_clear_last_exception(env, &err));
+  }
+  NAPI_ASSERT(napi_create_object(env, &ret));
+  NAPI_ASSERT(napi_create_int32(env, status, &status_value));
+  NAPI_ASSERT(napi_set_named_property(env, ret, "status", status_value));
+  if (err != NULL) {
+    NAPI_ASSERT(napi_get_undefined(env, &ret_value));
+    NAPI_ASSERT(napi_set_named_property(env, ret, "value", ret_value));
+    NAPI_ASSERT(napi_set_named_property(env, ret, "error", err));
+  } else {
+    NAPI_ASSERT(napi_set_named_property(env, ret, "value", ret_value));
+  }
+  return ret;
+}
+
+/* static napi_value napi_open_callback_scope_js(napi_env env, napi_callback_info info) {
+  napi_value argv[2];
+  size_t argc = 2;
+  napi_get_cb_info(env, info, &argc, argv, NULL, NULL);
+  bool lossless;
+  int64_t ctx;
+  napi_get_value_bigint_int64(env, argv[1], &ctx, &lossless);
+  napi_callback_scope scope;
+  napi_open_callback_scope(env, argv[0], (napi_async_context) ctx, &scope);
+  napi_value ret;
+  napi_create_bigint_int64(env, (int64_t) scope, &ret);
+  return ret;
+} */
+
+NAPI_MODULE_INIT() {
+  napi_value ai;
+  NAPI_ASSERT(napi_create_function(env, "asyncInit", NAPI_AUTO_LENGTH, napi_async_init_js, NULL, &ai));
+  NAPI_ASSERT(napi_set_named_property(env, exports, "asyncInit", ai));
+
+  napi_value ad;
+  NAPI_ASSERT(napi_create_function(env, "asyncDestroy", NAPI_AUTO_LENGTH, napi_async_destroy_js, NULL, &ad));
+  NAPI_ASSERT(napi_set_named_property(env, exports, "asyncDestroy", ad));
+
+  napi_value mc;
+  NAPI_ASSERT(napi_create_function(env, "makeCallback", NAPI_AUTO_LENGTH, napi_make_callback_js, NULL, &mc));
+  NAPI_ASSERT(napi_set_named_property(env, exports, "makeCallback", mc));
+
+  /* napi_value ocs;
+  napi_create_function(env, "napiOpenCallbackScope", NAPI_AUTO_LENGTH, napi_open_callback_scope_js, NULL, &ocs);
+  napi_set_named_property(env, exports, "napiOpenCallbackScope", ocs); */
+
+  return exports;
+}