Enable JS test decoder and encoder

This is a first step toward https://developer.mozilla.org/en-US/docs/Web/API/Encoding_API
The encoding crate will be required to implement the following missing features:
- Misc encodings
- BOM handling
- Substitute malformed data with a replacement character

Signed-off-by: Didier Wenzek <[email protected]>

Author: didier-wenzek

crates/extensions/tedge_flows/src/js_lib/mod.rs

@@ -0,0 +1,2 @@
+pub mod text_decoder;
+pub mod text_encoder;

crates/extensions/tedge_flows/src/js_lib/text_decoder.rs

@@ -0,0 +1,39 @@
+use rquickjs::class::Trace;
+use rquickjs::Class;
+use rquickjs::Ctx;
+use rquickjs::Exception;
+use rquickjs::JsLifetime;
+use rquickjs::Result;
+use rquickjs::TypedArray;
+
+#[derive(Clone, Trace, JsLifetime)]
+#[rquickjs::class(frozen)]
+struct TextDecoder {}
+
+pub fn init(ctx: &Ctx<'_>) {
+    let globals = ctx.globals();
+    let _ = Class::<TextDecoder>::define(&globals);
+}
+
+#[rquickjs::methods]
+impl<'js> TextDecoder {
+    #[qjs(constructor)]
+    fn new() -> TextDecoder {
+        TextDecoder {}
+    }
+
+    #[qjs(get)]
+    fn encoding(&self) -> &str {
+        "utf-8"
+    }
+
+    pub fn decode(&self, ctx: Ctx<'js>, bytes: TypedArray<'js, u8>) -> Result<String> {
+        let bytes = bytes
+            .as_bytes()
+            .ok_or(Exception::throw_message(&ctx, "ArrayBuffer is detached"))?;
+        let text = std::str::from_utf8(bytes)
+            .map_err(|err| Exception::throw_message(&ctx, &err.to_string()))?;
+
+        Ok(text.to_owned())
+    }
+}

crates/extensions/tedge_flows/src/js_lib/text_encoder.rs

@@ -0,0 +1,37 @@
+use rquickjs::class::Trace;
+use rquickjs::Class;
+use rquickjs::Ctx;
+use rquickjs::JsLifetime;
+use rquickjs::Result;
+use rquickjs::TypedArray;
+use rquickjs::Value;
+
+#[derive(Clone, Trace, JsLifetime)]
+#[rquickjs::class(frozen)]
+struct TextEncoder {}
+
+pub fn init(ctx: &Ctx<'_>) {
+    let globals = ctx.globals();
+    let _ = Class::<TextEncoder>::define(&globals);
+}
+
+#[rquickjs::methods]
+impl<'js> TextEncoder {
+    #[qjs(constructor)]
+    fn new() -> TextEncoder {
+        TextEncoder {}
+    }
+
+    #[qjs(get)]
+    fn encoding(&self) -> &str {
+        "utf-8"
+    }
+
+    pub fn encode(&self, ctx: Ctx<'js>, text: Value<'js>) -> Result<TypedArray<'js, u8>> {
+        let string = match text.as_string() {
+            None => "".to_string(),
+            Some(js_string) => js_string.to_string()?,
+        };
+        TypedArray::new(ctx.clone(), string.as_bytes())
+    }
+}

crates/extensions/tedge_flows/src/js_runtime.rs

@@ -1,3 +1,4 @@
+use crate::js_lib;
 use crate::js_script::JsScript;
 use crate::js_script::JsonValue;
 use crate::LoadError;
@@ -175,6 +176,8 @@ impl JsWorker {
     async fn run(mut self) {
         rquickjs::async_with!(self.context => |ctx| {
             console::init(&ctx);
+            js_lib::text_decoder::init(&ctx);
+            js_lib::text_encoder::init(&ctx);
             let mut modules = JsModules::new();
             while let Some(request) = self.requests.recv().await {
                 match request {

crates/extensions/tedge_flows/src/js_script.rs

@@ -514,6 +514,52 @@ export function onMessage(message) {
             .contains("Maximum call stack size exceeded"));
     }
 
+    #[tokio::test]
+    async fn using_text_decoder() {
+        let js = r#"
+export async function onMessage(message, config) {
+    const utf8decoder = new TextDecoder();
+    const encodedText = new Uint8Array([240, 159, 146, 150]);
+    return [{topic:"decoded", payload: utf8decoder.decode(encodedText)}];
+}
+        "#;
+        let (runtime, script) = runtime_with(js).await;
+
+        let input = Message::new("encoded", "content");
+        let mut output = Message::new("decoded", "💖");
+        output.timestamp = None;
+        assert_eq!(
+            script
+                .on_message(&runtime, &DateTime::now(), &input)
+                .await
+                .unwrap(),
+            vec![output]
+        );
+    }
+
+    #[tokio::test]
+    async fn using_text_encoder() {
+        let js = r#"
+export async function onMessage(message, config) {
+    const utf8encoder = new TextEncoder();
+    const encodedText = utf8encoder.encode(message.payload);
+    return [{topic:"encoded", payload: `[${encodedText}]`}];
+}
+        "#;
+        let (runtime, script) = runtime_with(js).await;
+
+        let input = Message::new("decoded", "💖");
+        let mut output = Message::new("encoded", "[240,159,146,150]");
+        output.timestamp = None;
+        assert_eq!(
+            script
+                .on_message(&runtime, &DateTime::now(), &input)
+                .await
+                .unwrap(),
+            vec![output]
+        );
+    }
+
     async fn runtime_with(js: &str) -> (JsRuntime, JsScript) {
         let mut runtime = JsRuntime::try_new().await.unwrap();
         let mut script = JsScript::new("toml".into(), 1, "js".into());

crates/extensions/tedge_flows/src/lib.rs

@@ -1,6 +1,7 @@
 mod actor;
 mod config;
 pub mod flow;
+mod js_lib;
 mod js_runtime;
 mod js_script;
 mod runtime;