feat(Request.signal) Initial support for signal in Request + fetch and Request + Bun.serve

packages/bun-types/globals.d.ts

@@ -1056,8 +1056,6 @@ declare class Request implements BlobInterface {
   readonly referrerPolicy: ReferrerPolicy;
   /**
    * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
-   *
-   * Note: this is **not implemented yet**. The cake is a lie.
    */
   readonly signal: AbortSignal;
 

src/bun.js/bindings/ZigGeneratedClasses.cpp

@@ -6201,6 +6201,9 @@ JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__referrerGetterWrap);
 extern "C" JSC::EncodedJSValue RequestPrototype__getReferrerPolicy(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
 JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__referrerPolicyGetterWrap);
 
+extern "C" JSC::EncodedJSValue RequestPrototype__getSignal(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(RequestPrototype__signalGetterWrap);
+
 extern "C" EncodedJSValue RequestPrototype__getText(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
 JSC_DECLARE_HOST_FUNCTION(RequestPrototype__textCallback);
 
@@ -6227,6 +6230,7 @@ static const HashTableValue JSRequestPrototypeTableValues[] = {
     { "redirect"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__redirectGetterWrap, 0 } },
     { "referrer"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerGetterWrap, 0 } },
     { "referrerPolicy"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__referrerPolicyGetterWrap, 0 } },
+    { "signal"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__signalGetterWrap, 0 } },
     { "text"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::NativeFunctionType, RequestPrototype__textCallback, 0 } },
     { "url"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute | PropertyAttribute::DontDelete), NoIntrinsic, { HashTableValue::GetterSetterType, RequestPrototype__urlGetterWrap, 0 } }
 };
@@ -6507,6 +6511,37 @@ JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__referrerPolicyGetterWrap, (JSGlobalOb
     RELEASE_AND_RETURN(throwScope, result);
 }
 
+JSC_DEFINE_CUSTOM_GETTER(RequestPrototype__signalGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSRequest* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+
+    if (JSValue cachedValue = thisObject->m_signal.get())
+        return JSValue::encode(cachedValue);
+
+    JSC::JSValue result = JSC::JSValue::decode(
+        RequestPrototype__getSignal(thisObject->wrapped(), globalObject));
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_signal.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+
+extern "C" void RequestPrototype__signalSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject* globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+    thisObject->m_signal.set(vm, thisObject, JSValue::decode(value));
+}
+
+extern "C" EncodedJSValue RequestPrototype__signalGetCachedValue(JSC::EncodedJSValue thisValue)
+{
+    auto* thisObject = jsCast<JSRequest*>(JSValue::decode(thisValue));
+    return JSValue::encode(thisObject->m_signal.get());
+}
+
 JSC_DEFINE_HOST_FUNCTION(RequestPrototype__textCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
 {
     auto& vm = lexicalGlobalObject->vm();
@@ -6720,6 +6755,7 @@ void JSRequest::visitChildrenImpl(JSCell* cell, Visitor& visitor)
     }
     visitor.append(thisObject->m_body);
     visitor.append(thisObject->m_headers);
+    visitor.append(thisObject->m_signal);
     visitor.append(thisObject->m_url);
 }
 
@@ -6733,6 +6769,7 @@ void JSRequest::visitAdditionalChildren(Visitor& visitor)
 
     visitor.append(thisObject->m_body);
     visitor.append(thisObject->m_headers);
+    visitor.append(thisObject->m_signal);
     visitor.append(thisObject->m_url);
     ;
 }

src/bun.js/bindings/ZigGeneratedClasses.h

@@ -618,6 +618,7 @@ class JSRequest final : public JSC::JSDestructibleObject {
 
     mutable JSC::WriteBarrier<JSC::Unknown> m_body;
     mutable JSC::WriteBarrier<JSC::Unknown> m_headers;
+    mutable JSC::WriteBarrier<JSC::Unknown> m_signal;
     mutable JSC::WriteBarrier<JSC::Unknown> m_url;
 };
 

src/bun.js/bindings/bindings.cpp

@@ -3796,6 +3796,18 @@ extern "C" void JSC__JSGlobalObject__queueMicrotaskJob(JSC__JSGlobalObject* arg0
         JSC::JSValue::decode(JSValue4));
 }
 
+
+extern "C" JSC__JSValue JSC__AbortSignal__create(JSC__JSGlobalObject* globalObject) {
+    Zig::GlobalObject* thisObject = JSC::jsCast<Zig::GlobalObject*>(globalObject);
+    return JSC::JSValue::encode(WebCore::JSAbortSignal::getConstructor(JSC::getVM(globalObject), thisObject));
+}
+extern "C" JSC__JSValue JSC__AbortSignal__toJS(JSC__AbortSignal* arg0, JSC__JSGlobalObject* globalObject) {
+    WebCore::AbortSignal* abortSignal = reinterpret_cast<WebCore::AbortSignal*>(arg0);
+
+    return JSValue::encode(toJS<IDLInterface<JSC__AbortSignal>>(*globalObject, *jsCast<JSDOMGlobalObject*>(globalObject), *abortSignal));
+}
+
+
 extern "C" JSC__AbortSignal* JSC__AbortSignal__signal(JSC__AbortSignal* arg0, JSC__JSValue JSValue1) {
     WebCore::AbortSignal* abortSignal = reinterpret_cast<WebCore::AbortSignal*>(arg0);
     abortSignal->signalAbort(JSC::JSValue::decode(JSValue1));
@@ -3824,6 +3836,10 @@ extern "C" JSC__AbortSignal* JSC__AbortSignal__unref(JSC__AbortSignal* arg0) {
     abortSignal->deref();
     return arg0;
 }
+extern "C" void JSC__AbortSignal__cleanNativeBindings(JSC__AbortSignal* arg0, void* arg1) {
+    WebCore::AbortSignal* abortSignal = reinterpret_cast<WebCore::AbortSignal*>(arg0);
+    abortSignal->cleanNativeBindings(arg1);
+}
 
 extern "C" JSC__AbortSignal* JSC__AbortSignal__addListener(JSC__AbortSignal* arg0, void* ctx, void (*callback)(void* ctx, JSC__JSValue reason)) {
     WebCore::AbortSignal* abortSignal = reinterpret_cast<WebCore::AbortSignal*>(arg0);
@@ -3891,6 +3907,7 @@ extern "C" JSC__JSValue JSC__AbortSignal__createTimeoutError(const ZigString* me
 
     return JSC::JSValue::encode(error);
 }
+
 #pragma mark - WebCore::DOMFormData
 
 CPP_DECL void WebCore__DOMFormData__append(WebCore__DOMFormData* arg0, ZigString* arg1, ZigString* arg2)

src/bun.js/bindings/bindings.zig

@@ -1697,6 +1697,11 @@ pub const AbortSignal = extern opaque {
     ) *AbortSignal {
         return cppFn("addListener", .{ this, ctx, callback });
     }
+
+    pub fn cleanNativeBindings(this: *AbortSignal, ctx: ?*anyopaque) void {
+        return cppFn("cleanNativeBindings", .{ this, ctx });
+    }
+
     pub fn signal(
         this: *AbortSignal,
         reason: JSValue,
@@ -1728,6 +1733,14 @@ pub const AbortSignal = extern opaque {
         return cppFn("fromJS", .{value});
     }
 
+    pub fn toJS(this: *AbortSignal, global: *JSGlobalObject) JSValue {
+        return cppFn("toJS", .{this, global});
+    }
+
+    pub fn create(global: *JSGlobalObject) JSValue {
+        return cppFn("create", .{ global });
+    }
+
     pub fn createAbortError(message: *const ZigString, code: *const ZigString, global: *JSGlobalObject) JSValue {
         return cppFn("createAbortError", .{ message, code, global });
     }
@@ -1739,13 +1752,16 @@ pub const AbortSignal = extern opaque {
     pub const Extern = [_][]const u8{
         "createAbortError",
         "createTimeoutError",
+        "create",
         "ref",
         "unref",
         "signal",
         "abortReason",
         "aborted",
         "addListener",
         "fromJS",
+        "toJS",
+        "cleanNativeBindings"
     };
 };
 
@@ -3544,7 +3560,7 @@ pub const JSValue = enum(JSValueReprInt) {
         status,
         url,
         body,
-        data,
+        data
     };
 
     // intended to be more lightweight than ZigString

src/bun.js/bindings/generated_classes.zig

@@ -1680,6 +1680,28 @@ pub const JSRequest = struct {
         return result;
     }
 
+    extern fn RequestPrototype__signalSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    extern fn RequestPrototype__signalGetCachedValue(JSC.JSValue) JSC.JSValue;
+
+    /// `Request.signal` setter
+    /// This value will be visited by the garbage collector.
+    pub fn signalSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        RequestPrototype__signalSetCachedValue(thisValue, globalObject, value);
+    }
+
+    /// `Request.signal` getter
+    /// This value will be visited by the garbage collector.
+    pub fn signalGetCached(thisValue: JSC.JSValue) ?JSC.JSValue {
+        JSC.markBinding(@src());
+        const result = RequestPrototype__signalGetCachedValue(thisValue);
+        if (result == .zero)
+            return null;
+
+        return result;
+    }
+
     extern fn RequestPrototype__urlSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
 
     extern fn RequestPrototype__urlGetCachedValue(JSC.JSValue) JSC.JSValue;
@@ -1799,6 +1821,9 @@ pub const JSRequest = struct {
         if (@TypeOf(Request.getReferrerPolicy) != GetterType)
             @compileLog("Expected Request.getReferrerPolicy to be a getter");
 
+        if (@TypeOf(Request.getSignal) != GetterType)
+            @compileLog("Expected Request.getSignal to be a getter");
+
         if (@TypeOf(Request.getText) != CallbackType)
             @compileLog("Expected Request.getText to be a callback but received " ++ @typeName(@TypeOf(Request.getText)));
         if (@TypeOf(Request.getUrl) != GetterType)
@@ -1825,6 +1850,7 @@ pub const JSRequest = struct {
             @export(Request.getRedirect, .{ .name = "RequestPrototype__getRedirect" });
             @export(Request.getReferrer, .{ .name = "RequestPrototype__getReferrer" });
             @export(Request.getReferrerPolicy, .{ .name = "RequestPrototype__getReferrerPolicy" });
+            @export(Request.getSignal, .{ .name = "RequestPrototype__getSignal" });
             @export(Request.getText, .{ .name = "RequestPrototype__getText" });
             @export(Request.getUrl, .{ .name = "RequestPrototype__getUrl" });
         }

src/bun.js/bindings/headers-cpp.h

@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1676656020
+//-- AUTOGENERATED FILE -- 1676922916
 // clang-format off
 #pragma once
 

src/bun.js/bindings/headers.h

@@ -1,5 +1,5 @@
 // clang-format off
-//-- AUTOGENERATED FILE -- 1676656020
+//-- AUTOGENERATED FILE -- 1676922916
 #pragma once
 
 #include <stddef.h>
@@ -210,11 +210,14 @@ CPP_DECL JSC__JSInternalPromise* JSC__JSModuleLoader__loadAndEvaluateModule(JSC_
 CPP_DECL bool JSC__AbortSignal__aborted(JSC__AbortSignal* arg0);
 CPP_DECL JSC__JSValue JSC__AbortSignal__abortReason(JSC__AbortSignal* arg0);
 CPP_DECL JSC__AbortSignal* JSC__AbortSignal__addListener(JSC__AbortSignal* arg0, void* arg1, void(* ArgFn2)(void* arg0, JSC__JSValue JSValue1)) __attribute__((nonnull (2)));
+CPP_DECL void JSC__AbortSignal__cleanNativeBindings(JSC__AbortSignal* arg0, void* arg1);
+CPP_DECL JSC__JSValue JSC__AbortSignal__create(JSC__JSGlobalObject* arg0);
 CPP_DECL JSC__JSValue JSC__AbortSignal__createAbortError(const ZigString* arg0, const ZigString* arg1, JSC__JSGlobalObject* arg2);
 CPP_DECL JSC__JSValue JSC__AbortSignal__createTimeoutError(const ZigString* arg0, const ZigString* arg1, JSC__JSGlobalObject* arg2);
 CPP_DECL JSC__AbortSignal* JSC__AbortSignal__fromJS(JSC__JSValue JSValue0);
 CPP_DECL JSC__AbortSignal* JSC__AbortSignal__ref(JSC__AbortSignal* arg0);
 CPP_DECL JSC__AbortSignal* JSC__AbortSignal__signal(JSC__AbortSignal* arg0, JSC__JSValue JSValue1);
+CPP_DECL JSC__JSValue JSC__AbortSignal__toJS(JSC__AbortSignal* arg0, JSC__JSGlobalObject* arg1);
 CPP_DECL JSC__AbortSignal* JSC__AbortSignal__unref(JSC__AbortSignal* arg0);
 
 #pragma mark - JSC::JSPromise

src/bun.js/bindings/headers.zig

@@ -138,11 +138,14 @@ pub extern fn JSC__JSModuleLoader__loadAndEvaluateModule(arg0: *bindings.JSGloba
 pub extern fn JSC__AbortSignal__aborted(arg0: ?*bindings.AbortSignal) bool;
 pub extern fn JSC__AbortSignal__abortReason(arg0: ?*bindings.AbortSignal) JSC__JSValue;
 pub extern fn JSC__AbortSignal__addListener(arg0: ?*bindings.AbortSignal, arg1: ?*anyopaque, ArgFn2: ?*const fn (?*anyopaque, JSC__JSValue) callconv(.C) void) ?*bindings.AbortSignal;
+pub extern fn JSC__AbortSignal__cleanNativeBindings(arg0: ?*bindings.AbortSignal, arg1: ?*anyopaque) void;
+pub extern fn JSC__AbortSignal__create(arg0: *bindings.JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__AbortSignal__createAbortError(arg0: [*c]const ZigString, arg1: [*c]const ZigString, arg2: *bindings.JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__AbortSignal__createTimeoutError(arg0: [*c]const ZigString, arg1: [*c]const ZigString, arg2: *bindings.JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__AbortSignal__fromJS(JSValue0: JSC__JSValue) ?*bindings.AbortSignal;
 pub extern fn JSC__AbortSignal__ref(arg0: ?*bindings.AbortSignal) ?*bindings.AbortSignal;
 pub extern fn JSC__AbortSignal__signal(arg0: ?*bindings.AbortSignal, JSValue1: JSC__JSValue) ?*bindings.AbortSignal;
+pub extern fn JSC__AbortSignal__toJS(arg0: ?*bindings.AbortSignal, arg1: *bindings.JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__AbortSignal__unref(arg0: ?*bindings.AbortSignal) ?*bindings.AbortSignal;
 pub extern fn JSC__JSPromise__asValue(arg0: ?*bindings.JSPromise, arg1: *bindings.JSGlobalObject) JSC__JSValue;
 pub extern fn JSC__JSPromise__create(arg0: *bindings.JSGlobalObject) ?*bindings.JSPromise;

src/bun.js/bindings/webcore/AbortSignal.cpp

@@ -115,6 +115,15 @@ void AbortSignal::signalAbort(JSC::JSValue reason)
     dispatchEvent(Event::create(eventNames().abortEvent, Event::CanBubble::No, Event::IsCancelable::No));
 }
 
+void AbortSignal::cleanNativeBindings(void* ref) {
+    auto callbacks = std::exchange(m_native_callbacks, {});
+
+    callbacks.removeLastMatching([=](auto callback){
+        const auto [ ctx, func ] = callback;
+        return ctx == ref;
+    });
+}
+
 // https://dom.spec.whatwg.org/#abortsignal-follow
 void AbortSignal::signalFollow(AbortSignal& signal)
 {

src/bun.js/bindings/webcore/AbortSignal.h

@@ -65,6 +65,7 @@ class AbortSignal final : public RefCounted<AbortSignal>, public EventTargetWith
 
     using Algorithm = Function<void(JSValue)>;
     void addAlgorithm(Algorithm&& algorithm) { m_algorithms.append(WTFMove(algorithm)); }
+    void cleanNativeBindings(void* ref);
     void addNativeCallback(std::tuple<void*, void (*)(void*, JSC::EncodedJSValue)> callback) { m_native_callbacks.append(callback); }
 
     bool isFollowingSignal() const { return !!m_followingSignal; }

src/bun.js/webcore/request.zig

@@ -12,6 +12,7 @@ const js = JSC.C;
 
 const Method = @import("../../http/method.zig").Method;
 const FetchHeaders = JSC.FetchHeaders;
+const AbortSignal = JSC.AbortSignal;
 const ObjectPool = @import("../../pool.zig").ObjectPool;
 const SystemError = JSC.SystemError;
 const Output = @import("bun").Output;
@@ -57,6 +58,7 @@ pub const Request = struct {
     url_was_allocated: bool = false,
 
     headers: ?*FetchHeaders = null,
+    signal: ?*AbortSignal = null,
     body: Body.Value = Body.Value{ .Empty = {} },
     method: Method = Method.GET,
     uws_request: ?*uws.Request = null,
@@ -217,6 +219,21 @@ pub const Request = struct {
         return ZigString.Empty.toValueGC(globalThis);
     }
 
+    pub fn getSignal(this: *Request, globalThis: *JSC.JSGlobalObject) callconv(.C) JSC.JSValue {
+        // Already have an C++ instance
+        if(this.signal) |signal| {
+            return signal.toJS(globalThis);
+        } else {
+            //Lazy create default signal
+            const js_signal = AbortSignal.create(globalThis);
+            js_signal.ensureStillAlive();
+            if (AbortSignal.fromJS(js_signal)) |signal| {
+                this.signal = signal;
+            }
+            return js_signal;
+        }
+    } 
+
     pub fn getMethod(
         this: *Request,
         globalThis: *JSC.JSGlobalObject,
@@ -254,6 +271,10 @@ pub const Request = struct {
         }
 
         this.body.deinit();
+        if(this.signal) |signal| {
+           _ = signal.unref();
+           this.signal = null;
+        }
 
         bun.default_allocator.destroy(this);
     }
@@ -415,6 +436,22 @@ pub const Request = struct {
                     }
                 }
 
+                if (arguments[1].get(globalThis, "signal")) |signal_| {
+                    if (AbortSignal.fromJS(signal_)) |signal| {
+                        //Keep it alive
+                        signal_.ensureStillAlive();
+                        request.signal = signal;
+                        _ = signal.ref();
+
+                    } else {
+                        if (request.headers) |head| {
+                            head.deref();
+                        }
+
+                        return null;
+                    }
+                }
+
                 request.url = (arguments[0].toSlice(globalThis, bun.default_allocator).cloneIfNeeded(bun.default_allocator) catch {
                     return null;
                 }).slice();
@@ -506,6 +543,11 @@ pub const Request = struct {
             req.headers = FetchHeaders.createFromUWS(globalThis, uws_req);
             this.headers = req.headers.?.cloneThis(globalThis).?;
         }
+
+        if(this.signal) |signal| {
+            _ = signal.ref();
+            req.signal = signal;
+        }
     }
 
     pub fn clone(this: *Request, allocator: std.mem.Allocator, globalThis: *JSGlobalObject) *Request {

src/bun.js/webcore/response.classes.ts

@@ -55,6 +55,10 @@ export default [
       bodyUsed: {
         getter: "getBodyUsed",
       },
+      signal: {
+        getter: "getSignal",
+        cache: true,
+      },
     },
   }),
   define({