JSRPC: Service bindings and stateless class syntax

src/cloudflare/internal/workers.d.ts

@@ -0,0 +1,13 @@
+export class DurableObject {
+  public constructor(ctx: unknown, env: unknown);
+
+  public ctx: unknown;
+  public env: unknown;
+}
+
+export class WorkerEntrypoint {
+  public constructor(ctx: unknown, env: unknown);
+
+  public ctx: unknown;
+  public env: unknown;
+}

src/cloudflare/workers.ts

@@ -0,0 +1,11 @@
+// Copyright (c) 2024 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+// TODO(cleanup): C++ built-in modules do not yet support named exports, so we must define this
+//   wrapper module that simply re-exports the classes from the built-in module.
+
+import entrypoints from 'cloudflare-internal:workers';
+
+export const WorkerEntrypoint = entrypoints.WorkerEntrypoint;
+export const DurableObject = entrypoints.DurableObject;

src/workerd/api/global-scope.h

@@ -255,12 +255,21 @@ struct ExportedHandler {
   // Values to pass for `env` and `ctx` when calling handlers. Note these have to be the last members
   // so that they don't interfere with `JSG_STRUCT`'s machinations.
 
+  // env and ctx values that need to be passed to the handler function. If the ExportedHandler
+  // represents a class instance (e.g. Durable Object instance), then `env` is is the JS value
+  // `undefined` and `ctx` is `kj::none`.
+  // TODO(cleanup): Why isn't `env` a `jsg::Optional` too? Or maybe the pair should be wrapped in
+  //   a struct that is `Maybe`?
   jsg::Value env = nullptr;
   jsg::Optional<jsg::Ref<ExecutionContext>> ctx = kj::none;
   // TODO(cleanup): These are shoved here as a bit of a hack. At present, this is convenient and
   //   works for all use cases. If we have bindings or things on ctx that vary on a per-request basis,
   //   this won't work as well, I guess, but we can cross that bridge when we come to it.
 
+  // If true, this is a Durable Object class that failed to extend `DurableObject`. We will not
+  // permit RPC to this class.
+  bool missingSuperclass = false;
+
   jsg::Optional<jsg::Ref<ExecutionContext>> getCtx() {
     return ctx.map([&](jsg::Ref<ExecutionContext>& p) { return p.addRef(); });
   }

src/workerd/api/http.h

@@ -560,6 +560,9 @@ class Fetcher: public jsg::Object {
       const v8::FunctionCallbackInfo<v8::Value>& info)>;
 
   kj::Maybe<RpcFunction> getRpcMethod(jsg::Lock& js, kj::StringPtr name);
+  kj::Maybe<RpcFunction> getRpcMethodForTestOnly(jsg::Lock& js, kj::String name) {
+    return getRpcMethod(js, name);
+  }
 
   JSG_RESOURCE_TYPE(Fetcher, CompatibilityFlags::Reader flags) {
     // WARNING: New JSG_METHODs on Fetcher must be gated via compatibility flag to prevent
@@ -587,6 +590,11 @@ class Fetcher: public jsg::Object {
 
     if (flags.getWorkerdExperimental()) {
       JSG_WILDCARD_PROPERTY(getRpcMethod);
+
+      // We export a copy of getRpcMethod for use in tests only which allows the caller to provide
+      // an arbitrary string as the method name. This allows invoking methods that would normally
+      // be shadowed by non-wildcard methods.
+      JSG_METHOD(getRpcMethodForTestOnly);
     }
 
     JSG_TS_OVERRIDE({

src/workerd/api/modules.h

@@ -10,6 +10,7 @@
 #include <workerd/api/rtti.h>
 #include <workerd/api/sockets.h>
 #include <workerd/api/unsafe.h>
+#include <workerd/api/worker-rpc.h>
 #include <workerd/io/worker.h>
 #include <cloudflare/cloudflare.capnp.h>
 
@@ -28,6 +29,7 @@ void registerModules(Registry& registry, auto featureFlags) {
   }
   registerSocketsModule(registry, featureFlags);
   registry.addBuiltinBundle(CLOUDFLARE_BUNDLE);
+  registerRpcModules(registry, featureFlags);
 }
 
 }  // namespace workerd::api

src/workerd/api/tests/js-rpc-flag.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2023 Cloudflare, Inc.
+// Licensed under the Apache 2.0 license found in the LICENSE file or at:
+//     https://opensource.org/licenses/Apache-2.0
+
+import assert from 'node:assert';
+
+// This class does not extend `DurableObject`, but because we have the `js_rpc` compat flag on,
+// it'll still accept RPC.
+export class DurableObjectExample {
+  constructor() {}
+
+  foo() {
+    return 123;
+  }
+}
+
+export default {
+  async test(ctrl, env, ctx) {
+    let id = env.ns.idFromName("foo");
+    let obj = env.ns.get(id);
+    assert.strictEqual(await obj.foo(), 123);
+  }
+}
+

src/workerd/api/tests/js-rpc-disabled.wd-test → src/workerd/api/tests/js-rpc-flag.wd-test

@@ -9,10 +9,10 @@ const config :Workerd.Config = (
 
 const mainWorker :Workerd.Worker = (
   compatibilityDate = "2022-09-16",
-  compatibilityFlags = ["experimental", "nodejs_compat"],
+  compatibilityFlags = ["experimental", "nodejs_compat", "js_rpc"],
 
   modules = [
-    (name = "worker", esModule = embed "js-rpc-disabled.js"),
+    (name = "worker", esModule = embed "js-rpc-flag.js"),
   ],
 
   durableObjectNamespaces = [