Remove the include of fastly_world.h from the host_api

Instead of re-exporting the api defined by fastly_world.h through
host_api.h, introduce type synonyms for handle types and enforce through
static asserts that the representation is the same. Consumers of
host_api.h that require access to fastly_world.h now access it directly,
reducing the number of files that are affected directly by changes to
fastly.wit, and making it a little more difficult to use the generated
api directly.

Author: elliottt

runtime/js-compute-runtime/builtin.h

@@ -1,6 +1,8 @@
 #ifndef JS_COMPUTE_RUNTIME_BUILTIN_H
 #define JS_COMPUTE_RUNTIME_BUILTIN_H
 
+#include <optional>
+#include <span>
 #include <tuple>
 
 // TODO: remove these once the warnings are fixed
@@ -16,8 +18,6 @@
 #include "jsapi.h"
 #include "jsfriendapi.h"
 #include "rust-url/rust-url.h"
-#include <span>
-
 #pragma clang diagnostic pop
 
 std::optional<std::span<uint8_t>> value_to_buffer(JSContext *cx, JS::HandleValue val,

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

@@ -19,6 +19,7 @@
 
 #include "builtins/backend.h"
 #include "builtins/request-response.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_call.h"
 #include "js-compute-builtins.h"
 #include "js/Conversions.h"

runtime/js-compute-runtime/builtins/cache-override.cpp

@@ -8,6 +8,7 @@
 #include "js/Conversions.h"
 
 #include "cache-override.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_call.h"
 #include "js-compute-builtins.h"
 

runtime/js-compute-runtime/builtins/cache-simple.cpp

@@ -2,6 +2,7 @@
 #include "builtin.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"
@@ -64,14 +65,13 @@ bool SimpleCacheEntry::constructor(JSContext *cx, unsigned argc, JS::Value *vp)
   return false;
 }
 
-JSObject *SimpleCacheEntry::create(JSContext *cx,
-                                   fastly_compute_at_edge_fastly_body_handle_t body_handle) {
+JSObject *SimpleCacheEntry::create(JSContext *cx, HttpBody body_handle) {
   JS::RootedObject SimpleCacheEntry(cx, JS_NewObjectWithGivenProto(cx, &class_, proto_obj));
   if (!SimpleCacheEntry)
     return nullptr;
 
   JS::SetReservedSlot(SimpleCacheEntry, static_cast<uint32_t>(Slots::Body),
-                      JS::Int32Value(body_handle));
+                      JS::Int32Value(body_handle.handle));
   JS::SetReservedSlot(SimpleCacheEntry, static_cast<uint32_t>(Slots::BodyStream), JS::NullValue());
   JS::SetReservedSlot(SimpleCacheEntry, static_cast<uint32_t>(Slots::HasBody),
                       JS::BooleanValue(true));
@@ -467,9 +467,9 @@ bool SimpleCache::getOrSetThenHandler(JSContext *cx, JS::HandleObject owner, JS:
     }
   }
 
-  fastly_compute_at_edge_fastly_body_handle_t bodyHandle = INVALID_HANDLE;
+  HttpBody bodyHandle;
   fastly_compute_at_edge_fastly_cache_get_body_options_t opts;
-  if (!fastly_compute_at_edge_fastly_cache_get_body(ret.f1, &opts, &bodyHandle, &err)) {
+  if (!fastly_compute_at_edge_fastly_cache_get_body(ret.f1, &opts, &bodyHandle.handle, &err)) {
     HANDLE_ERROR(cx, err);
     if (!fastly_compute_at_edge_fastly_transaction_cancel(handle, &err)) {
       HANDLE_ERROR(cx, err);
@@ -552,9 +552,9 @@ bool SimpleCache::getOrSet(JSContext *cx, unsigned argc, JS::Value *vp) {
   }
   args.rval().setObject(*promise);
   if (state & FASTLY_COMPUTE_AT_EDGE_FASTLY_CACHE_LOOKUP_STATE_USABLE) {
-    fastly_compute_at_edge_fastly_body_handle_t body = INVALID_HANDLE;
+    HttpBody body;
     fastly_compute_at_edge_fastly_cache_get_body_options_t opts;
-    if (!fastly_compute_at_edge_fastly_cache_get_body(handle, &opts, &body, &err)) {
+    if (!fastly_compute_at_edge_fastly_cache_get_body(handle, &opts, &body.handle, &err)) {
       if (!fastly_compute_at_edge_fastly_transaction_cancel(handle, &err)) {
         HANDLE_ERROR(cx, err);
         return ReturnPromiseRejectedWithPendingError(cx, args);
@@ -838,14 +838,14 @@ bool SimpleCache::get(JSContext *cx, unsigned argc, JS::Value *vp) {
     return false;
   }
 
-  fastly_compute_at_edge_fastly_body_handle_t body = INVALID_HANDLE;
+  HttpBody body;
   fastly_compute_at_edge_fastly_cache_get_body_options_t opts;
-  if (!fastly_compute_at_edge_fastly_cache_get_body(handle, &opts, &body, &err)) {
+  if (!fastly_compute_at_edge_fastly_cache_get_body(handle, &opts, &body.handle, &err)) {
     HANDLE_ERROR(cx, err);
     return false;
   }
 
-  if (body == INVALID_HANDLE) {
+  if (!body.valid()) {
     args.rval().setNull();
   } else {
     JS::RootedObject entry(cx, SimpleCacheEntry::create(cx, body));

runtime/js-compute-runtime/builtins/cache-simple.h

@@ -26,7 +26,7 @@ class SimpleCacheEntry final : public BuiltinImpl<SimpleCacheEntry> {
 
   static bool init_class(JSContext *cx, JS::HandleObject global);
   static bool constructor(JSContext *cx, unsigned argc, JS::Value *vp);
-  static JSObject *create(JSContext *cx, fastly_compute_at_edge_fastly_body_handle_t body_handle);
+  static JSObject *create(JSContext *cx, HttpBody body_handle);
 };
 
 class SimpleCache : public BuiltinImpl<SimpleCache> {

runtime/js-compute-runtime/builtins/config-store.cpp

@@ -1,4 +1,5 @@
 #include "config-store.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {

runtime/js-compute-runtime/builtins/dictionary.cpp

@@ -1,4 +1,5 @@
 #include "dictionary.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {

runtime/js-compute-runtime/builtins/kv-store.cpp

@@ -18,6 +18,7 @@
 #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 "js-compute-builtins.h"
 

runtime/js-compute-runtime/builtins/secret-store.cpp

@@ -1,4 +1,5 @@
 #include "secret-store.h"
+#include "host_interface/fastly.h"
 #include "host_interface/host_api.h"
 
 namespace builtins {

runtime/js-compute-runtime/host_interface/host_api.cpp

@@ -1,4 +1,5 @@
 #include <algorithm>
+#include <type_traits>
 
 #include "core/allocator.h"
 #include "fastly-world/fastly_world.h"
@@ -13,8 +14,33 @@ fastly_world_string_t string_view_to_world_string(std::string_view str) {
   };
 }
 
+HostString make_host_string(fastly_world_string_t str) {
+  return HostString{JS::UniqueChars{str.ptr}, str.len};
+}
+
+HostBytes make_host_bytes(fastly_world_list_u8_t str) {
+  return HostBytes{std::unique_ptr<uint8_t[]>{str.ptr}, str.len};
+}
+
+Response make_response(fastly_compute_at_edge_fastly_response_t &resp) {
+  return Response{HttpResp{resp.f0}, HttpBody{resp.f1}};
+}
+
 } // namespace
 
+// Ensure that the handle types stay in sync with fastly-world.h
+static_assert(std::is_same_v<AsyncHandle::Handle, fastly_compute_at_edge_fastly_async_handle_t>);
+static_assert(std::is_same_v<HttpBody::Handle, fastly_compute_at_edge_fastly_body_handle_t>);
+static_assert(
+    std::is_same_v<HttpPendingReq::Handle, fastly_compute_at_edge_fastly_pending_request_handle_t>);
+static_assert(std::is_same_v<HttpReq::Handle, fastly_compute_at_edge_fastly_request_handle_t>);
+static_assert(std::is_same_v<HttpResp::Handle, fastly_compute_at_edge_fastly_response_handle_t>);
+static_assert(
+    std::is_same_v<LogEndpoint::Handle, fastly_compute_at_edge_fastly_log_endpoint_handle_t>);
+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>);
+
 Result<bool> AsyncHandle::is_ready() const {
   Result<bool> res;
 
@@ -155,7 +181,7 @@ Result<std::vector<HostString>> generic_get_header_names(auto handle) {
     std::vector<HostString> names;
 
     for (int i = 0; i < ret.len; i++) {
-      names.emplace_back(HostString{ret.ptr[i]});
+      names.emplace_back(make_host_string(ret.ptr[i]));
     }
 
     // Free the vector of string pointers, but leave the individual strings alone.
@@ -183,7 +209,7 @@ Result<std::optional<std::vector<HostString>>> generic_get_header_values(auto ha
       std::vector<HostString> names;
 
       for (int i = 0; i < ret.val.len; i++) {
-        names.emplace_back(HostString{ret.val.ptr[i]});
+        names.emplace_back(make_host_string(ret.val.ptr[i]));
       }
 
       // Free the vector of string pointers, but leave the individual strings alone.
@@ -235,7 +261,7 @@ Result<std::optional<Response>> HttpPendingReq::poll() {
   if (!fastly_compute_at_edge_fastly_http_req_pending_req_poll(this->handle, &ret, &err)) {
     res.emplace_err(err);
   } else if (ret.is_some) {
-    res.emplace(ret.val);
+    res.emplace(make_response(ret.val));
   } else {
     res.emplace(std::nullopt);
   }
@@ -251,7 +277,7 @@ Result<Response> HttpPendingReq::wait() {
   if (!fastly_compute_at_edge_fastly_http_req_pending_req_wait(this->handle, &ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_response(ret));
   }
 
   return res;
@@ -377,7 +403,7 @@ Result<Response> HttpReq::send(HttpBody body, std::string_view backend) {
                                                    &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_response(ret));
   }
 
   return res;
@@ -435,7 +461,7 @@ Result<HostString> HttpReq::get_method() const {
   if (!fastly_compute_at_edge_fastly_http_req_method_get(this->handle, &ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_string(ret));
   }
 
   return res;
@@ -463,7 +489,7 @@ Result<HostString> HttpReq::get_uri() const {
   if (!fastly_compute_at_edge_fastly_http_req_uri_get(this->handle, &uri, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(uri);
+    res.emplace(make_host_string(uri));
   }
 
   return res;
@@ -509,7 +535,7 @@ Result<HostBytes> HttpReq::downstream_client_ip_addr() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_client_ip_addr(&octets, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(octets);
+    res.emplace(make_host_bytes(octets));
   }
 
   return res;
@@ -524,7 +550,7 @@ Result<HostString> HttpReq::http_req_downstream_tls_cipher_openssl_name() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_tls_cipher_openssl_name(&ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_string(ret));
   }
 
   return res;
@@ -539,7 +565,7 @@ Result<HostString> HttpReq::http_req_downstream_tls_protocol() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_tls_protocol(&ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_string(ret));
   }
 
   return res;
@@ -554,7 +580,7 @@ Result<HostBytes> HttpReq::http_req_downstream_tls_client_hello() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_tls_client_hello(&ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_bytes(ret));
   }
 
   return res;
@@ -569,7 +595,7 @@ Result<HostBytes> HttpReq::http_req_downstream_tls_raw_client_certificate() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_tls_raw_client_certificate(&ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_bytes(ret));
   }
 
   return res;
@@ -584,7 +610,7 @@ Result<HostBytes> HttpReq::http_req_downstream_tls_ja3_md5() {
   if (!fastly_compute_at_edge_fastly_http_req_downstream_tls_ja3_md5(&ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_bytes(ret));
   }
 
   return res;
@@ -736,7 +762,7 @@ Result<HostString> GeoIp::lookup(std::span<uint8_t> bytes) {
   if (!fastly_compute_at_edge_fastly_geo_lookup(&octets_list, &ret, &err)) {
     res.emplace_err(err);
   } else {
-    res.emplace(ret);
+    res.emplace(make_host_string(ret));
   }
 
   return res;
@@ -795,7 +821,7 @@ Result<std::optional<HostString>> Dict::get(std::string_view name) {
   if (!fastly_compute_at_edge_fastly_dictionary_get(this->handle, &name_str, &ret, &err)) {
     res.emplace_err(err);
   } else if (ret.is_some) {
-    res.emplace(ret.val);
+    res.emplace(make_host_string(ret.val));
   } else {
     res.emplace(std::nullopt);
   }
@@ -852,6 +878,10 @@ Result<Void> ObjectStore::insert(std::string_view name, HttpBody body) {
 
 namespace host_api {
 
+static_assert(std::is_same_v<Secret::Handle, fastly_compute_at_edge_fastly_secret_handle_t>);
+static_assert(
+    std::is_same_v<SecretStore::Handle, fastly_compute_at_edge_fastly_secret_store_handle_t>);
+
 Result<std::optional<HostString>> Secret::plaintext() const {
   Result<std::optional<HostString>> res;
 
@@ -860,7 +890,7 @@ Result<std::optional<HostString>> Secret::plaintext() const {
   if (!fastly_compute_at_edge_fastly_secret_store_plaintext(this->handle, &ret, &err)) {
     res.emplace_err(err);
   } else if (ret.is_some) {
-    res.emplace(ret.val);
+    res.emplace(make_host_string(ret.val));
   } else {
     res.emplace(std::nullopt);
   }