feat: Add Dynamic Backends support

Dynamic Backends allows JavaScript projects to dynamically create new backend server definitions without having to deploy a new version of their Fastly Service. These backends function exactly as existing backends, and will _eventually_ be configurable in all the same ways as existing backends can via the Fastly Service defintion.

The way I've implemented this feature is to have it only enabled when the property `fastly.allowDynamicBackends` is set to `true`. The reason for that is to try to make it a bit more obvious that Dynamic Backends is not the default approach for a fetch.  (It's not the default approach as it can be a potential avenue for third-party JavaScript code within a project to send requests, potentially including sensitive/secret data, off to destinations that the JavaScript project was not intending, which could be a security issue.) The implementation of the property `fastly.allowDynamicBackends` doesn’t _yet_ gain any security advantages because a third-party dependency has access to the `fastly` global variable and can set `fastly.allowDynamicBackends = true` — there would be a security advantage when we have support for ES Modules and can then limit this property to only be writable from the top-level script and readable from other ES Modules.

There are two ways to make use of Dynamic Backends within JavaScript projects.
The first way is by omitting the `backend` property definition on the Request instance. The JavaScript Runtime will then create a Dynamic Backend definition using default configuration options. This approach is useful for JavaScript applications as it means that a standard `fetch` call will now be possible, which means libraries that use `fetch` should just work 🥳.

E.G:
```js
// Enable dynamic backends -- warning, this is potentially dangerous as third-party dependencies could make requests to their own backends, potentially including your sensitive/secret data
fastly.allowDynamicBackends = true;

// For any request, return the fastly homepage -- without defining a backend!
addEventListener("fetch", event => {
  event.respondWith(fetch('https://www.fastly.com/'));
});
```

The second way is by creating a new Dynamic Backend using the JavaScript `Backend` class. This approach is useful for JavaScript applications that want to have control over the configuration of the new backend defintion, such as only allowing TLS 1.3 and disallowing older versions of TLS. The `Backend` class has a `toString` implementation which will return it's name, this means it can be attached to a Request instance.
E.G.
```js
// Enable dynamic backends -- warning, this is potentially dangerous as third-party dependencies could make requests to their own backends, potentially including your sensitive/secret data
fastly.allowDynamicBackends = true;

// For any request, return the fastly homepage -- without defining a backend!
addEventListener("fetch", event => {
  // We are defining all the possible fields here but any number of fields can be defined - the ones which are not defined will use their default value instead.
  const backend = new Backend({
    name: 'fastly',
    target: 'fastly.com',
    hostOverride: "www.fastly.com",
    connectTimeout: 1000,
    firstByteTimeout: 15000,
    betweenBytesTimeout: 10000,
    useSsl: true,
    sslMinVersion: 1.3,
    sslMaxVersion: 1.3,
    certificateHostname: "www.fastly.com",
    checkCertificate: true,
    caCertificate: `-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----`,
    // Colon-delimited list of permitted SSL Ciphers
    ciphers: "TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256:!RC4",
    sniHostname: "www.fastly.com",
  });
  event.respondWith(fetch('https://www.fastly.com/', {
    backend // Here we are configuring this request to use the dynamically define backend from above.
  }));
});
```

Author: Jake Champion

c-dependencies/js-compute-runtime/builtins/backend.cpp

@@ -0,0 +1,47 @@
+#ifndef JS_COMPUTE_RUNTIME_BACKEND_H
+#define JS_COMPUTE_RUNTIME_BACKEND_H
+
+#include "builtin.h"
+
+namespace builtins {
+
+class Backend : public BuiltinImpl<Backend> {
+private:
+public:
+  static constexpr const char *class_name = "Backend";
+  static const int ctor_length = 1;
+  enum Slots {
+    Name,
+    Target,
+    HostOverride,
+    ConnectTimeout,
+    FirstByteTimeout,
+    BetweenBytesTimeout,
+    UseSsl,
+    TlsMinVersion,
+    TlsMaxVersion,
+    CertificateHostname,
+    CaCertificate,
+    Ciphers,
+    SniHostname,
+    Count
+  };
+
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+
+  static JSString *name(JSContext *cx, JSObject *self);
+  static JS::Result<mozilla::Ok> register_dynamic_backend(JSContext *cx, JS::HandleObject request);
+  static JSObject *create(JSContext *cx, JS::HandleObject request);
+  static bool set_target(JSContext *cx, JSObject *backend, JS::HandleValue target_val);
+  static bool set_host_override(JSContext *cx, JSObject *backend, JS::HandleValue hostOverride_val);
+  static bool set_name(JSContext *cx, JSObject *backend, JS::HandleValue name_val);
+  static bool toString(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool constructor(JSContext *cx, unsigned argc, JS::Value *vp);
+
+  static bool init_class(JSContext *cx, JS::HandleObject global);
+};
+
+} // namespace builtins
+
+#endif

c-dependencies/js-compute-runtime/builtins/backend.h

@@ -12,6 +12,7 @@
 #include "builtins/fastly.h"
 #include "builtins/logger.h"
 #include "geo_ip.h"
+#include "host_call.h"
 
 namespace builtins {
 
@@ -21,6 +22,7 @@ JS::PersistentRooted<JSObject *> Fastly::env;
 
 JS::PersistentRooted<JSObject *> Fastly::baseURL;
 JS::PersistentRooted<JSString *> Fastly::defaultBackend;
+bool Fastly::allowDynamicBackends = false;
 
 bool Fastly::dump(JSContext *cx, unsigned argc, JS::Value *vp) {
   JS::CallArgs args = CallArgsFromVp(argc, vp);
@@ -179,10 +181,26 @@ bool Fastly::defaultBackend_set(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
+bool Fastly::allowDynamicBackends_get(JSContext *cx, unsigned argc, JS::Value *vp) {
+  JS::CallArgs args = CallArgsFromVp(argc, vp);
+  args.rval().setBoolean(allowDynamicBackends);
+  return true;
+}
+
+bool Fastly::allowDynamicBackends_set(JSContext *cx, unsigned argc, JS::Value *vp) {
+  JS::CallArgs args = CallArgsFromVp(argc, vp);
+  allowDynamicBackends = JS::ToBoolean(args.get(0));
+  args.rval().setUndefined();
+  return true;
+}
+
 const JSPropertySpec Fastly::properties[] = {
     JS_PSG("env", env_get, JSPROP_ENUMERATE),
     JS_PSGS("baseURL", baseURL_get, baseURL_set, JSPROP_ENUMERATE),
-    JS_PSGS("defaultBackend", defaultBackend_get, defaultBackend_set, JSPROP_ENUMERATE), JS_PS_END};
+    JS_PSGS("defaultBackend", defaultBackend_get, defaultBackend_set, JSPROP_ENUMERATE),
+    JS_PSGS("allowDynamicBackends", allowDynamicBackends_get, allowDynamicBackends_set,
+            JSPROP_ENUMERATE),
+    JS_PS_END};
 
 bool Fastly::create(JSContext *cx, JS::HandleObject global) {
   JS::RootedObject fastly(cx, JS_NewPlainObject(cx));

c-dependencies/js-compute-runtime/builtins/fastly.cpp

@@ -18,6 +18,7 @@ class Fastly : public BuiltinNoConstructor<Fastly> {
 
   static JS::PersistentRooted<JSObject *> baseURL;
   static JS::PersistentRooted<JSString *> defaultBackend;
+  static bool allowDynamicBackends;
 
   static const JSFunctionSpec methods[];
   static const JSPropertySpec properties[];
@@ -32,6 +33,8 @@ class Fastly : public BuiltinNoConstructor<Fastly> {
   static bool baseURL_set(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool defaultBackend_get(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool defaultBackend_set(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool allowDynamicBackends_get(JSContext *cx, unsigned argc, JS::Value *vp);
+  static bool allowDynamicBackends_set(JSContext *cx, unsigned argc, JS::Value *vp);
   static bool create(JSContext *cx, JS::HandleObject global);
 };
 

c-dependencies/js-compute-runtime/builtins/fastly.h

@@ -58,4 +58,26 @@ MSG_DEF(JSMSG_OBJECT_STORE_PUT_CONTENT_STREAM,                 0, JSEXN_TYPEERR,
 MSG_DEF(JSMSG_OBJECT_STORE_PUT_OVER_30_MB,                     0, JSEXN_TYPEERR, "ObjectStore value can not be more than 30 Megabytes in size")
 MSG_DEF(JSMSG_READABLE_STREAM_LOCKED_OR_DISTRUBED,             0, JSEXN_TYPEERR, "Can't use a ReadableStream that's locked or has ever been read from or canceled")
 MSG_DEF(JSMSG_INVALID_CHARACTER_ERROR,                         0, JSEXN_ERR, "String contains an invalid character")
+MSG_DEF(JSMSG_BACKEND_PARAMETER_NOT_OBJECT,                    0, JSEXN_TYPEERR, "Backend constructor: configuration parameter must be an Object")
+MSG_DEF(JSMSG_BACKEND_NAME_NOT_SET,                            0, JSEXN_TYPEERR, "Backend constructor: name can not be null or undefined")
+MSG_DEF(JSMSG_BACKEND_NAME_TOO_LONG,                           0, JSEXN_TYPEERR, "Backend constructor: name can not be more than 254 characters")
+MSG_DEF(JSMSG_BACKEND_NAME_EMPTY,                              0, JSEXN_TYPEERR, "Backend constructor: name can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_TARGET_NOT_SET,                          0, JSEXN_TYPEERR, "Backend constructor: target can not be null or undefined")
+MSG_DEF(JSMSG_BACKEND_TARGET_EMPTY,                            0, JSEXN_TYPEERR, "Backend constructor: target can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_TARGET_INVALID,                          0, JSEXN_TYPEERR, "Backend constructor: target is not a valid host or IP address")
+MSG_DEF(JSMSG_BACKEND_CIPHERS_EMPTY,                           0, JSEXN_TYPEERR, "Backend constructor: ciphers can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_HOST_OVERRIDE_EMPTY,                     0, JSEXN_TYPEERR, "Backend constructor: hostOverride can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_CERTIFICATE_HOSTNAME_EMPTY,              0, JSEXN_TYPEERR, "Backend constructor: certificateHostname can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_SNI_HOSTNAME_EMPTY,                      0, JSEXN_TYPEERR, "Backend constructor: sniHostname can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_CA_CERTIFICATE_EMPTY,                    0, JSEXN_TYPEERR, "Backend constructor: caCertificate can not be an empty string")
+MSG_DEF(JSMSG_BACKEND_CONNECT_TIMEOUT_NEGATIVE,                0, JSEXN_RANGEERR, "Backend constructor: connectTimeout can not be a negative number")
+MSG_DEF(JSMSG_BACKEND_CONNECT_TIMEOUT_TOO_BIG,                 0, JSEXN_RANGEERR, "Backend constructor: connectTimeout must be less than 2^32")
+MSG_DEF(JSMSG_BACKEND_FIRST_BYTE_TIMEOUT_NEGATIVE,             0, JSEXN_RANGEERR, "Backend constructor: firstByteTimeout can not be a negative number")
+MSG_DEF(JSMSG_BACKEND_FIRST_BYTE_TIMEOUT_TOO_BIG,              0, JSEXN_RANGEERR, "Backend constructor: firstByteTimeout must be less than 2^32")
+MSG_DEF(JSMSG_BACKEND_BETWEEN_BYTES_TIMEOUT_NEGATIVE,          0, JSEXN_RANGEERR, "Backend constructor: betweenBytesTimeout can not be a negative number")
+MSG_DEF(JSMSG_BACKEND_BETWEEN_BYTES_TIMEOUT_TOO_BIG,           0, JSEXN_RANGEERR, "Backend constructor: betweenBytesTimeout must be less than 2^32")
+MSG_DEF(JSMSG_BACKEND_TLS_MIN_INVALID,                         0, JSEXN_RANGEERR, "Backend constructor: tlsMinVersion must be either 1, 1.1, 1.2, or 1.3")
+MSG_DEF(JSMSG_BACKEND_TLS_MAX_INVALID,                         0, JSEXN_RANGEERR, "Backend constructor: tlsMaxVersion must be either 1, 1.1, 1.2, or 1.3")
+MSG_DEF(JSMSG_BACKEND_TLS_MIN_GREATER_THAN_TLS_MAX,            0, JSEXN_RANGEERR, "Backend constructor: tlsMinVersion must be less than or equal to tlsMaxVersion")
+MSG_DEF(JSMSG_BACKEND_PORT_INVALID,                            0, JSEXN_RANGEERR, "Backend constructor: port must be more than 0 and less than 2^16 (65,536)")
 //clang-format on

c-dependencies/js-compute-runtime/error-numbers.msg

@@ -36,6 +36,7 @@
 #include "sequence.hpp"
 
 #include "builtin.h"
+#include "builtins/backend.h"
 #include "builtins/cache-override.h"
 #include "builtins/compression-stream.h"
 #include "builtins/config-store.h"
@@ -4038,10 +4039,10 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
   }
 
   RootedString backend(cx, Request::backend(request));
-  if (!backend) {
+  if (!backend && builtins::Fastly::allowDynamicBackends == false) {
     backend = builtins::Fastly::defaultBackend;
   }
-  if (!backend) {
+  if (!backend && builtins::Fastly::allowDynamicBackends == false) {
     size_t bytes_read;
     RequestHandle handle = Request::request_handle(request);
     UniqueChars buf(
@@ -4056,6 +4057,14 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
     return ReturnPromiseRejectedWithPendingError(cx, args);
   }
 
+  if (!backend && builtins::Fastly::allowDynamicBackends) {
+    JS::RootedObject dynamicBackend(cx, builtins::Backend::create(cx, request));
+    if (!dynamicBackend) {
+      return false;
+    }
+    backend.set(builtins::Backend::name(cx, dynamicBackend));
+  }
+
   size_t backend_len;
   UniqueChars backend_chars = encode(cx, backend, &backend_len);
   if (!backend_chars)
@@ -4424,6 +4433,8 @@ bool define_fastly_sys(JSContext *cx, HandleObject global) {
   if (!GlobalProperties::init(cx, global))
     return false;
 
+  if (!builtins::Backend::init_class(cx, global))
+    return false;
   if (!builtins::Fastly::create(cx, global))
     return false;
   if (!builtins::Console::create(cx, global))

c-dependencies/js-compute-runtime/js-compute-builtins.cpp

@@ -104,6 +104,7 @@ bool body_unusable(JSContext *cx, JS::HandleObject body);
 BodyHandle body_handle(JSObject *obj);
 template <BodyReadResult result_type>
 bool bodyAll(JSContext *cx, JS::CallArgs args, JS::HandleObject self);
+JS::Value url(JSObject *obj);
 } // namespace RequestOrResponse
 
 int write_to_body_all(BodyHandle handle, const char *buf, size_t len);

c-dependencies/js-compute-runtime/js-compute-builtins.h

@@ -52,6 +52,45 @@ typedef struct {
   uint32_t handle;
 } ObjectStoreHandle;
 
+// The values need to match https://docs.rs/fastly-sys/0.8.7/src/fastly_sys/lib.rs.html#86-108
+#define BACKEND_CONFIG_RESERVED (1u << 0)
+#define BACKEND_CONFIG_HOST_OVERRIDE (1u << 1)
+#define BACKEND_CONFIG_CONNECT_TIMEOUT (1u << 2)
+#define BACKEND_CONFIG_FIRST_BYTE_TIMEOUT (1u << 3)
+#define BACKEND_CONFIG_BETWEEN_BYTES_TIMEOUT (1u << 4)
+#define BACKEND_CONFIG_USE_SSL (1u << 5)
+#define BACKEND_CONFIG_SSL_MIN_VERSION (1u << 6)
+#define BACKEND_CONFIG_SSL_MAX_VERSION (1u << 7)
+#define BACKEND_CONFIG_CERT_HOSTNAME (1u << 8)
+#define BACKEND_CONFIG_CA_CERT (1u << 9)
+#define BACKEND_CONFIG_CIPHERS (1u << 10)
+#define BACKEND_CONFIG_SNI_HOSTNAME (1u << 11)
+
+typedef enum TLS {
+  VERSION_1 = 0,
+  VERSION_1_1 = 1,
+  VERSION_1_2 = 2,
+  VERSION_1_3 = 3,
+} TLS;
+
+typedef struct DynamicBackendConfig {
+  char *host_override;
+  uint32_t host_override_len;
+  uint32_t connect_timeout_ms;
+  uint32_t first_byte_timeout_ms;
+  uint32_t between_bytes_timeout_ms;
+  uint32_t ssl_min_version;
+  uint32_t ssl_max_version;
+  char *cert_hostname;
+  uint32_t cert_hostname_len;
+  char *ca_cert;
+  uint32_t ca_cert_len;
+  char *ciphers;
+  uint32_t ciphers_len;
+  char *sni_hostname;
+  uint32_t sni_hostname_len;
+} DynamicBackendConfig;
+
 #define INVALID_HANDLE (UINT32_MAX - 1)
 
 typedef enum BodyWriteEnd {
@@ -104,6 +143,12 @@ int xqd_log_write(LogEndpointHandle endpoint_handle, const char *msg, size_t msg
                   size_t *nwritten);
 
 // Module fastly_http_req
+WASM_IMPORT("fastly_http_req", "register_dynamic_backend")
+int xqd_req_register_dynamic_backend(const char *name_prefix, size_t name_prefix_len,
+                                     const char *target, size_t target_len,
+                                     uint32_t backend_config_mask,
+                                     DynamicBackendConfig *backend_configuration);
+
 WASM_IMPORT("fastly_http_req", "body_downstream_get")
 int xqd_req_body_downstream_get(RequestHandle *req_handle_out, BodyHandle *body_handle_out);