Updated Durable Object fetch method to be optional.

Author: spigaz

worker-build/src/js/durable_objects_shim.js

@@ -6,15 +6,14 @@ const globalStorePrefix = "__DO_WRAPPED_"; // For globalThis storage
 if (typeof __WORKER_BUILD_DO_NAMES__ !== 'undefined' && Array.isArray(__WORKER_BUILD_DO_NAMES__)) {
     __WORKER_BUILD_DO_NAMES__.forEach(className => {
         const OriginalClass = imports[className];
-        if (typeof OriginalClass === 'function' && OriginalClass.prototype && typeof OriginalClass.prototype.fetch === 'function') {
-            console.log(`[shim.js] Wrapping DO (identified by worker-build): ${className}`);
+        if (typeof OriginalClass === 'function' && OriginalClass.prototype) {
+            console.log(`[shim.js] Wrapping DO: ${className}`);
             successfullyWrappedDONames.push(className);
             const WrappedClass = class extends DurableObject {
                 constructor(state, env) { super(state, env); this._inner = new OriginalClass(state, env); }
-                async fetch(request) { return this._inner.fetch(request); }
             };
             Object.getOwnPropertyNames(OriginalClass.prototype).forEach(methodName => {
-                if (methodName !== 'constructor' && methodName !== 'fetch') {
+                if (methodName !== 'constructor') {
                     if (typeof OriginalClass.prototype[methodName] === 'function') {
                         WrappedClass.prototype[methodName] = function(...args) { return this._inner[methodName](...args); };
                     }

worker-macros/src/durable_object.rs

@@ -23,6 +23,7 @@ pub fn expand_macro(tokens: TokenStream) -> syn::Result<TokenStream> {
             #[derive(Default)]
             struct OptionalMethods {
                 has_alarm: bool,
+                has_fetch: bool,
                 has_websocket_message: bool,
                 has_websocket_close: bool,
                 has_websocket_error: bool,
@@ -75,6 +76,8 @@ pub fn expand_macro(tokens: TokenStream) -> syn::Result<TokenStream> {
                         })
                     },
                     "fetch" => {
+                        optional_methods.has_fetch = true;
+
                         let mut method = impl_method.clone();
                         method.sig.ident = Ident::new("_fetch_raw", method.sig.ident.span());
                         method.vis = Visibility::Inherited;
@@ -219,6 +222,12 @@ pub fn expand_macro(tokens: TokenStream) -> syn::Result<TokenStream> {
                 tokenized.push(tokens?);
             }
 
+            let fetch = optional_methods.has_fetch.then(|| quote!{
+                async fn fetch(&mut self, req: ::worker::Request) -> ::worker::Result<worker::Response> {
+                    self._fetch_raw(req).await
+                }
+            });
+
             let alarm_tokens = optional_methods.has_alarm.then(|| quote! {
                 async fn alarm(&mut self) -> ::worker::Result<worker::Response> {
                     self._alarm_raw().await
@@ -255,9 +264,7 @@ pub fn expand_macro(tokens: TokenStream) -> syn::Result<TokenStream> {
                         Self::_new(state._inner(), env)
                     }
 
-                    async fn fetch(&mut self, req: ::worker::Request) -> ::worker::Result<worker::Response> {
-                        self._fetch_raw(req).await
-                    }
+                    #fetch
 
                     #alarm_tokens
 

worker/src/durable.rs

@@ -814,7 +814,9 @@ impl DurableObject for Chatroom {
 pub trait DurableObject {
     fn new(state: State, env: Env) -> Self;
 
-    async fn fetch(&mut self, req: Request) -> Result<Response>;
+    async fn fetch(&mut self, _req: Request) -> Result<Response> {
+        unimplemented!("fetch() handler not implemented")
+    }
 
     #[allow(clippy::diverging_sub_expression)]
     async fn alarm(&mut self) -> Result<Response> {