DeferredPromise type wrapper

Author: jasnell

src/workerd/jsg/deferred-promise.h

@@ -1888,6 +1888,38 @@ inline DeferredPromiseResolverPair<T> newDeferredPromiseAndResolver() {
     .resolver = DeferredPromiseResolver<T>(kj::mv(stateRef))};
 }
 
+template <typename TypeWrapper>
+class DeferredPromiseWrapper {
+ public:
+  template <typename T>
+  static constexpr const char* getName(DeferredPromise<T>*) {
+    return "Promise";
+  }
+
+  template <typename T>
+  v8::Local<v8::Promise> wrap(jsg::Lock& js,
+      v8::Local<v8::Context> context,
+      kj::Maybe<v8::Local<v8::Object>> creator,
+      DeferredPromise<T>&& promise) {
+    auto& wrapper = *static_cast<TypeWrapper*>(this);
+    return wrapper.wrap(js, context, creator, promise.toJsPromise(js));
+  }
+
+  template <typename T>
+  kj::Maybe<DeferredPromise<T>> tryUnwrap(Lock& js,
+      v8::Local<v8::Context> context,
+      v8::Local<v8::Value> handle,
+      DeferredPromise<T>*,
+      kj::Maybe<v8::Local<v8::Object>> parentObject) {
+    auto& wrapper = *static_cast<TypeWrapper*>(this);
+    KJ_IF_SOME(jsPromise,
+        wrapper.tryUnwrap(js, context, handle, static_cast<Promise<T>*>(nullptr), parentObject)) {
+      return DeferredPromise<T>::fromJsPromise(js, kj::mv(jsPromise));
+    }
+    return kj::none;
+  }
+};
+
 // ======================================================================================
 // When NOT To Use DeferredPromise (Even For Pure C++ Code)
 // ======================================================================================

src/workerd/jsg/promise-test.c++

@@ -10,6 +10,7 @@ namespace {
 V8System v8System;
 
 int promiseTestResult = 0;
+int deferredPromiseTestResult = 0;
 kj::String catchTestResult;
 
 struct PromiseContext: public jsg::Object, public jsg::ContextGlobal {
@@ -98,6 +99,27 @@ struct PromiseContext: public jsg::Object, public jsg::ContextGlobal {
     return result;
   }
 
+  DeferredPromise<kj::String> makeDeferredPromise(jsg::Lock& js) {
+    auto [p, r] = js.newDeferredPromiseAndResolver<int>();
+    deferredResolver = kj::mv(r);
+    return p.then(js, [](jsg::Lock&, int i) { return i * 2; })
+        .then(js, [](jsg::Lock& js, int i) {
+      return jsg::DeferredPromise<int>::resolved(i + 2);
+    }).then(js, [](jsg::Lock& js, int i) { return kj::str(i); });
+  }
+
+  void deferredResolvePromise(Lock& js, int i) {
+    KJ_ASSERT_NONNULL(deferredResolver).resolve(js, kj::mv(i));
+  }
+
+  void setDeferredResult(jsg::Lock& js, DeferredPromise<kj::String> promise) {
+    // Throwing away the result of `.then()` doesn't cancel it!
+    promise
+        .then(js, [](jsg::Lock&, kj::String str) {
+      deferredPromiseTestResult = str.parseAs<int>();
+    }).then(js, [](jsg::Lock&) { deferredPromiseTestResult += 60000; });
+  }
+
   JSG_RESOURCE_TYPE(PromiseContext) {
     JSG_READONLY_PROTOTYPE_PROPERTY(promise, makePromise);
     JSG_METHOD(resolvePromise);
@@ -111,9 +133,14 @@ struct PromiseContext: public jsg::Object, public jsg::ContextGlobal {
     JSG_METHOD(whenResolved);
 
     JSG_METHOD(thenable);
+
+    JSG_READONLY_PROTOTYPE_PROPERTY(deferredPromise, makeDeferredPromise);
+    JSG_METHOD(deferredResolvePromise);
+    JSG_METHOD(setDeferredResult);
   }
 
   kj::Maybe<Promise<int>::Resolver> resolver;
+  kj::Maybe<DeferredPromise<int>::Resolver> deferredResolver;
 };
 JSG_DECLARE_ISOLATE_TYPE(PromiseIsolate, PromiseContext);
 
@@ -192,5 +219,19 @@ KJ_TEST("thenable") {
   e.expectEval("thenable({ then(res) { res(123) } })", "number", "123");
 }
 
+KJ_TEST("jsg::DeferredPromise<T>") {
+  Evaluator<PromiseContext, PromiseIsolate> e(v8System);
+
+  e.expectEval("setDeferredResult(deferredPromise.then(i => i + 1 /* oops, i is a string */));\n"
+               "deferredResolvePromise(123)",
+      "undefined", "undefined");
+
+  KJ_EXPECT(deferredPromiseTestResult == 0);
+
+  e.runMicrotasks();
+
+  KJ_EXPECT(deferredPromiseTestResult == 62481);
+}
+
 }  // namespace
 }  // namespace workerd::jsg::test

src/workerd/jsg/rtti.h

@@ -450,6 +450,13 @@ struct BuildRtti<Configuration, jsg::Promise<T>> {
   }
 };
 
+template <typename Configuration, typename T>
+struct BuildRtti<Configuration, jsg::DeferredPromise<T>> {
+  static void build(Type::Builder builder, Builder<Configuration>& rtti) {
+    BuildRtti<Configuration, T>::build(builder.initPromise().initValue(), rtti);
+  }
+};
+
 template <typename Configuration>
 struct BuildRtti<Configuration, v8::Promise> {
   static void build(Type::Builder builder, Builder<Configuration>& rtti) {

src/workerd/jsg/type-wrapper.h

@@ -401,6 +401,7 @@ class TypeWrapper: public DynamicResourceTypeMap<Self>,
                    public BufferSourceWrapper,
                    public FunctionWrapper<Self>,
                    public PromiseWrapper<Self>,
+                   public DeferredPromiseWrapper<Self>,
                    public NonCoercibleWrapper<Self>,
                    public MemoizedIdentityWrapper<Self>,
                    public IdentifiedWrapper<Self>,
@@ -464,6 +465,7 @@ class TypeWrapper: public DynamicResourceTypeMap<Self>,
   USING_WRAPPER(BufferSourceWrapper);
   USING_WRAPPER(FunctionWrapper<Self>);
   USING_WRAPPER(PromiseWrapper<Self>);
+  USING_WRAPPER(DeferredPromiseWrapper<Self>);
   USING_WRAPPER(NonCoercibleWrapper<Self>);
   USING_WRAPPER(MemoizedIdentityWrapper<Self>);
   USING_WRAPPER(IdentifiedWrapper<Self>);

src/workerd/tests/bench-deferred-promise.c++

@@ -14,7 +14,6 @@
 // 3. Pending with continuations - Setup overhead comparison
 // 4. Conversion to JS - Cost when you do need a V8 promise
 
-#include <workerd/jsg/deferred-promise.h>
 #include <workerd/jsg/jsg.h>
 #include <workerd/jsg/setup.h>
 #include <workerd/tests/bench-tools.h>