Comprehensive promise handling improvements for NJS and QuickJS engines

This commit significantly enhances promise handling across multiple areas:

- **Enhanced ngx_engine_njs_call() and ngx_engine_qjs_call()**: Added comprehensive
  promise state handling for fulfilled, rejected, and pending promises

- **Fulfilled promises**: Automatically extract resolved values
- **Rejected promises**: Log error
- **Pending promises**: Log errors when no waiting events exist, indicating stuck promises

- **Microtask queue protection**: Added iteration limit
  to prevent infinite microtask loops in both NJS and QuickJS engines
- **Event loop starvation prevention**: Protects against recursive promise chains that
  could monopolize the event loop indefinitely
- **Clear error reporting**: Logs specific messages when job queue limits are exceeded

- **js_promise_pending.t**: Tests pending promise detection and error logging
- **js_promise_rejected.t**: Validates rejected promise exception handling
- **js_promise_states.t**: Comprehensive promise state transition testing
- **js_infinite_loop_protection.t**: Validates microtask loop protection
- **Enhanced js_async.t**: Demonstrates async function integration with js_set
- **Updated stream_js.t**: Extended stream promise handling tests

- Async functions now work correctly with js_set directives, and other directives
  where syncronious result is expected
- Prevents nginx hangs from infinite microtask loops
- Maintains JavaScript exception semantics for rejected promises
- Provides clear error messages for debugging stuck promises
- Full compatibility with both NJS and QuickJS engines

This enables robust async/await patterns in nginx JavaScript while maintaining
stability and providing event loop protection.

Author: VadimZhestikov

nginx/ngx_js.c

@@ -10,6 +10,7 @@
 #include <ngx_core.h>
 #include <math.h>
 #include "ngx_js.h"
+#include <njs_main.h>
 
 
 typedef struct {
@@ -683,6 +684,9 @@ ngx_njs_clone(ngx_js_ctx_t *ctx, ngx_js_loc_conf_t *cf, void *external)
 }
 
 
+#define NJS_MAX_JOB_ITERATIONS 0x10000
+
+
 static ngx_int_t
 ngx_engine_njs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
     njs_opaque_value_t *args, njs_uint_t nargs)
@@ -716,6 +720,10 @@ ngx_engine_njs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
         return NGX_ERROR;
     }
 
+    /* Infinite loop protection: limit microtask queue processing. */
+    ngx_uint_t max_job_iterations = NJS_MAX_JOB_ITERATIONS;
+    ngx_uint_t job_count = 0;
+
     for ( ;; ) {
         ret = njs_vm_execute_pending_job(vm);
         if (ret <= NJS_OK) {
@@ -729,6 +737,35 @@ ngx_engine_njs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
 
             break;
         }
+
+        job_count++;
+        if (job_count >= max_job_iterations) {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
+                          "js job queue processing limit exceeded (%ui iterations), "
+                          "possible infinite loop in microtasks", max_job_iterations);
+            return NGX_ERROR;
+        }
+    }
+
+    /* Check if the value is a promise and handle its state. */
+    njs_value_t *val = njs_value_arg(&ctx->retval);
+    if (njs_is_promise(val)) {
+        njs_promise_t *promise = njs_promise(val);
+        njs_promise_data_t *promise_data = njs_data(&promise->value);
+
+        if (promise_data->state == NJS_PROMISE_FULFILL) {
+            *val = promise_data->result;
+
+        } else if (promise_data->state == NJS_PROMISE_REJECTED) {
+            njs_vm_throw(vm, &promise_data->result);
+
+        } else if (promise_data->state == NJS_PROMISE_PENDING &&
+                   njs_rbtree_is_empty(&ctx->waiting_events))
+        {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0, 
+                          "js promise pending, no jobs, no waiting_events");
+            return NGX_ERROR;
+        }
     }
 
     return njs_rbtree_is_empty(&ctx->waiting_events) ? NGX_OK : NGX_AGAIN;
@@ -754,8 +791,9 @@ ngx_engine_njs_string(ngx_engine_t *e, njs_opaque_value_t *value,
 {
     ngx_int_t  rc;
     njs_str_t  s;
+    njs_value_t *val = njs_value_arg(value);
 
-    rc = ngx_js_string(e->u.njs.vm, njs_value_arg(value), &s);
+    rc = ngx_js_string(e->u.njs.vm, val, &s);
 
     str->data = s.start;
     str->len = s.length;
@@ -1060,6 +1098,10 @@ ngx_engine_qjs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
 
     rt = JS_GetRuntime(cx);
 
+    /* Infinite loop protection: limit microtask queue processing. */
+    ngx_uint_t max_job_iterations = NJS_MAX_JOB_ITERATIONS;
+    ngx_uint_t job_count = 0;
+
     for ( ;; ) {
         rc = JS_ExecutePendingJob(rt, &cx1);
         if (rc <= 0) {
@@ -1074,6 +1116,38 @@ ngx_engine_qjs_call(ngx_js_ctx_t *ctx, ngx_str_t *fname,
 
             break;
         }
+
+        job_count++;
+        if (job_count >= max_job_iterations) {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0,
+                          "js job queue processing limit exceeded (%ui iterations), "
+                          "possible infinite loop in microtasks", max_job_iterations);
+            return NGX_ERROR;
+        }
+    }
+
+    /* Check if the value is a promise and handle its state. */
+    JSValue retval = ngx_qjs_arg(ctx->retval);
+    if (JS_IsObject(retval)) {
+        JSPromiseStateEnum state = JS_PromiseState(cx, retval);
+
+        if (state == JS_PROMISE_FULFILLED) {
+            JSValue result = JS_PromiseResult(cx, retval);
+            JS_FreeValue(cx, ngx_qjs_arg(ctx->retval));
+            ngx_qjs_arg(ctx->retval) = result;
+
+        } else if (state == JS_PROMISE_REJECTED) {
+            JSValue rejection = JS_PromiseResult(cx, retval);
+            JS_FreeValue(cx, ngx_qjs_arg(ctx->retval));
+            ngx_qjs_arg(ctx->retval) = JS_Throw(cx, rejection);
+
+        } else if (state == JS_PROMISE_PENDING &&
+                   njs_rbtree_is_empty(&ctx->waiting_events))
+        {
+            ngx_log_error(NGX_LOG_ERR, ctx->log, 0, 
+                          "js promise pending, no jobs, no waiting_events");
+            return NGX_ERROR;
+        }
     }
 
     return njs_rbtree_is_empty(&ctx->waiting_events) ? NGX_OK : NGX_AGAIN;
@@ -1098,7 +1172,9 @@ static ngx_int_t
 ngx_engine_qjs_string(ngx_engine_t *e, njs_opaque_value_t *value,
     ngx_str_t *str)
 {
-    return ngx_qjs_dump_obj(e, ngx_qjs_arg(*value), str);
+    JSValue val = ngx_qjs_arg(*value);
+
+    return ngx_qjs_dump_obj(e, val, str);
 }
 
 

nginx/t/js_async.t

@@ -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_promise_infinite_loop_protection.t

@@ -0,0 +1,146 @@
+#!/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 1000 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(6);
+
+###############################################################################
+
+# 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 limit exceeded') > 0, 
+   'job queue limit exceeded message logged');
+
+# Should mention possible infinite loop
+ok(index($error_log, 'possible infinite loop in microtasks') > 0, 
+   'infinite loop warning message logged');
+
+###############################################################################