Merge pull request #123 from karthik2804/redis/exec

Add support for redis `execute`

Author: karthik2804

crates/spin-js-engine/src/js_sdk/modules/spinSdk.ts

@@ -44,6 +44,7 @@ interface SpinSDK {
         send: (arg0: BaseHttpRequest) => HttpResponse
     }
     redis: {
+        execute: (address: string, args: Array< ArrayBuffer | bigint>) => undefined | string | bigint | ArrayBuffer
         get: (address: string, key: string) => ArrayBuffer
         incr: (address: string, key: string) => bigint
         publish: (address: string, channel: string, value: ArrayBuffer) => undefined

crates/spin-js-engine/src/lib.rs

@@ -17,6 +17,7 @@ use {
         http_component,
         key_value::Store,
         outbound_http, redis,
+        redis::RedisResult,
     },
     std::{
         collections::HashMap,
@@ -331,6 +332,73 @@ fn math_rand(context: &Context, _this: &Value, _args: &[Value]) -> Result<Value>
     context.value_from_f64(thread_rng().gen_range(0.0_f64..1.0))
 }
 
+fn redis_exec(context: &Context, _this: &Value, args: &[Value]) -> Result<Value> {
+    enum Parameter {
+        Int64(i64),
+        Binary(ByteBuf),
+    }
+
+    match args {
+        [address, command, arguments] => {
+            let address = &deserialize_helper(address)?;
+            let command = &deserialize_helper(command)?;
+            let mut arg = vec![];
+            if arguments.is_array() {
+                let mut props = arguments.properties()?;
+                while let Some(ref _x) = props.next_key()? {
+                    let val = props.next_value()?;
+                    if val.is_big_int() {
+                        let deserializer = &mut Deserializer::from(val.clone());
+                        let temp = i64::deserialize(deserializer)?;
+                        arg.push(Parameter::Int64(temp));
+                    } else if val.is_array_buffer() {
+                        let deserializer = &mut Deserializer::from(val.clone());
+                        let temp = ByteBuf::deserialize(deserializer)?;
+                        arg.push(Parameter::Binary(temp));
+                    } else {
+                        bail!("invalid argument type, must be bigint or arraybuffer")
+                    }
+                }
+            } else {
+                bail!("invalid argument type, must be array")
+            }
+            let results = redis::execute(
+                address,
+                command,
+                &arg.iter()
+                    .map(|arg| match arg {
+                        Parameter::Int64(v) => redis::RedisParameter::Int64(*v),
+                        Parameter::Binary(v) => redis::RedisParameter::Binary(v.deref()),
+                    })
+                    .collect::<Vec<_>>(),
+            )
+            .map_err(|_| anyhow!("Error executing Redis execute command"))?;
+            let arr = context.array_value()?;
+            for result in results.iter() {
+                match result {
+                    RedisResult::Nil => arr.append_property(context.undefined_value()?)?,
+                    RedisResult::Status(val) => {
+                        arr.append_property(context.value_from_str(&val)?)?
+                    }
+                    RedisResult::Int64(val) => {
+                        arr.append_property(context.value_from_i64(val.to_owned())?)?
+                    }
+                    RedisResult::Binary(val) => {
+                        let mut serializer = Serializer::from_context(context)?;
+                        val.serialize(&mut serializer)?;
+                        arr.append_property(serializer.value)?;
+                    }
+                }
+            }
+            return Ok(arr);
+        }
+        _ => bail!(
+            "expected a three arguments (address, command, arguments), got {} arguments",
+            args.len()
+        ),
+    }
+}
+
 fn redis_get(context: &Context, _this: &Value, args: &[Value]) -> Result<Value> {
     match args {
         [address, key] => {
@@ -680,6 +748,7 @@ fn do_init() -> Result<()> {
     redis.set_property("sadd", context.wrap_callback(redis_sadd)?)?;
     redis.set_property("smembers", context.wrap_callback(redis_smembers)?)?;
     redis.set_property("srem", context.wrap_callback(redis_srem)?)?;
+    redis.set_property("execute", context.wrap_callback(redis_exec)?)?;
 
     let kv = context.object_value()?;
     kv.set_property("open", context.wrap_callback(open_kv)?)?;

types/lib/modules/spinSdk.d.ts

@@ -27,6 +27,7 @@ interface KvStore {
 interface SpinSDK {
     config: SpinConfig;
     redis: {
+        execute: (address: string, args: Array<ArrayBuffer | bigint>) => undefined | string | bigint | ArrayBuffer;
         get: (address: string, key: string) => ArrayBuffer;
         incr: (address: string, key: string) => bigint;
         publish: (address: string, channel: string, value: ArrayBuffer) => undefined;