Trying to solve more issues from nodejs.

Author: viferga

.github/workflows/docker-hub.yml

@@ -8,6 +8,7 @@ on:
   push:
     branches:
       - master
+      - develop
     tags:
       - 'v*.*.*'
 
@@ -44,9 +45,6 @@ jobs:
             bash ./docker-compose.sh push
           elif [[ "${{ contains(github.ref, 'refs/tags/') }}" = true ]]; then
             bash ./docker-compose.sh version
-          else
-            echo "Failed to push the docker images"
-            exit 1
           fi
 
       - name: Logout from DockerHub

source/loaders/node_loader/bootstrap/lib/bootstrap.js

@@ -6,26 +6,29 @@ const path = require('path');
 const util = require('util');
 const fs = require('fs');
 
-/* Require the JavaScript parser */
+// Require the JavaScript parser
 const espree = require(path.join(__dirname, 'node_modules', 'espree'));
 
 const node_require = Module.prototype.require;
 const node_resolve = require.resolve;
 const node_cache = require.cache;
 
-/* Store in the module prototype the original functions for future use in derived loaders like TypeScript */
+// Store in the module prototype the original functions for future use in derived loaders like TypeScript
 Module.prototype.node_require = node_require;
 Module.prototype.node_resolve = node_resolve;
 Module.prototype.node_cache = node_cache;
 
 function node_loader_trampoline_initialize(loader_library_path) {
+	// Restore the argv (this is used for tricking node::Start method)
+	process.argv = [ process.argv[0] ];
+
 	// Add current execution directory to the execution paths
 	node_loader_trampoline_execution_path(process.cwd());
 
 	const paths = [
-		/* Local version of MetaCall NodeJS Port */
+		// Local version of MetaCall NodeJS Port
 		'metacall',
-		/* Optionally, use loader library path for global installed NodeJS Port */
+		// Optionally, use loader library path for global installed NodeJS Port
 		...loader_library_path ? [ path.join(loader_library_path, 'node_modules', 'metacall', 'index.js') ] : [],
 	];
 
@@ -333,7 +336,7 @@ function node_loader_trampoline_discover(handle) {
 }
 
 function node_loader_trampoline_test(obj) {
-	/* Imporant: never trigger an async resource in this function */
+	// Imporant: never trigger an async resource in this function
 	if (obj !== undefined) {
 		fs.writeSync(process.stdout.fd, `${util.inspect(obj, false, null, true)}\n`);
 	}
@@ -411,7 +414,7 @@ module.exports = ((impl, ptr) => {
 			throw new Error('Process arguments (process.argv[2], process.argv[3]) not defined.');
 		}
 
-		/* Get trampoline from list of linked bindings */
+		// Get trampoline from list of linked bindings
 		const trampoline = process._linkedBinding('node_loader_trampoline_module');
 
 		const node_loader_ptr = trampoline.register(impl, ptr, {

source/loaders/node_loader/source/node_loader_impl.cpp

@@ -99,9 +99,15 @@ extern char **environ;
 	#pragma GCC diagnostic ignored "-Wstrict-aliasing"
 #endif
 
-#include <node.h>
+/* NodeJS Includes */
 #include <node_api.h>
 
+#ifdef NAPI_VERSION
+	#undef NAPI_VERSION
+#endif
+
+#include <node.h>
+
 #include <v8.h> /* version: 6.2.414.50 */
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
@@ -650,7 +656,7 @@ struct loader_impl_async_handle_promise_safe_type
 	loader_impl_async_handle_promise_safe_type(loader_impl_node node_impl, napi_env env) :
 		node_impl(node_impl), env(env), result(NULL) {}
 
-	~loader_impl_async_handle_promise_safe_type()
+	void destroy()
 	{
 		threadsafe_async.close([](uv_handle_t *handle) {
 			loader_impl_async_handle_promise_safe_type *handle_promise_safe = static_cast<loader_impl_async_handle_promise_safe_type *>(handle->data);
@@ -659,6 +665,8 @@ struct loader_impl_async_handle_promise_safe_type
 			{
 				metacall_value_destroy(handle_promise_safe->result);
 			}
+
+			delete handle_promise_safe;
 		});
 	}
 };
@@ -772,6 +780,40 @@ static HMODULE (*get_module_handle_a_ptr)(_In_opt_ LPCSTR) = NULL; /* TODO: Impl
 
 /* -- Methods -- */
 
+#if 1 // NODE_MAJOR_VERSION < 18
+	#if NODE_MAJOR_VERSION >= 12
+		#define node_loader_impl_register_module_id node::ModuleFlags::kLinked
+	#else
+		#define node_loader_impl_register_module_id 0x02 /* NM_F_LINKED */
+	#endif
+
+	#define node_loader_impl_register_module(name, fn) \
+		do \
+		{ \
+			static napi_module node_loader_module = { \
+				NAPI_MODULE_VERSION, \
+				node_loader_impl_register_module_id, \
+				__FILE__, \
+				fn, \
+				name, \
+				NULL, \
+				{ 0 } \
+			}; \
+			napi_module_register(&node_loader_module); \
+		} while (0)
+
+void node_loader_impl_register_linked_bindings()
+{
+	/* Initialize Node Loader Trampoline */
+	node_loader_impl_register_module("node_loader_trampoline_module", node_loader_trampoline_initialize);
+
+	/* Initialize Node Loader Port */
+	node_loader_impl_register_module("node_loader_port_module", node_loader_port_initialize);
+}
+#else
+// TODO: New register implementation
+#endif
+
 void node_loader_impl_exception(napi_env env, napi_status status)
 {
 	if (status != napi_ok)
@@ -3385,7 +3427,7 @@ void node_loader_impl_handle_promise_safe(napi_env env, loader_impl_async_handle
 	}
 
 	/* Close the handle */
-	delete handle_promise_safe;
+	handle_promise_safe->destroy();
 
 	/* Close scope */
 	status = napi_close_handle_scope(env, handle_scope);
@@ -3445,6 +3487,7 @@ void *node_loader_impl_register(void *node_impl_ptr, void *env_ptr, void *functi
 	napi_value function_table_object;
 	napi_value global;
 	napi_status status;
+	napi_handle_scope handle_scope;
 
 	/* Lock node implementation mutex */
 	uv_mutex_lock(&node_impl->mutex);
@@ -3456,6 +3499,11 @@ void *node_loader_impl_register(void *node_impl_ptr, void *env_ptr, void *functi
 	env = static_cast<napi_env>(env_ptr);
 	function_table_object = static_cast<napi_value>(function_table_object_ptr);
 
+	/* Create scope */
+	status = napi_open_handle_scope(env, &handle_scope);
+
+	node_loader_impl_exception(env, status);
+
 	/* Make global object persistent */
 	status = napi_get_global(env, &global);
 
@@ -3548,6 +3596,11 @@ void *node_loader_impl_register(void *node_impl_ptr, void *env_ptr, void *functi
 	get_module_handle_a_ptr = (HMODULE(*)(_In_opt_ LPCSTR))node_loader_hook_import_address_table("kernel32.dll", "GetModuleHandleA", &get_module_handle_a_hook);
 #endif
 
+	/* Close scope */
+	status = napi_close_handle_scope(env, handle_scope);
+
+	node_loader_impl_exception(env, status);
+
 	/* Signal start condition */
 	uv_cond_signal(&node_impl->cond);
 
@@ -3780,9 +3833,15 @@ void node_loader_impl_thread(void *data)
 	#endif
 	*/
 
+	// #if NODE_MAJOR_VERSION < 18
+	node_loader_impl_register_linked_bindings();
+	// #endif
+
 	/* Unlock node implementation mutex */
 	uv_mutex_unlock(&node_impl->mutex);
 
+	/* Register bindings for versions older than 18 */
+
 	/* Start NodeJS runtime */
 	int result = node::Start(argc, reinterpret_cast<char **>(argv));
 
@@ -3824,44 +3883,6 @@ loader_impl_data node_loader_impl_initialize(loader_impl impl, configuration con
 
 	(void)impl;
 
-	/* Initialize Node Loader Trampoline */
-	{
-		static napi_module node_loader_trampoline_module = {
-			NAPI_MODULE_VERSION,
-#if NODE_MAJOR_VERSION >= 12
-			node::ModuleFlags::kLinked,
-#else
-			0x02, /* NM_F_LINKED */
-#endif
-			__FILE__,
-			node_loader_trampoline_initialize,
-			"node_loader_trampoline_module",
-			NULL,
-			{ 0 }
-		};
-
-		napi_module_register(&node_loader_trampoline_module);
-	}
-
-	/* Initialize Node Loader Port */
-	{
-		static napi_module node_loader_port_module = {
-			NAPI_MODULE_VERSION,
-#if NODE_MAJOR_VERSION >= 12
-			node::ModuleFlags::kLinked,
-#else
-			0x02, /* NM_F_LINKED */
-#endif
-			__FILE__,
-			node_loader_port_initialize,
-			"node_loader_port_module",
-			NULL,
-			{ 0 }
-		};
-
-		napi_module_register(&node_loader_port_module);
-	}
-
 	node_impl = new loader_impl_node_type();
 
 	if (node_impl == nullptr)

source/tests/metacall_node_python_await_extended_test/source/metacall_node_python_await_extended_test.cpp

@@ -46,8 +46,11 @@ TEST_F(metacall_node_python_await_extended_test, DefaultConstructor)
 			/* Python */
 			"import sys\n"
 			"import threading\n"
+			"counter = 0\n"
 			"async def python_simple(n):\n"
-			"\tprint('inside python_simple', threading.current_thread().ident, ':', n)\n"
+			"\tglobal counter\n"
+			"\tprint('inside python_simple', threading.current_thread().ident, counter, ':', n)\n"
+			"\tcounter = counter + 1\n"
 			"\tsys.stdout.flush()\n"
 			"\treturn n\n"
 			// "import asyncio\n"