Modules: improved handling of results of async handlers.

Previously, r.setReturnValue() had to be used when returning a value from async js_set handler.

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    r.setReturnValue(Buffer.from(hash).toString('hex'));
}

Now r.setReturnValue() is not needed:

async function hash(r) {
    let hash = await crypto.subtle.digest('SHA-512', r.headersIn.host);
    return Buffer.from(hash).toString('hex');
}

In addition added:
    infinite microtask loops detection,
    promise handling in global qjs code.

Author: VadimZhestikov

nginx/ngx_js.c

@@ -158,7 +158,8 @@ typedef struct {
     njs_opaque_value_t     retval;                                            \
     njs_arr_t             *rejected_promises;                                 \
     njs_rbtree_t           waiting_events;                                    \
-    ngx_socket_t           event_id
+    ngx_socket_t           event_id;                                          \
+    ngx_int_t              broken
 
 
 #define ngx_js_add_event(ctx, event)                                          \

nginx/ngx_js.h

@@ -35,9 +35,10 @@ events {
 http {
     %%TEST_GLOBALS_HTTP%%
 
-    js_set $test_async      test.set_timeout;
-    js_set $context_var     test.context_var;
-    js_set $test_set_rv_var test.set_rv_var;
+    js_set $test_async       test.set_timeout;
+    js_set $context_var      test.context_var;
+    js_set $test_set_rv_var  test.set_rv_var;
+    js_set $test_promise_var test.set_promise_var;
 
     js_import test.js;
 
@@ -85,6 +86,10 @@ http {
             return 200 $test_set_rv_var;
         }
 
+        location /promise_var {
+            return 200 $test_promise_var;
+        }
+
         location /await_reject {
             js_content test.await_reject;
         }
@@ -198,6 +203,13 @@ $t->write_file('test.js', <<EOF);
         r.setReturnValue(`retval: \${a1 + a2}`);
     }
 
+    async function set_promise_var(r) {
+        const a1 = await pr(10);
+        const a2 = await pr(20);
+
+        return `retval: \${a1 + a2}`;
+    }
+
     async function timeout(ms) {
         return new Promise((resolve, reject) => {
             setTimeout(() => {
@@ -213,11 +225,11 @@ $t->write_file('test.js', <<EOF);
 
     export default {njs:test_njs, set_timeout, set_timeout_data,
                     set_timeout_many, context_var, shared_ctx, limit_rate,
-                    async_content, set_rv_var, await_reject};
+                    async_content, set_rv_var, set_promise_var, await_reject};
 
 EOF
 
-$t->try_run('no njs available')->plan(10);
+$t->try_run('no njs available')->plan(11);
 
 ###############################################################################
 
@@ -229,6 +241,7 @@ like(http_get('/limit_rate'), qr/A{50}/, 'limit_rate');
 
 like(http_get('/async_content'), qr/retval: AB/, 'async content');
 like(http_get('/set_rv_var'), qr/retval: 30/, 'set return value variable');
+like(http_get('/promise_var'), qr/retval: 30/, 'fulfilled promise variable');
 
 http_get('/async_var');
 http_get('/await_reject');

nginx/t/js_async.t

@@ -0,0 +1,142 @@
+#!/usr/bin/perl
+
+# (C) Test for infinite loop protection in microtask queue processing
+
+# Tests for proper handling of infinite microtask loops similar to Node.js protection.
+
+###############################################################################
+
+use warnings;
+use strict;
+
+use Test::More;
+
+BEGIN { use FindBin; chdir($FindBin::Bin); }
+
+use lib 'lib';
+use Test::Nginx;
+
+###############################################################################
+
+select STDERR; $| = 1;
+select STDOUT; $| = 1;
+
+my $t = Test::Nginx->new()->has(qw/http rewrite/)
+	->write_file_expand('nginx.conf', <<'EOF');
+
+%%TEST_GLOBALS%%
+
+daemon off;
+
+events {
+}
+
+http {
+    %%TEST_GLOBALS_HTTP%%
+
+    js_import test.js;
+
+    server {
+        listen       127.0.0.1:8080;
+        server_name  localhost;
+
+        location /njs {
+            js_content test.njs;
+        }
+
+        location /infinite_microtasks {
+            js_content test.infinite_microtasks;
+        }
+
+        location /recursive_promises {
+            js_content test.recursive_promises;
+        }
+
+        location /normal_promise_chain {
+            js_content test.normal_promise_chain;
+        }
+
+    }
+}
+
+EOF
+
+$t->write_file('test.js', <<'EOF');
+    function test_njs(r) {
+        r.return(200, njs.version);
+    }
+
+    function infinite_microtasks(r) {
+        // Create an infinite microtask loop - should trigger protection limit
+        function infiniteLoop() {
+            return Promise.resolve().then(() => {
+                // Recursively create more microtasks
+                return infiniteLoop();
+            });
+        }
+
+        return infiniteLoop();
+    }
+
+    function recursive_promises(r) {
+        // Another variation of infinite microtask generation
+        let count = 0;
+        function createPromise() {
+            return new Promise((resolve) => {
+                resolve();
+            }).then(() => {
+                count++;
+                // Keep creating more promises indefinitely
+                return createPromise();
+            });
+        }
+
+        return createPromise();
+    }
+
+    function normal_promise_chain(r) {
+        // Normal promise chain that should complete without hitting the limit
+        let result = Promise.resolve(1);
+
+        // Create a reasonable chain of 50 promises (well under the NGX_MAX_JOB_ITERATIONS limit)
+        for (let i = 0; i < 50; i++) {
+            result = result.then((value) => value + 1);
+        }
+
+        return result.then((finalValue) => {
+            r.return(200, "completed with value: " + finalValue);
+        });
+    }
+
+    export default {njs: test_njs, infinite_microtasks, recursive_promises, normal_promise_chain};
+
+EOF
+
+$t->try_run('no njs available')->plan(5);
+
+###############################################################################
+
+# Test basic functionality
+like(http_get('/njs'), qr/\d+\.\d+\.\d+/, 'njs version');
+
+# Test normal promise chain (should work - under the limit)
+like(http_get('/normal_promise_chain'), qr/completed with value: 51/, 'normal promise chain completes');
+
+# Test infinite microtasks scenario - should trigger protection limit
+my $infinite_response = http_get('/infinite_microtasks');
+like($infinite_response, qr/HTTP\/1\.[01] 500|Internal Server Error/, 'infinite microtasks causes error');
+
+# Test recursive promises scenario - should also trigger protection limit  
+my $recursive_response = http_get('/recursive_promises');
+like($recursive_response, qr/HTTP\/1\.[01] 500|Internal Server Error/, 'recursive promises causes error');
+
+$t->stop();
+
+# Check error log for the specific infinite loop protection messages
+my $error_log = $t->read_file('error.log');
+
+# Should have error messages for job queue limit exceeded
+ok(index($error_log, 'js job queue processing exceeded') > 0, 
+   'job queue limit exceeded message logged');
+
+###############################################################################

nginx/t/js_promise_infinite_jobs.t

@@ -0,0 +1,122 @@
+#!/usr/bin/perl
+
+# (C) Test for NJS promise pending state handling
+
+# Tests for proper handling of pending promises with no waiting events.
+
+###############################################################################
+
+use warnings;
+use strict;
+
+use Test::More;
+
+BEGIN { use FindBin; chdir($FindBin::Bin); }
+
+use lib 'lib';
+use Test::Nginx;
+
+###############################################################################
+
+select STDERR; $| = 1;
+select STDOUT; $| = 1;
+
+my $t = Test::Nginx->new()->has(qw/http rewrite/)
+	->write_file_expand('nginx.conf', <<'EOF');
+
+%%TEST_GLOBALS%%
+
+daemon off;
+
+events {
+}
+
+http {
+    %%TEST_GLOBALS_HTTP%%
+
+    js_import test.js;
+
+    server {
+        listen       127.0.0.1:8080;
+        server_name  localhost;
+
+        location /njs {
+            js_content test.njs;
+        }
+
+        location /promise_never_resolves {
+            js_content test.promise_never_resolves;
+        }
+
+        location /promise_with_timeout {
+            js_content test.promise_with_timeout;
+        }
+
+
+    }
+}
+
+EOF
+
+$t->write_file('test.js', <<'EOF');
+    function test_njs(r) {
+        r.return(200, njs.version);
+    }
+
+    function promise_never_resolves(r) {
+        // Create a promise that never resolves and has no pending events
+        // This should trigger the condition:
+        // promise_data->state == NJS_PROMISE_PENDING && 
+        // njs_rbtree_is_empty(&ctx->waiting_events)
+        return new Promise((resolve, reject) => {
+            // Intentionally never call resolve or reject
+            // No setTimeout, no async operations - truly pending with no events
+        });
+    }
+
+    function promise_with_timeout(r) {
+        // Create a promise with a timeout (has waiting events)
+        const p = new Promise((resolve, reject) => {
+            setTimeout(() => {
+                resolve("timeout resolved");
+            }, 10);
+        });
+
+        // This should NOT trigger pending error because there are waiting events
+        return p.then((value) => {
+            r.return(200, "resolved: " + value);
+        });
+    }
+
+    export default {njs: test_njs, promise_never_resolves, promise_with_timeout};
+
+EOF
+
+$t->try_run('no njs available')->plan(5);
+
+###############################################################################
+
+# Test basic functionality
+like(http_get('/njs'), qr/\d+\.\d+\.\d+/, 'njs version');
+
+# Test promise with timeout (should work - has waiting events) 
+like(http_get('/promise_with_timeout'), qr/resolved: timeout resolved/, 'promise with timeout resolves');
+
+# Test pending promise scenario - should trigger error response
+# because it returns a promise that will never resolve with no waiting events
+my $never_resolves_response = http_get('/promise_never_resolves');
+like($never_resolves_response, qr/HTTP\/1\.[01] 500|Internal Server Error/, 'never resolving promise causes error');
+
+$t->stop();
+
+# Check error log for the specific pending promise error message
+my $error_log = $t->read_file('error.log');
+
+# Now that we use ngx_log_error, the specific error message should appear in the log
+ok(index($error_log, 'js promise pending, no jobs, no waiting_events') > 0, 
+   'pending promise error message logged');
+
+# Should have no error for promises with waiting events
+unlike($error_log, qr/js exception.*timeout resolved/, 'no error for promise with waiting events');
+
+###############################################################################