Allow null name when creating dynamic workers

Author: ketanhwr

src/workerd/api/worker-loader-test.js

@@ -510,7 +510,21 @@ export let isolateUniqueness = {
     assert.strictEqual(await anonymousAgain.increment(), 2);
     assert.strictEqual(await anonymousAgain.increment(), 3);
 
-    assert.strictEqual(loadCount, 5);
+    // Test that null/undefined name parameter creates unique isolates each time
+    // Each call should generate a unique name internally.
+    let noName1 = env.loader.get(null, loadCodeCallback).getEntrypoint();
+    let noName2 = env.loader.get(undefined, loadCodeCallback).getEntrypoint();
+    let noName3 = env.loader.get(undefined, loadCodeCallback).getEntrypoint();
+
+    // Each should be a different isolate
+    assert.strictEqual(await noName1.increment(), 0);
+    assert.strictEqual(await noName1.increment(), 1);
+    assert.strictEqual(await noName2.increment(), 0);
+    assert.strictEqual(await noName2.increment(), 1);
+    assert.strictEqual(await noName3.increment(), 0);
+    assert.strictEqual(await noName3.increment(), 1);
+
+    assert.strictEqual(loadCount, 8);
   },
 };
 

src/workerd/api/worker-loader.c++

@@ -59,7 +59,7 @@ jsg::Ref<DurableObjectClass> WorkerStub::getDurableObjectClass(jsg::Lock& js,
 }
 
 jsg::Ref<WorkerStub> WorkerLoader::get(
-    jsg::Lock& js, kj::String name, jsg::Function<jsg::Promise<WorkerCode>()> getCode) {
+    jsg::Lock& js, kj::Maybe<kj::String> name, jsg::Function<jsg::Promise<WorkerCode>()> getCode) {
   auto& ioctx = IoContext::current();
 
   auto reenterAndGetCode = ioctx.makeReentryCallback(

src/workerd/api/worker-loader.h

@@ -125,7 +125,7 @@ class WorkerLoader: public jsg::Object {
   };
 
   jsg::Ref<WorkerStub> get(
-      jsg::Lock& js, kj::String name, jsg::Function<jsg::Promise<WorkerCode>()> getCode);
+      jsg::Lock& js, kj::Maybe<kj::String> name, jsg::Function<jsg::Promise<WorkerCode>()> getCode);
 
   JSG_RESOURCE_TYPE(WorkerLoader) {
     JSG_METHOD(get);

src/workerd/io/io-channels.h

@@ -245,11 +245,11 @@ class IoChannelFactory {
     KJ_UNIMPLEMENTED("Only implemented by single-tenant workerd runtime");
   }
 
-  // Use a dynamic Worker loader binding to obtain an Worker by name. If the named Worker
-  // doesn't already exist, the callback will be called to fetch the source code from which the
-  // Worker should be created.
+  // Use a dynamic Worker loader binding to obtain an Worker by name. If name is undefined, or if
+  // the named Worker doesn't already exist, the callback will be called to fetch the source code
+  // from which the Worker should be created.
   virtual kj::Own<WorkerStubChannel> loadIsolate(uint loaderChannel,
-      kj::String name,
+      kj::Maybe<kj::String> name,
       kj::Function<kj::Promise<DynamicWorkerSource>()> fetchSource) {
     JSG_FAIL_REQUIRE(Error, "Dynamic worker loading is not supported by this runtime.");
   }

src/workerd/server/server.c++

@@ -3321,7 +3321,7 @@ class Server::WorkerService final: public Service,
   }
 
   kj::Own<WorkerStubChannel> loadIsolate(uint loaderChannel,
-      kj::String name,
+      kj::Maybe<kj::String> name,
       kj::Function<kj::Promise<DynamicWorkerSource>()> fetchSource) override;
 
   // ---------------------------------------------------------------------------
@@ -3865,15 +3865,16 @@ class Server::WorkerLoaderNamespace: public kj::Refcounted {
   }
 
   kj::Own<WorkerStubChannel> loadIsolate(
-      kj::String name, kj::Function<kj::Promise<DynamicWorkerSource>()> fetchSource) {
+      kj::Maybe<kj::String> name, kj::Function<kj::Promise<DynamicWorkerSource>()> fetchSource) {
+    auto actualName = kj::mv(name).orDefault([] { return randomUUID(kj::none); });
     return isolates
-        .findOrCreate(name,
+        .findOrCreate(actualName,
             [&]() -> decltype(isolates)::Entry {
       // This name isn't actually used in any maps nor is it ever revealed back to the app, but it
       // may be used in error logs.
       auto isolateName = kj::str(namespaceName, ':', name);
 
-      return {.key = kj::mv(name),
+      return {.key = kj::mv(actualName),
         .value = kj::rc<WorkerStubImpl>(server, kj::mv(isolateName), kj::mv(fetchSource))};
     })
         .addRef()
@@ -4147,7 +4148,7 @@ void Server::unlinkWorkerLoaders() {
 }
 
 kj::Own<WorkerStubChannel> Server::WorkerService::loadIsolate(uint loaderChannel,
-    kj::String name,
+    kj::Maybe<kj::String> name,
     kj::Function<kj::Promise<DynamicWorkerSource>()> fetchSource) {
   auto& channels =
       KJ_REQUIRE_NONNULL(ioChannels.tryGet<LinkedIoChannels>(), "link() has not been called");

types/generated-snapshot/experimental/index.d.ts

@@ -4112,7 +4112,7 @@ interface WorkerStubEntrypointOptions {
 }
 interface WorkerLoader {
   get(
-    name: string,
+    name: string | null,
     getCode: () => WorkerLoaderWorkerCode | Promise<WorkerLoaderWorkerCode>,
   ): WorkerStub;
 }

types/generated-snapshot/experimental/index.ts

@@ -4125,7 +4125,7 @@ export interface WorkerStubEntrypointOptions {
 }
 export interface WorkerLoader {
   get(
-    name: string,
+    name: string | null,
     getCode: () => WorkerLoaderWorkerCode | Promise<WorkerLoaderWorkerCode>,
   ): WorkerStub;
 }

types/generated-snapshot/latest/index.d.ts

@@ -3832,7 +3832,7 @@ interface WorkerStubEntrypointOptions {
 }
 interface WorkerLoader {
   get(
-    name: string,
+    name: string | null,
     getCode: () => WorkerLoaderWorkerCode | Promise<WorkerLoaderWorkerCode>,
   ): WorkerStub;
 }

types/generated-snapshot/latest/index.ts

@@ -3843,7 +3843,7 @@ export interface WorkerStubEntrypointOptions {
 }
 export interface WorkerLoader {
   get(
-    name: string,
+    name: string | null,
     getCode: () => WorkerLoaderWorkerCode | Promise<WorkerLoaderWorkerCode>,
   ): WorkerStub;
 }