Added hostcalls for the new builder api hostcalls

lib/Cargo.toml

@@ -64,6 +64,7 @@ wasmtime-wasi = { workspace = true }
 wasmtime-wasi-nn = { workspace = true }
 wat = { workspace = true }
 wiggle = { workspace = true }
+base64.workspace = true
 
 [dev-dependencies]
 tempfile = "3.6.0"

lib/compute-at-edge-abi/compute-at-edge.witx

@@ -761,6 +761,7 @@
     )
 )
 
+;; NOTE: These are deprecated, use the fastly_kv_store hostcalls
 (module $fastly_object_store
     (@interface func (export "open")
         (param $name string)
@@ -820,6 +821,79 @@
     )
 )
 
+(module $fastly_kv_store
+    (@interface func (export "open")
+        (param $name string)
+        (result $err (expected $kv_store_handle (error $fastly_status)))
+    )
+
+    (@interface func (export "lookup")
+        (param $store $kv_store_handle)
+        (param $key string)
+        (param $lookup_config_mask $kv_lookup_config_options)
+        (param $lookup_configuration (@witx pointer $kv_lookup_config))
+        (param $handle_out (@witx pointer $kv_store_lookup_handle))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "lookup_wait")
+        (param $handle $kv_store_lookup_handle)
+        (param $body_handle_out (@witx pointer $body_handle))
+        (param $metadata_buf (@witx pointer (@witx char8)))
+        (param $metadata_buf_len (@witx usize))
+        (param $nwritten_out (@witx pointer (@witx usize)))
+        (param $generation_out (@witx pointer u32))
+        (param $kv_error_out (@witx pointer $kv_error))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "insert")
+        (param $store $kv_store_handle)
+        (param $key string)
+        (param $body_handle $body_handle)
+        (param $insert_config_mask $kv_insert_config_options)
+        (param $insert_configuration (@witx pointer $kv_insert_config))
+        (param $handle_out (@witx pointer $kv_store_insert_handle))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "insert_wait")
+        (param $handle $kv_store_insert_handle)
+        (param $kv_error_out (@witx pointer $kv_error))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "delete")
+        (param $store $kv_store_handle)
+        (param $key string)
+        (param $delete_config_mask $kv_delete_config_options)
+        (param $delete_configuration (@witx pointer $kv_delete_config))
+        (param $handle_out (@witx pointer $kv_store_delete_handle))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "delete_wait")
+        (param $handle $kv_store_delete_handle)
+        (param $kv_error_out (@witx pointer $kv_error))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "list")
+        (param $store $kv_store_handle)
+        (param $list_config_mask $kv_list_config_options)
+        (param $list_configuration (@witx pointer $kv_list_config))
+        (param $handle_out (@witx pointer $kv_store_list_handle))
+        (result $err (expected (error $fastly_status)))
+    )
+
+    (@interface func (export "list_wait")
+        (param $handle $kv_store_list_handle)
+        (param $body_handle_out (@witx pointer $body_handle))
+        (param $kv_error_out (@witx pointer $kv_error))
+        (result $err (expected (error $fastly_status)))
+    )
+)
+
 (module $fastly_secret_store
     (@interface func (export "open")
         (param $name string)

lib/compute-at-edge-abi/typenames.witx

@@ -91,14 +91,26 @@
 (typename $endpoint_handle (handle))
 ;;; A handle to an Edge Dictionary.
 (typename $dictionary_handle (handle))
-;;; A handle to an Object Store.
+;;; (DEPRECATED) A handle to an Object Store.
 (typename $object_store_handle (handle))
-;;; A handle to a pending KV lookup request.
+;;; (DEPRECATED) A handle to a pending KV lookup request.
 (typename $pending_kv_lookup_handle (handle))
-;;; A handle to a pending KV insert request.
+;;; (DEPRECATED) A handle to a pending KV insert request.
 (typename $pending_kv_insert_handle (handle))
-;;; A handle to a pending KV delete request.
+;;; (DEPRECATED) A handle to a pending KV delete request.
 (typename $pending_kv_delete_handle (handle))
+;;; (DEPRECATED) A handle to a pending KV list.
+(typename $pending_kv_list_handle (handle))
+;;; A handle to an KV Store.
+(typename $kv_store_handle (handle))
+;;; A handle to a KV Store lookup.
+(typename $kv_store_lookup_handle (handle))
+;;; A handle to a KV Store insert.
+(typename $kv_store_insert_handle (handle))
+;;; A handle to a KV Store delete.
+(typename $kv_store_delete_handle (handle))
+;;; A handle to a KV Store list.
+(typename $kv_store_list_handle (handle))
 ;;; A handle to a Secret Store.
 (typename $secret_store_handle (handle))
 ;;; A handle to an individual secret.
@@ -385,3 +397,97 @@
         (field $workspace_len u32)
     )
 )
+
+(typename $kv_lookup_config_options
+    (flags (@witx repr u32)
+       $reserved
+       ))
+
+(typename $kv_lookup_config
+  (record
+    (field $reserved u32)
+    ))
+
+(typename $kv_delete_config_options
+    (flags (@witx repr u32)
+       $reserved
+       ))
+
+(typename $kv_delete_config
+  (record
+    (field $reserved u32)
+    ))
+
+(typename $kv_insert_config_options
+    (flags (@witx repr u32)
+       $reserved
+       $background_fetch
+       $if_generation_match
+       $metadata
+       $time_to_live_sec
+       ))
+
+(typename $kv_insert_mode
+    (enum (@witx tag u32)
+       $overwrite
+       $add
+       $append
+       $prepend))
+
+(typename $kv_insert_config
+  (record
+    (field $mode $kv_insert_mode)
+    (field $if_generation_match u32)
+    (field $metadata (@witx pointer (@witx char8)))
+    (field $metadata_len u32)
+    (field $time_to_live_sec u32)
+    ))
+
+(typename $kv_list_config_options
+    (flags (@witx repr u32)
+       $reserved
+       $cursor
+       $limit
+       $prefix
+       ))
+
+(typename $kv_list_mode
+    (enum (@witx tag u32)
+       $strong
+       $eventual))
+
+(typename $kv_list_config
+  (record
+    (field $mode $kv_list_mode)
+    (field $cursor (@witx pointer (@witx char8)))
+    (field $cursor_len u32)
+    (field $limit u32)
+    (field $prefix (@witx pointer (@witx char8)))
+    (field $prefix_len u32)
+    ))
+
+(typename $kv_error
+    (enum (@witx tag u32)
+        ;;; The $kv_error has not been set.
+        $uninitialized
+        ;;; There was no error.
+        $ok
+        ;;; KV store cannot or will not process the request due to something that is perceived to be a client error
+        ;;; This will map to the api's 400 codes
+        $bad_request
+        ;;; KV store cannot find the requested resource
+        ;;; This will map to the api's 404 codes
+        $not_found
+        ;;; KV store cannot fulfill the request, as definied by the client's prerequisites (ie. if-generation-match)
+        ;;; This will map to the api's 412 codes
+        $precondition_failed
+        ;;; The size limit for a KV store key was exceeded.
+        ;;; This will map to the api's 413 codes
+        $payload_too_large
+        ;;; The system encountered an unexpected internal error.
+        ;;; This will map to all remaining http error codes
+        $internal_error
+        ;;; Too many requests have been made to the KV store.
+        ;;; This will map to the api's 429 codes
+        $too_many_requests
+        ))

lib/src/component/error.rs

@@ -3,7 +3,7 @@ use {
     crate::{
         config::ClientCertError,
         error::{self, HandleError},
-        object_store::{KeyValidationError, ObjectStoreError},
+        object_store::{KeyValidationError, KvStoreError, ObjectStoreError},
         wiggle_abi::{DictionaryError, SecretStoreError},
     },
     http::{
@@ -130,6 +130,22 @@ impl From<ObjectStoreError> for types::Error {
     }
 }
 
+impl From<KvStoreError> for types::Error {
+    fn from(err: KvStoreError) -> Self {
+        use KvStoreError::*;
+        match err {
+            Uninitialized => panic!("{}", err),
+            Ok => panic!("{}", err),
+            BadRequest => types::Error::InvalidArgument,
+            NotFound => types::Error::OptionalNone,
+            PreconditionFailed => types::Error::InvalidArgument,
+            PayloadTooLarge => types::Error::InvalidArgument,
+            InternalError => types::Error::InvalidArgument,
+            TooManyRequests => types::Error::InvalidArgument,
+        }
+    }
+}
+
 impl From<KeyValidationError> for types::Error {
     fn from(_: KeyValidationError) -> Self {
         types::Error::GenericError
@@ -177,6 +193,7 @@ impl From<error::Error> for types::Error {
             // We delegate to some error types' own implementation of `to_fastly_status`.
             Error::DictionaryError(e) => e.into(),
             Error::ObjectStoreError(e) => e.into(),
+            Error::KvStoreError(e) => e.into(),
             Error::SecretStoreError(e) => e.into(),
             // All other hostcall errors map to a generic `ERROR` value.
             Error::AbiVersionMismatch

lib/src/component/kv_store.rs

@@ -1,39 +1,55 @@
 use {
     super::fastly::api::{http_body, kv_store, types},
+    super::types::TrappableError,
     crate::linking::ComponentCtx,
+    wasmtime_wasi::WasiView,
 };
 
-pub struct LookupResult;
+pub struct LookupResult {
+    body: http_body::BodyHandle,
+    metadata: Option<Vec<u8>>,
+    generation: u32,
+}
 
 #[async_trait::async_trait]
 impl kv_store::HostLookupResult for ComponentCtx {
     async fn body(
         &mut self,
-        _self_: wasmtime::component::Resource<kv_store::LookupResult>,
-    ) -> http_body::BodyHandle {
-        todo!()
+        rep: wasmtime::component::Resource<kv_store::LookupResult>,
+    ) -> wasmtime::Result<http_body::BodyHandle> {
+        Ok(self.table().get(&rep)?.body)
     }
 
     async fn metadata(
         &mut self,
-        _self_: wasmtime::component::Resource<kv_store::LookupResult>,
-        _max_len: u64,
-    ) -> Result<Option<Vec<u8>>, types::Error> {
-        todo!()
+        rep: wasmtime::component::Resource<kv_store::LookupResult>,
+        max_len: u64,
+    ) -> Result<Option<Vec<u8>>, TrappableError> {
+        let res = self.table().get(&rep)?;
+        let Some(md) = res.metadata.as_ref() else {
+            return Ok(None);
+        };
+
+        if md.len() > max_len as usize {
+            return Err(types::Error::BufferLen(md.len() as u64).into());
+        }
+
+        Ok(self.table().get_mut(&rep)?.metadata.take())
     }
 
     async fn generation(
         &mut self,
-        _self_: wasmtime::component::Resource<kv_store::LookupResult>,
-    ) -> u32 {
-        todo!()
+        rep: wasmtime::component::Resource<kv_store::LookupResult>,
+    ) -> wasmtime::Result<u32> {
+        Ok(self.table().get(&rep)?.generation)
     }
 
     fn drop(
         &mut self,
-        _rep: wasmtime::component::Resource<kv_store::LookupResult>,
+        rep: wasmtime::component::Resource<kv_store::LookupResult>,
     ) -> wasmtime::Result<()> {
-        todo!()
+        self.table().delete(rep)?;
+        Ok(())
     }
 }
 

lib/src/component/mod.rs

@@ -6,6 +6,7 @@ component::bindgen!({
     async: true,
     with: {
         "fastly:api/uap/user-agent": uap::UserAgent,
+        "fastly:api/kv-store/lookup-result": kv_store::LookupResult,
 
         "wasi:clocks": wasmtime_wasi::bindings::clocks,
         "wasi:random": wasmtime_wasi::bindings::random,
@@ -18,7 +19,10 @@ component::bindgen!({
     },
 
     trappable_imports: [
-        "header-values-get"
+        "header-values-get",
+        "[method]lookup-result.body",
+        "[method]lookup-result.metadata",
+        "[method]lookup-result.generation"
     ],
 });