Further restrict use of the fastly.h header

elliottt · JakeChampion · commit 727157862513 · 2023-07-14T10:21:17.000+01:00
diff --git a/runtime/js-compute-runtime/builtins/cache-override.cpp b/runtime/js-compute-runtime/builtins/cache-override.cpp
@@ -9,6 +9,7 @@
 
 #include "cache-override.h"
 #include "host_interface/fastly.h"
+#include "host_interface/host_api.h"
 #include "host_interface/host_call.h"
 #include "js-compute-builtins.h"
 
@@ -75,7 +76,7 @@ void CacheOverride::set_pci(JSObject *self, bool pci) {
   JS::SetReservedSlot(self, CacheOverride::Slots::PCI, JS::BooleanValue(pci));
 }
 
-fastly_compute_at_edge_fastly_http_cache_override_tag_t CacheOverride::abi_tag(JSObject *self) {
+CacheOverrideTag CacheOverride::abi_tag(JSObject *self) {
   MOZ_ASSERT(is_instance(self));
   switch (CacheOverride::mode(self)) {
   case CacheOverride::CacheOverrideMode::None:
@@ -85,7 +86,7 @@ fastly_compute_at_edge_fastly_http_cache_override_tag_t CacheOverride::abi_tag(J
   default:;
   }
 
-  fastly_compute_at_edge_fastly_http_cache_override_tag_t tag = 0;
+  CacheOverrideTag tag = 0;
   if (!ttl(self).isUndefined())
     tag |= FASTLY_COMPUTE_AT_EDGE_FASTLY_HTTP_CACHE_OVERRIDE_TAG_TTL;
   if (!swr(self).isUndefined())
diff --git a/runtime/js-compute-runtime/builtins/config-store.cpp b/runtime/js-compute-runtime/builtins/config-store.cpp
@@ -1,5 +1,4 @@
 #include "config-store.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {
@@ -106,7 +105,7 @@ bool ConfigStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
   JS::RootedObject config_store(cx, JS_NewObjectForConstructor(cx, &class_, args));
   auto open_res = Dict::open(name);
   if (auto *err = open_res.to_err()) {
-    if (*err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_BAD_HANDLE) {
+    if (error_is_bad_handle(*err)) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_CONFIG_STORE_DOES_NOT_EXIST,
                                 name.data());
       return false;
diff --git a/runtime/js-compute-runtime/builtins/dictionary.cpp b/runtime/js-compute-runtime/builtins/dictionary.cpp
@@ -1,5 +1,4 @@
 #include "dictionary.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {
@@ -117,7 +116,7 @@ bool Dictionary::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
 
   auto res = Dict::open(name_view);
   if (auto *err = res.to_err()) {
-    if (*err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_BAD_HANDLE) {
+    if (error_is_bad_handle(*err)) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_DICTIONARY_DOES_NOT_EXIST,
                                 name_view.data());
       return false;
diff --git a/runtime/js-compute-runtime/builtins/fetch-event.h b/runtime/js-compute-runtime/builtins/fetch-event.h
@@ -2,7 +2,6 @@
 #define BUILTINS_FETCH_EVENT_H
 
 #include "builtin.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {
diff --git a/runtime/js-compute-runtime/builtins/kv-store.cpp b/runtime/js-compute-runtime/builtins/kv-store.cpp
@@ -18,8 +18,8 @@
 #include "builtins/kv-store.h"
 #include "builtins/native-stream-source.h"
 #include "builtins/shared/url.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
+#include "host_interface/host_call.h"
 #include "js-compute-builtins.h"
 
 namespace builtins {
@@ -434,7 +434,7 @@ bool KVStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
 
   auto res = ObjectStore::open(name_str);
   if (auto *err = res.to_err()) {
-    if (*err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_INVALID_ARGUMENT) {
+    if (error_is_invalid_argument(*err)) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_KV_STORE_DOES_NOT_EXIST,
                                 name_str.data());
       return false;
diff --git a/runtime/js-compute-runtime/builtins/secret-store.cpp b/runtime/js-compute-runtime/builtins/secret-store.cpp
@@ -1,5 +1,4 @@
 #include "secret-store.h"
-#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {
@@ -195,7 +194,7 @@ bool SecretStore::constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
 
   auto res = host_api::SecretStore::open(name);
   if (auto *err = res.to_err()) {
-    if (*err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_OPTIONAL_NONE) {
+    if (error_is_optional_none(*err)) {
       JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_SECRET_STORE_DOES_NOT_EXIST,
                                 name.data());
       return false;
diff --git a/runtime/js-compute-runtime/host_interface/host_api.cpp b/runtime/js-compute-runtime/host_interface/host_api.cpp
@@ -40,6 +40,10 @@ static_assert(
 static_assert(std::is_same_v<Dict::Handle, fastly_compute_at_edge_fastly_dictionary_handle_t>);
 static_assert(
     std::is_same_v<ObjectStore::Handle, fastly_compute_at_edge_fastly_object_store_handle_t>);
+static_assert(std::is_same_v<HttpVersion, fastly_compute_at_edge_fastly_http_version_t>);
+static_assert(
+    std::is_same_v<CacheOverrideTag, fastly_compute_at_edge_fastly_http_cache_override_tag_t>);
+static_assert(std::is_same_v<TlsVersion, fastly_compute_at_edge_fastly_tls_version_t>);
 
 Result<bool> AsyncHandle::is_ready() const {
   Result<bool> res;
diff --git a/runtime/js-compute-runtime/host_interface/host_call.cpp b/runtime/js-compute-runtime/host_interface/host_call.cpp
@@ -1,12 +1,29 @@
 
 #include <type_traits>
 
+#include "fastly-world/fastly_world.h"
 #include "host_interface/fastly.h"
 #include "host_interface/host_call.h"
 
 // Ensure that our type synonyms match what's generated by wit-bindgen.
 static_assert(std::is_same_v<FastlyError, fastly_compute_at_edge_fastly_error_t>);
 
+bool error_is_generic(FastlyError e) {
+  return e == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_GENERIC_ERROR;
+}
+
+bool error_is_invalid_argument(FastlyError e) {
+  return e == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_INVALID_ARGUMENT;
+}
+
+bool error_is_optional_none(FastlyError e) {
+  return e == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_OPTIONAL_NONE;
+}
+
+bool error_is_bad_handle(FastlyError e) {
+  return e == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_BAD_HANDLE;
+}
+
 /* Returns false if an exception is set on `cx` and the caller should
    immediately return to propagate the exception. */
 void handle_fastly_error(JSContext *cx, FastlyError err, int line, const char *func) {
diff --git a/runtime/js-compute-runtime/host_interface/host_call.h b/runtime/js-compute-runtime/host_interface/host_call.h
@@ -12,6 +12,11 @@
 
 using FastlyError = uint8_t;
 
+bool error_is_generic(FastlyError e);
+bool error_is_invalid_argument(FastlyError e);
+bool error_is_optional_none(FastlyError e);
+bool error_is_bad_handle(FastlyError e);
+
 void handle_fastly_error(JSContext *cx, FastlyError err, int line, const char *func);
 
 #define HANDLE_ERROR(cx, err) handle_fastly_error(cx, err, __LINE__, __func__)
diff --git a/runtime/js-compute-runtime/js-compute-builtins.cpp b/runtime/js-compute-runtime/js-compute-builtins.cpp
@@ -9,7 +9,6 @@
 #include <strings.h>
 #include <vector>
 
-#include "fastly-world/fastly_world.h"
 #include "js-compute-builtins.h"
 #include "rust-url/rust-url.h"
 
@@ -33,6 +32,7 @@
 #include "js/shadow/Object.h"
 #include "zlib.h"
 
+#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 #include "host_interface/host_call.h"
 
@@ -806,10 +806,11 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
     }
   }
 
-  size_t backend_len;
-  UniqueChars backend_chars = encode(cx, backend, &backend_len);
-  if (!backend_chars)
+  HostString backend_chars;
+  backend_chars.ptr = encode(cx, backend, &backend_chars.len);
+  if (!backend_chars.ptr) {
     return ReturnPromiseRejectedWithPendingError(cx, args);
+  }
 
   RootedObject response_promise(cx, JS::NewPromiseObject(cx, nullptr));
   if (!response_promise)
@@ -824,32 +825,24 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
     return false;
   }
 
-  fastly_world_string_t backend_str = {backend_chars.get(), backend_len};
-
-  fastly_compute_at_edge_fastly_pending_request_handle_t pending_handle = INVALID_HANDLE;
+  HttpPendingReq pending_handle;
   {
-    fastly_compute_at_edge_fastly_error_t err;
-    bool ok;
     auto request_handle = builtins::Request::request_handle(request);
     auto body = builtins::RequestOrResponse::body_handle(request);
-    if (streaming) {
-      ok = fastly_compute_at_edge_fastly_http_req_send_async_streaming(
-          request_handle.handle, body.handle, &backend_str, &pending_handle, &err);
-    } else {
-      ok = fastly_compute_at_edge_fastly_http_req_send_async(request_handle.handle, body.handle,
-                                                             &backend_str, &pending_handle, &err);
-    }
+    auto res = streaming ? request_handle.send_async_streaming(body, backend_chars)
+                         : request_handle.send_async(body, backend_chars);
 
-    if (!ok) {
-      if (err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_GENERIC_ERROR ||
-          err == FASTLY_COMPUTE_AT_EDGE_FASTLY_ERROR_INVALID_ARGUMENT) {
+    if (auto *err = res.to_err()) {
+      if (error_is_generic(*err) || error_is_invalid_argument(*err)) {
         JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
-                                  JSMSG_REQUEST_BACKEND_DOES_NOT_EXIST, backend_chars.get());
+                                  JSMSG_REQUEST_BACKEND_DOES_NOT_EXIST, backend_chars.ptr.get());
       } else {
-        HANDLE_ERROR(cx, err);
+        HANDLE_ERROR(cx, *err);
       }
       return ReturnPromiseRejectedWithPendingError(cx, args);
     }
+
+    pending_handle = res.unwrap();
   }
 
   // If the request body is streamed, we need to wait for streaming to complete before marking the
@@ -860,7 +853,7 @@ bool fetch(JSContext *cx, unsigned argc, Value *vp) {
   }
 
   JS::SetReservedSlot(request, static_cast<uint32_t>(builtins::Request::Slots::PendingRequest),
-                      JS::Int32Value(pending_handle));
+                      JS::Int32Value(pending_handle.handle));
   JS::SetReservedSlot(request, static_cast<uint32_t>(builtins::Request::Slots::ResponsePromise),
                       JS::ObjectValue(*response_promise));
 
diff --git a/runtime/js-compute-runtime/js-compute-builtins.h b/runtime/js-compute-runtime/js-compute-builtins.h
@@ -8,20 +8,13 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Winvalid-offsetof"
 #pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"
-#include "jsapi.h"
-#include "jsfriendapi.h"
-
 #include "js/ForOfIterator.h"
 #include "js/Object.h"
 #include "js/Promise.h"
-
+#include "jsapi.h"
+#include "jsfriendapi.h"
 #pragma clang diagnostic pop
 
-#include "host_interface/host_call.h"
-#include "rust-url/rust-url.h"
-
-struct JSErrorFormatString;
-
 extern JS::PersistentRootedObjectVector *pending_async_tasks;
 
 enum JSErrNum {
@@ -31,6 +24,8 @@ enum JSErrNum {
   JSErrNum_Limit
 };
 
+struct JSErrorFormatString;
+
 const JSErrorFormatString js_ErrorFormatString[JSErrNum_Limit] = {
 #define MSG_DEF(name, count, exception, format) {#name, format, count, exception},
 #include "./error-numbers.msg"
@@ -116,6 +111,12 @@ bool process_pending_async_tasks(JSContext *cx);
 
 JS::UniqueChars encode(JSContext *cx, JS::HandleString val, size_t *encoded_len);
 JS::UniqueChars encode(JSContext *cx, JS::HandleValue val, size_t *encoded_len);
+
+// Forward decls for encode
+namespace jsurl {
+struct SpecString;
+}
+
 jsurl::SpecString encode(JSContext *cx, JS::HandleValue val);
 
 bool debug_logging_enabled();
diff --git a/runtime/js-compute-runtime/js-compute-runtime.cpp b/runtime/js-compute-runtime/js-compute-runtime.cpp
@@ -21,6 +21,7 @@
 
 #include "builtins/fetch-event.h"
 #include "core/allocator.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 #include "js-compute-builtins.h"
 #include "third_party/wizer.h"
