support remote module loading

Author: robherley

Cargo.toml

@@ -28,6 +28,7 @@ deno_web = "0.245.0"
 deno_webidl = "0.214.0"
 http = "1.3.1"
 rand = "0.9.2"
+reqwest = "0.12.23"
 rustls = "0.23.28"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"

crates/funcgg-runtime/Cargo.toml

@@ -23,6 +23,7 @@ deno_url = { workspace = true }
 deno_web = { workspace = true }
 deno_webidl = { workspace = true }
 http = { workspace = true }
+reqwest = { workspace = true }
 rustls = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/funcgg-runtime/src/js/worker.js

@@ -1,15 +1,19 @@
 async function resolveHandler() {
   const mod = await import("func:user-code");
 
-  if (typeof mod.handler === "function") {
-    return mod.handler;
-  }
+  const methods = ["fetch", "handler"];
+
+  for (const method of methods) {
+    if (typeof mod[method] === "function") {
+      return mod[method];
+    }
 
-  if (
-    typeof mod.default === "object" &&
-    typeof mod.default.handler === "function"
-  ) {
-    return mod.default.handler;
+    if (
+      typeof mod.default === "object" &&
+      typeof mod.default[method] === "function"
+    ) {
+      return mod.default[method];
+    }
   }
 
   if (typeof mod.default === "function") {

crates/funcgg-runtime/src/loader.rs

@@ -1,15 +1,26 @@
+use std::borrow::Cow;
+use std::time::Duration;
+
 use deno_ast::{MediaType, ParseParams};
 use deno_core::{
-    ModuleCodeString, ModuleLoadResponse, ModuleName, ModuleSpecifier, SourceMapData,
-    error::ModuleLoaderError,
+    ModuleCodeString, ModuleLoadResponse, ModuleName, ModuleSource, ModuleSourceCode,
+    ModuleSpecifier, ModuleType, SourceMapData, error::ModuleLoaderError, futures::FutureExt,
 };
 use deno_error::JsErrorBox;
 
-pub struct ModuleLoader;
+pub struct ModuleLoader {
+    http_client: reqwest::Client,
+}
 
 impl ModuleLoader {
     pub fn new() -> Self {
-        Self {}
+        let http_client = reqwest::Client::builder()
+            .connect_timeout(Duration::from_secs(10))
+            .user_agent("func.gg/module_loader")
+            .build()
+            .expect("Unable to build HTTP client");
+
+        Self { http_client }
     }
 }
 
@@ -26,15 +37,87 @@ impl deno_core::ModuleLoader for ModuleLoader {
 
     fn load(
         &self,
-        module_specifier: &ModuleSpecifier,
+        specifier: &ModuleSpecifier,
         _maybe_referrer: Option<&ModuleSpecifier>,
-        _is_dynamic: bool,
+        is_dyn_import: bool,
         _requested_module_type: deno_core::RequestedModuleType,
-    ) -> deno_core::ModuleLoadResponse {
-        tracing::error!("attempting to load module: {}", module_specifier);
-        ModuleLoadResponse::Sync(Err(ModuleLoaderError::generic(
-            "module loading is not supported",
-        )))
+    ) -> ModuleLoadResponse {
+        if is_dyn_import {
+            return ModuleLoadResponse::Sync(Err(ModuleLoaderError::generic(
+                "dynamic module loading is not supported",
+            )));
+        }
+
+        if specifier.scheme() != "https" {
+            return ModuleLoadResponse::Sync(Err(ModuleLoaderError::generic(
+                "only modules with an 'https' scheme are supported",
+            )));
+        }
+
+        let specifier = specifier.clone();
+        let http_client = self.http_client.clone();
+        return ModuleLoadResponse::Async(
+            async move {
+                let res = http_client
+                    .get(specifier.clone())
+                    .query(&[("target", "deno")]) // tells services to explicitly redirect
+                    .send()
+                    .await
+                    .map_err(|err| ModuleLoaderError::generic(err.to_string()))?;
+
+                let original_specifier = {
+                    let mut url = specifier.clone();
+                    url.set_query(None);
+                    url
+                };
+
+                let found_specifier = {
+                    let mut url = res.url().clone();
+                    url.set_query(None);
+                    url
+                };
+
+                let content_type = res
+                    .headers()
+                    .get("content-type")
+                    .map(|ct| ct.to_str().unwrap_or_default())
+                    .unwrap_or_default()
+                    .split(';')
+                    .next()
+                    .unwrap_or_default()
+                    .trim()
+                    .to_lowercase();
+                let module_type = match content_type.as_ref() {
+                    "application/javascript"
+                    | "text/javascript"
+                    | "application/ecmascript"
+                    | "text/ecmascript" => ModuleType::JavaScript,
+                    "application/wasm" => ModuleType::Wasm,
+                    "application/json" | "text/json" => ModuleType::Json,
+                    "text/plain" | "application/octet-stream" => ModuleType::Text,
+                    s => ModuleType::Other(Cow::Owned(s.to_string())),
+                };
+
+                if !res.status().is_success() {
+                    return Err(ModuleLoaderError::generic("failed to load module"));
+                }
+
+                // TODO: probably use bytes
+                let src_text = res
+                    .text()
+                    .await
+                    .map_err(|err| ModuleLoaderError::generic(err.to_string()))?;
+
+                return Ok(ModuleSource::new_with_redirect(
+                    module_type,
+                    ModuleSourceCode::String(src_text.into()),
+                    &original_specifier,
+                    &found_specifier,
+                    None,
+                ));
+            }
+            .boxed_local(),
+        );
     }
 }
 

crates/funcgg-worker/examples/hono.js

@@ -0,0 +1,7 @@
+import { Hono } from "https://esm.sh/hono";
+
+const app = new Hono();
+
+app.get("/", (c) => c.text("Hello World"));
+
+export default app;

crates/funcgg-worker/src/routes.rs

@@ -17,7 +17,17 @@ use crate::pool::Pool;
 pub async fn invoke(State(pool): State<Arc<Pool>>, request: Request) -> Response {
     // TODO: temporary, eventually this should be served dynamically
     // possibly serve https://github.com/denoland/eszip
-    let js_code = include_str!("../examples/basic.js");
+    let js_code = match tokio::fs::read_to_string("crates/funcgg-worker/examples/basic.js").await {
+        Ok(code) => code,
+        Err(err) => {
+            tracing::error!("Failed to load JavaScript code: {}", err);
+            return (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Failed to load handler code",
+            )
+                .into_response();
+        }
+    };
 
     let method = request.method().to_string();
     let path_and_query = request.uri().path_and_query().unwrap().to_owned();