Add service binding support

worker-build/src/install.rs

@@ -35,7 +35,7 @@ pub fn ensure_wasm_pack() -> Result<()> {
     if is_installed("wasm-pack")?.is_none() {
         println!("Installing wasm-pack...");
         let exit_status = Command::new("cargo")
-            .args(&["install", "wasm-pack"])
+            .args(["install", "wasm-pack"])
             .spawn()?
             .wait()?;
 

worker-build/src/main.rs

@@ -49,9 +49,9 @@ where
     let exit_status = Command::new("wasm-pack")
         .arg("build")
         .arg("--no-typescript")
-        .args(&["--target", "bundler"])
-        .args(&["--out-dir", OUT_DIR])
-        .args(&["--out-name", OUT_NAME])
+        .args(["--target", "bundler"])
+        .args(["--out-dir", OUT_DIR])
+        .args(["--out-name", OUT_NAME])
         .args(args)
         .spawn()?
         .wait()?;
@@ -122,7 +122,7 @@ fn bundle(esbuild_path: &Path) -> Result<()> {
     let path = PathBuf::from(OUT_DIR).join(WORKER_SUBDIR).canonicalize()?;
     let esbuild_path = esbuild_path.canonicalize()?;
     let mut command = Command::new(esbuild_path);
-    command.args(&[
+    command.args([
         "--external:./index.wasm",
         "--format=esm",
         "--bundle",

worker-sandbox/remote-service/package.json

@@ -0,0 +1,3 @@
+{
+    "main": "./service.js"
+}

worker-sandbox/remote-service/service.js

@@ -0,0 +1,3 @@
+addEventListener('fetch', event => {
+    event.respondWith(new Response('hello world'))
+})

worker-sandbox/remote-service/wrangler.toml

@@ -0,0 +1,2 @@
+name = "remote-service"
+type = "javascript"

worker-sandbox/src/lib.rs

@@ -646,6 +646,17 @@ pub async fn main(req: Request, env: Env, _ctx: worker::Context) -> Result<Respo
                 Ok(resp)
             }
         })
+        .get_async("/remote-by-request", |req, ctx| async move {
+            let fetcher = ctx.service("remote")?;
+            fetcher.fetch_request(req).await
+        })
+        .get_async("/remote-by-path", |req, ctx| async move {
+            let fetcher = ctx.service("remote")?;
+            let mut init = RequestInit::new();
+            init.with_method(Method::Post);
+
+            fetcher.fetch(req.url()?.to_string(), Some(init)).await
+        })
         .or_else_any_method_async("/*catchall", |_, ctx| async move {
             console_log!(
                 "[or_else_any_method_async] caught: {}",

worker-sandbox/tests/requests.rs

@@ -469,3 +469,12 @@ fn cache_api() {
     let body: serde_json::Value = post(delete_endpoint.as_str(), |r| r).json().unwrap();
     assert_eq!("ResponseNotFound", body);
 }
+
+#[test]
+fn test_service_binding() {
+    let body: String = get("remote-by-request", |r| r).text().unwrap();
+    assert_eq!(body, "hello world");
+
+    let body: String = get("remote-by-path", |r| r).text().unwrap();
+    assert_eq!(body, "hello world");
+}

worker-sandbox/wrangler.toml

@@ -11,6 +11,13 @@ kv_namespaces = [
 
 vars = { SOME_VARIABLE = "some value" }
 
+[[services]]
+binding = "remote"
+service = "remote-service"
+
+[miniflare.mounts]
+remote-service = "./remote-service"
+
 [durable_objects]
 bindings = [{ name = "COUNTER", class_name = "Counter" }, { name = "ALARM", class_name = "AlarmObject" }]
 

worker/src/env.rs

@@ -1,6 +1,5 @@
 use crate::error::Error;
-use crate::Result;
-use crate::{durable::ObjectNamespace, DynamicDispatcher};
+use crate::{durable::ObjectNamespace, DynamicDispatcher, Fetcher, Result};
 
 use js_sys::Object;
 use wasm_bindgen::{prelude::*, JsCast, JsValue};
@@ -51,6 +50,12 @@ impl Env {
     pub fn dynamic_dispatcher(&self, binding: &str) -> Result<DynamicDispatcher> {
         self.get_binding(binding)
     }
+
+    /// Get a [Service Binding](https://developers.cloudflare.com/workers/runtime-apis/service-bindings/)
+    /// for Worker-to-Worker communication.
+    pub fn service(&self, binding: &str) -> Result<Fetcher> {
+        self.get_binding(binding)
+    }
 }
 
 pub trait EnvBinding: Sized + JsCast {

worker/src/fetcher.rs

@@ -1,20 +1,20 @@
-use wasm_bindgen::JsCast;
+use wasm_bindgen::{JsCast, JsValue};
 use wasm_bindgen_futures::JsFuture;
 use worker_sys::{Fetcher as FetcherSys, Response as ResponseSys};
 
-use crate::{Request, RequestInit, Response, Result};
+use crate::{env::EnvBinding, Request, RequestInit, Response, Result};
 
 /// A struct for invoking fetch events to other Workers.
 pub struct Fetcher(FetcherSys);
 
 impl Fetcher {
-    /// Invoke a fetch event in a worker with a path and optionally a [RequestInit].
+    /// Invoke a fetch event in a worker with a url and optionally a [RequestInit].
     pub async fn fetch(
         &self,
-        path: impl Into<String>,
+        url: impl Into<String>,
         init: Option<RequestInit>,
     ) -> Result<Response> {
-        let path = path.into();
+        let path = url.into();
         let promise = match init {
             Some(ref init) => self.0.fetch_with_str_and_init(&path, &init.into()),
             None => self.0.fetch_with_str(&path),
@@ -32,6 +32,36 @@ impl Fetcher {
     }
 }
 
+impl EnvBinding for Fetcher {
+    const TYPE_NAME: &'static str = "Fetcher";
+}
+
+impl JsCast for Fetcher {
+    fn instanceof(val: &wasm_bindgen::JsValue) -> bool {
+        val.is_instance_of::<Fetcher>()
+    }
+
+    fn unchecked_from_js(val: wasm_bindgen::JsValue) -> Self {
+        Self(val.into())
+    }
+
+    fn unchecked_from_js_ref(val: &wasm_bindgen::JsValue) -> &Self {
+        unsafe { &*(val as *const JsValue as *const Self) }
+    }
+}
+
+impl From<Fetcher> for JsValue {
+    fn from(service: Fetcher) -> Self {
+        JsValue::from(service.0)
+    }
+}
+
+impl AsRef<wasm_bindgen::JsValue> for Fetcher {
+    fn as_ref(&self) -> &wasm_bindgen::JsValue {
+        &self.0
+    }
+}
+
 impl From<FetcherSys> for Fetcher {
     fn from(inner: FetcherSys) -> Self {
         Self(inner)

worker/src/router.rs

@@ -10,7 +10,7 @@ use crate::{
     http::Method,
     request::Request,
     response::Response,
-    Result,
+    Fetcher, Result,
 };
 
 type HandlerFn<D> = fn(Request, RouteContext<D>) -> Result<Response>;
@@ -94,6 +94,12 @@ impl<D> RouteContext<D> {
     pub fn param(&self, key: &str) -> Option<&String> {
         self.params.get(key)
     }
+
+    /// Get a [Service Binding](https://developers.cloudflare.com/workers/runtime-apis/service-bindings/)
+    /// for Worker-to-Worker communication.
+    pub fn service(&self, binding: &str) -> Result<Fetcher> {
+        self.env.service(binding)
+    }
 }
 
 impl<'a> Router<'a, ()> {