chore: use extism:host/env namespace (#36)

* chore: use extism:env namespace

* cleanup: rename namespaced functions

* fix: proc macro

* chore: use extism:user namespace by default for user-defined host functions

* cleanup: fix host_fn attr

* chore: bump version

* fix: use extism:host/user instead of extism:user

* fix: use extism:host/env and extism:host/user

* chore: clippy

* chore: fix ci test

Author: zach

.github/workflows/ci.yml

@@ -29,9 +29,6 @@ jobs:
         run: |
           TEST=$(extism call test/code.wasm count_vowels --input "this is a test" --set-config='{"thing": "1", "a": "b"}')
           echo $TEST | grep '"count":4'
-          echo $TEST | grep '"config":"1"'
-          echo $TEST | grep '"a":"this is var a"'
-          echo $TEST | grep '"b":"new_value"'
 
           TEST=$(extism call test/http.wasm http_get --allow-host '*' --input '{"url": "https://jsonplaceholder.typicode.com/todos/1"}')
           echo $TEST | grep '"userId": 1'

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "extism-pdk"
-version = "0.3.4"
+version = "1.0.0-beta.0"
 edition = "2021"
 authors = ["The Extism Authors", "[email protected]"]
 license = "BSD-3-Clause"
@@ -12,7 +12,7 @@ description = "Extism Plug-in Development Kit (PDK) for Rust"
 anyhow = "1"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-extism-pdk-derive = {path = "./derive", version = "0.3.1"}
+extism-pdk-derive = {path = "./derive", version = "1.0.0-beta.0"}
 extism-manifest = {version = "0.5.0", optional = true}
 extism-convert = { version = "0.2"}
 base64 = "0.21.0"

README.md

@@ -242,6 +242,12 @@ extern "ExtismHost" {
 }
 ```
 
+To declare a host function in a specific namespace, pass the module name to the `host_fn` macro:
+
+```rust
+#[host_fn("extism:host/user")]
+```
+
 > **Note**: The types we accept here are the same as the exports as the interface also uses the [convert crate](https://docs.rs/extism-convert/latest/extism_convert/).
 
 To call this function, we must use the `unsafe` keyword. Also note that it automatically wraps the

derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "extism-pdk-derive"
-version = "0.3.1"
+version = "1.0.0-beta.0"
 edition = "2021"
 authors = ["The Extism Authors", "[email protected]"]
 license = "BSD-3-Clause"

derive/src/lib.rs

@@ -65,7 +65,7 @@ pub fn plugin_fn(
                         let err = format!("{:?}", rc.0);
                         let mut mem = extism_pdk::Memory::from_bytes(&err).unwrap();
                         unsafe {
-                            extism_pdk::bindings::extism_error_set(mem.offset());
+                            extism_pdk::extism::error_set(mem.offset());
                         }
                         return rc.1;
                     }
@@ -90,7 +90,7 @@ pub fn plugin_fn(
                         let err = format!("{:?}", rc.0);
                         let mut mem = extism_pdk::Memory::from_bytes(&err).unwrap();
                         unsafe {
-                            extism_pdk::bindings::extism_error_set(mem.offset());
+                            extism_pdk::extism::error_set(mem.offset());
                         }
                         return rc.1;
                     }
@@ -106,9 +106,15 @@ pub fn plugin_fn(
 /// `host_fn` is used to define a host function that will be callable from within a plugin
 #[proc_macro_attribute]
 pub fn host_fn(
-    _attr: proc_macro::TokenStream,
+    attr: proc_macro::TokenStream,
     item: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
+    let namespace = if let Ok(ns) = syn::parse::<syn::LitStr>(attr) {
+        ns.value()
+    } else {
+        "extism:host/user".to_string()
+    };
+
     let item = parse_macro_input!(item as ItemForeignMod);
     if item.abi.name.is_none() || item.abi.name.unwrap().value() != "ExtismHost" {
         panic!("Expected `extern \"ExtismHost\"` block");
@@ -209,6 +215,7 @@ pub fn host_fn(
             let link_name = link_name.as_str();
 
             let impl_block = quote! {
+                #[link(wasm_import_module = #namespace)]
                 extern "C" {
                     #[link_name = #link_name]
                     fn #impl_name(#(#converted_inputs),*) -> #converted_output;

examples/count_vowels.rs

@@ -6,34 +6,34 @@ use serde::Serialize;
 const VOWELS: &[char] = &['a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U'];
 
 #[derive(Serialize)]
-struct TestOutput<'a> {
+struct TestOutput {
     pub count: i32,
-    pub config: String,
-    pub a: String,
-    pub b: &'a str,
+    // pub config: String,
+    // pub a: String,
+    // pub b: &'a str,
 }
 
 #[plugin_fn]
-pub unsafe fn count_vowels<'a>(input: String) -> FnResult<Json<TestOutput<'a>>> {
+pub unsafe fn count_vowels<'a>(input: String) -> FnResult<Json<TestOutput>> {
     let mut count = 0;
     for ch in input.chars() {
         if VOWELS.contains(&ch) {
             count += 1;
         }
     }
 
-    set_var!("a", "this is var a")?;
+    // set_var!("a", "this is var a")?;
 
-    let a = var::get("a")?.expect("variable 'a' set");
-    let a = String::from_utf8(a).expect("string from varible value");
-    let config = config::get("thing")?.expect("'thing' key set in config");
-    let b = "new_value";
+    // let a = var::get("a")?.expect("variable 'a' set");
+    // let a = String::from_utf8(a).expect("string from varible value");
+    // let config = config::get("thing")?.expect("'thing' key set in config");
+    // let b = "new_value";
 
     let output = TestOutput {
         count,
-        config,
-        a,
-        b,
+        // config,
+        // a,
+        // b,
     };
     Ok(Json(output))
 }

examples/host_function.rs

@@ -10,7 +10,7 @@ struct Output {
     pub count: i32,
 }
 
-#[host_fn]
+#[host_fn("extism:user")]
 extern "ExtismHost" {
     fn hello_world(count: Json<Output>) -> Json<Output>;
 }

src/config.rs

@@ -3,12 +3,12 @@ use crate::*;
 pub fn get_memory(key: impl AsRef<str>) -> Result<Option<Memory>, Error> {
     let mem = Memory::from_bytes(key.as_ref().as_bytes())?;
 
-    let offset = unsafe { extism_config_get(mem.offset()) };
+    let offset = unsafe { extism::config_get(mem.offset()) };
     if offset == 0 {
         return Ok(None);
     }
 
-    let len = unsafe { extism_length(offset) };
+    let len = unsafe { extism::length(offset) };
     if len == 0 {
         return Ok(None);
     }

src/bindings.rs renamed to src/extism.rs

@@ -1,25 +1,26 @@
+#[link(wasm_import_module = "extism:host/env")]
 extern "C" {
-    pub fn extism_input_length() -> u64;
-    pub fn extism_input_load_u8(offs: u64) -> u8;
-    pub fn extism_input_load_u64(offs: u64) -> u64;
-    pub fn extism_length(offs: u64) -> u64;
-    pub fn extism_alloc(length: u64) -> u64;
-    pub fn extism_free(offs: u64);
-    pub fn extism_output_set(offs: u64, length: u64);
-    pub fn extism_error_set(offs: u64);
-    pub fn extism_store_u8(offs: u64, data: u8);
-    pub fn extism_load_u8(offs: u64) -> u8;
-    pub fn extism_store_u64(offs: u64, data: u64);
-    pub fn extism_load_u64(offs: u64) -> u64;
-    pub fn extism_config_get(offs: u64) -> u64;
-    pub fn extism_var_get(offs: u64) -> u64;
-    pub fn extism_var_set(offs: u64, offs1: u64);
-    pub fn extism_http_request(req: u64, body: u64) -> u64;
-    pub fn extism_http_status_code() -> i32;
-    pub fn extism_log_info(offs: u64);
-    pub fn extism_log_debug(offs: u64);
-    pub fn extism_log_warn(offs: u64);
-    pub fn extism_log_error(offs: u64);
+    pub fn input_length() -> u64;
+    pub fn input_load_u8(offs: u64) -> u8;
+    pub fn input_load_u64(offs: u64) -> u64;
+    pub fn length(offs: u64) -> u64;
+    pub fn alloc(length: u64) -> u64;
+    pub fn free(offs: u64);
+    pub fn output_set(offs: u64, length: u64);
+    pub fn error_set(offs: u64);
+    pub fn store_u8(offs: u64, data: u8);
+    pub fn load_u8(offs: u64) -> u8;
+    pub fn store_u64(offs: u64, data: u64);
+    pub fn load_u64(offs: u64) -> u64;
+    pub fn config_get(offs: u64) -> u64;
+    pub fn var_get(offs: u64) -> u64;
+    pub fn var_set(offs: u64, offs1: u64);
+    pub fn http_request(req: u64, body: u64) -> u64;
+    pub fn http_status_code() -> i32;
+    pub fn log_info(offs: u64);
+    pub fn log_debug(offs: u64);
+    pub fn log_warn(offs: u64);
+    pub fn log_error(offs: u64);
 }
 
 /// Loads a byte array from Extism's memory. Only use this if you
@@ -29,7 +30,7 @@ extern "C" {
 ///
 /// * `offs` - The Extism offset pointer location to the memory
 /// * `data` - The pointer to byte slice result
-pub unsafe fn extism_load(offs: u64, data: &mut [u8]) {
+pub unsafe fn load(offs: u64, data: &mut [u8]) {
     let ptr = data.as_mut_ptr();
 
     let mut index = 0;
@@ -38,12 +39,12 @@ pub unsafe fn extism_load(offs: u64, data: &mut [u8]) {
     while index < len {
         left = len - index;
         if left < 8 {
-            data[index] = extism_load_u8(offs + index as u64);
+            data[index] = load_u8(offs + index as u64);
             index += 1;
             continue;
         }
 
-        let x = extism_load_u64(offs + index as u64);
+        let x = load_u64(offs + index as u64);
         (ptr as *mut u64).add(index / 8).write(x);
         index += 8;
     }
@@ -52,8 +53,8 @@ pub unsafe fn extism_load(offs: u64, data: &mut [u8]) {
 /// Loads the input from the host as a raw byte vec.
 /// Consider using the plugin_fn macro to automatically
 /// handle inputs as function parameters.
-pub unsafe fn extism_load_input() -> Vec<u8> {
-    let input_length = extism_input_length();
+pub unsafe fn load_input() -> Vec<u8> {
+    let input_length = input_length();
     let mut data = vec![0; input_length as usize];
 
     let mut index = 0;
@@ -62,12 +63,12 @@ pub unsafe fn extism_load_input() -> Vec<u8> {
     while index < len {
         left = len - index;
         if left < 8 {
-            data[index] = extism_input_load_u8(index as u64);
+            data[index] = input_load_u8(index as u64);
             index += 1;
             continue;
         }
 
-        let x = extism_input_load_u64(index as u64);
+        let x = input_load_u64(index as u64);
         (data.as_mut_ptr() as *mut u64).add(index / 8).write(x);
         index += 8;
     }
@@ -82,7 +83,7 @@ pub unsafe fn extism_load_input() -> Vec<u8> {
 ///
 /// * `offs` - The Extism offset pointer location to store the memory
 /// * `data` - The byte array to store at that offset
-pub unsafe fn extism_store(offs: u64, data: &[u8]) {
+pub unsafe fn store(offs: u64, data: &[u8]) {
     let ptr = data.as_ptr();
 
     let mut index = 0;
@@ -91,12 +92,12 @@ pub unsafe fn extism_store(offs: u64, data: &[u8]) {
     while index < len {
         left = len - index;
         if left < 8 {
-            extism_store_u8(offs + index as u64, data[index]);
+            store_u8(offs + index as u64, data[index]);
             index += 1;
             continue;
         }
 
-        extism_store_u64(
+        store_u64(
             offs + index as u64,
             (ptr as *const u64).add(index / 8).read(),
         );

src/http.rs

@@ -1,7 +1,7 @@
 use crate::*;
 
 /// A HttpResponse is used to wrap the memory returned by
-/// `extism_pdx::http::request`
+/// `extism_pdk::http::request`
 pub struct HttpResponse {
     memory: Memory,
     status: u16,
@@ -43,9 +43,9 @@ pub fn request<T: ToMemory>(
         None => None,
     };
     let data = body.as_ref().map(|x| x.offset()).unwrap_or(0);
-    let offs = unsafe { extism_http_request(req.offset(), data) };
-    let status = unsafe { extism_http_status_code() };
-    let len = unsafe { extism_length(offs) };
+    let offs = unsafe { extism::http_request(req.offset(), data) };
+    let status = unsafe { extism::http_status_code() };
+    let len = unsafe { extism::length(offs) };
     Ok(HttpResponse {
         memory: Memory(MemoryHandle {
             offset: offs,