diff --git a/implementations/wrap-rust/URI.txt b/implementations/wrap-rust/URI.txt index 6160c7c4..ef0ad527 100644 --- a/implementations/wrap-rust/URI.txt +++ b/implementations/wrap-rust/URI.txt @@ -1 +1 @@ -wrap://ipfs/QmNenpmWMFM5DUAp4G2NpDRc3WMFo2R3BrBYcgMNCU8Vwp \ No newline at end of file +wrap://ipfs/QmS77xZ1j3i9jsNMkwm1HCYHrDzztZwSVkgXFd1bxzHMnp \ No newline at end of file diff --git a/implementations/wrap-rust/build/wrap.wasm b/implementations/wrap-rust/build/wrap.wasm index f7005a0b..51154ba4 100755 Binary files a/implementations/wrap-rust/build/wrap.wasm and b/implementations/wrap-rust/build/wrap.wasm differ diff --git a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/custom_type/mod.rs b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/custom_type/mod.rs index 2e53a74f..041745d4 100644 --- a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/custom_type/mod.rs +++ b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/custom_type/mod.rs @@ -117,11 +117,11 @@ impl CustomType { u_opt_array_opt_array: vec![], u_array_opt_array_array: vec![], crazy_array: None, - object: Option::new(), + object: AnotherType::new(), opt_object: None, object_array: vec![], opt_object_array: None, - en: Option::_MAX_, + en: CustomEnum::_MAX_, opt_enum: None, enum_array: vec![], opt_enum_array: None, diff --git a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_env/mod.rs b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_env/mod.rs index ea2dfd1b..e4c9f5fd 100644 --- a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_env/mod.rs +++ b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_env/mod.rs @@ -29,11 +29,11 @@ impl TestImportEnv { pub fn new() -> TestImportEnv { TestImportEnv { - object: Option::new(), + object: TestImportAnotherObject::new(), opt_object: None, object_array: vec![], opt_object_array: None, - en: Option::_MAX_, + en: TestImportEnum::_MAX_, opt_enum: None, enum_array: vec![], opt_enum_array: None, diff --git a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_object/mod.rs b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_object/mod.rs index b40e4db3..f0fbed2b 100644 --- a/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_object/mod.rs +++ b/implementations/wrap-rust/src/__tests__/cases/000-sanity/output/imported/test_import_object/mod.rs @@ -35,11 +35,11 @@ impl TestImportObject { pub fn new() -> TestImportObject { TestImportObject { - object: Option::new(), + object: TestImportAnotherObject::new(), opt_object: None, object_array: vec![], opt_object_array: None, - en: Option::_MAX_, + en: TestImportEnum::_MAX_, opt_enum: None, enum_array: vec![], opt_enum_array: None, diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/input.graphql b/implementations/wrap-rust/src/__tests__/cases/002-object-types/input.graphql index 0aa7c068..e2cc28dd 100644 --- a/implementations/wrap-rust/src/__tests__/cases/002-object-types/input.graphql +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/input.graphql @@ -66,3 +66,24 @@ type CustomMapValue { type else { else: String! } + + +type Module { + method( + arg: Arg! + ): Output! +} + +type Arg { + prop: String! + nested: Nested! +} + +type Nested { + prop: String! +} + +type Output { + prop: String! + nested: Nested! +} \ No newline at end of file diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/arg/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/arg/mod.rs new file mode 100644 index 00000000..eb5eb30d --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/arg/mod.rs @@ -0,0 +1,27 @@ +use serde::{Serialize, Deserialize}; +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; +use crate::Nested; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct Arg { + pub prop: String, + pub nested: Nested, +} + +impl Arg { + pub fn new() -> Arg { + Arg { + prop: String::new(), + nested: Nested::new(), + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/custom_type/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/custom_type/mod.rs index 413b6366..c1308bdf 100644 --- a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/custom_type/mod.rs +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/custom_type/mod.rs @@ -109,7 +109,7 @@ impl CustomType { u_opt_array_opt_array: vec![], u_array_opt_array_array: vec![], crazy_array: None, - object: Option::new(), + object: AnotherType::new(), opt_object: None, object_array: vec![], opt_object_array: None, diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/entry.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/entry.rs index 640d46b3..fa5b9a6f 100644 --- a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/entry.rs +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/entry.rs @@ -1,3 +1,6 @@ +use crate::{ + method_wrapped +}; use polywrap_wasm_rs::{ abort, invoke, @@ -13,6 +16,9 @@ pub extern "C" fn _wrap_invoke(method_size: u32, args_size: u32, env_size: u32) let result: Vec; match args.method.as_str() { + "method" => { + result = method_wrapped(args.args.as_slice(), env_size); + } _ => { invoke::wrap_invoke_error(format!("Could not find invoke function {}", args.method)); return false; diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/mod.rs index 6f9f9379..1f3d3f12 100644 --- a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/mod.rs +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/mod.rs @@ -7,7 +7,20 @@ pub mod custom_map_value; pub use custom_map_value::CustomMapValue; pub mod _else; pub use _else::Else; +pub mod arg; +pub use arg::Arg; +pub mod nested; +pub use nested::Nested; +pub mod output; +pub use output::Output; +pub mod module; +pub use module::{ + Module, + ModuleTrait, + method_wrapped, + ArgsMethod +}; // Override print!(...) & println!(...) macros #[macro_export] diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/mod.rs new file mode 100644 index 00000000..d68fec33 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/mod.rs @@ -0,0 +1,8 @@ +pub mod wrapped; +pub use wrapped::{ + method_wrapped, + ArgsMethod +}; + +pub mod module; +pub use module::*; diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/module.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/module.rs new file mode 100644 index 00000000..9a212678 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/module.rs @@ -0,0 +1,21 @@ +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; +use crate::{ + ArgsMethod, +}; +use crate::Arg; +use crate::Output; + +pub struct Module; + +pub trait ModuleTrait { + fn method(args: ArgsMethod) -> Result; +} diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/wrapped.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/wrapped.rs new file mode 100644 index 00000000..e98b5a62 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/module/wrapped.rs @@ -0,0 +1,43 @@ +use serde::{Deserialize, Serialize}; +use polywrap_msgpack_serde::{ + from_slice, + to_vec, + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON, + wrap_load_env +}; +use crate::module::{ModuleTrait, Module}; +use crate::Arg; +use crate::Output; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct ArgsMethod { + pub arg: Arg, +} + +pub fn method_wrapped(args: &[u8], env_size: u32) -> Vec { + match from_slice::(args) { + Ok(args) => { + let result = Module::method(ArgsMethod { + arg: args.arg, + }); + match result { + Ok(res) => { + to_vec(&res).unwrap() + } + Err(e) => { + panic!("{}", e.to_string()) + } + } + } + Err(e) => { + panic!("{}", e.to_string()) + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/nested/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/nested/mod.rs new file mode 100644 index 00000000..b645bc6c --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/nested/mod.rs @@ -0,0 +1,24 @@ +use serde::{Serialize, Deserialize}; +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct Nested { + pub prop: String, +} + +impl Nested { + pub fn new() -> Nested { + Nested { + prop: String::new(), + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/output/mod.rs b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/output/mod.rs new file mode 100644 index 00000000..957bc049 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/002-object-types/output/output/mod.rs @@ -0,0 +1,27 @@ +use serde::{Serialize, Deserialize}; +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; +use crate::Nested; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct Output { + pub prop: String, + pub nested: Nested, +} + +impl Output { + pub fn new() -> Output { + Output { + prop: String::new(), + nested: Nested::new(), + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/input.graphql b/implementations/wrap-rust/src/__tests__/cases/003-env-types/input.graphql new file mode 100644 index 00000000..dd756df3 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/input.graphql @@ -0,0 +1,47 @@ +scalar UInt +scalar UInt8 +scalar UInt16 +scalar UInt32 +scalar Int +scalar Int8 +scalar Int16 +scalar Int32 +scalar Bytes +scalar BigInt +scalar BigNumber +scalar JSON +scalar Map + +type EnvObject { + prop: String! +} + +enum EnvEnum { + FIRST + SECOND +} + +type Env { + str: String! + optStr: String + optFilledStr: String + number: Int8! + optNumber: Int8 + bool: Boolean! + optBool: Boolean + en: EnvEnum! + optEnum: EnvEnum + object: EnvObject! + optObject: EnvObject + array: [UInt32!]! +} + +type Module { + methodNoEnv( + arg: String! + ): String! + + methodRequireEnv: Env! @env(required: true) + + methodOptionalEnv: Env @env(required: false) +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/entry.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/entry.rs new file mode 100644 index 00000000..6cf69b3e --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/entry.rs @@ -0,0 +1,37 @@ +use crate::{ + method_no_env_wrapped, + method_require_env_wrapped, + method_optional_env_wrapped +}; +use polywrap_wasm_rs::{ + abort, + invoke, + InvokeArgs, +}; + +#[no_mangle] +pub extern "C" fn _wrap_invoke(method_size: u32, args_size: u32, env_size: u32) -> bool { + // Ensure the abort handler is properly setup + abort::wrap_abort_setup(); + + let args: InvokeArgs = invoke::wrap_invoke_args(method_size, args_size); + let result: Vec; + + match args.method.as_str() { + "methodNoEnv" => { + result = method_no_env_wrapped(args.args.as_slice(), env_size); + } + "methodRequireEnv" => { + result = method_require_env_wrapped(args.args.as_slice(), env_size); + } + "methodOptionalEnv" => { + result = method_optional_env_wrapped(args.args.as_slice(), env_size); + } + _ => { + invoke::wrap_invoke_error(format!("Could not find invoke function {}", args.method)); + return false; + } + }; + invoke::wrap_invoke_result(result); + return true; +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env/mod.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env/mod.rs new file mode 100644 index 00000000..aa696b68 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env/mod.rs @@ -0,0 +1,54 @@ +use serde::{Serialize, Deserialize}; +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; +use crate::EnvEnum; +use crate::EnvObject; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct Env { + pub str: String, + #[serde(rename = "optStr")] + pub opt_str: Option, + #[serde(rename = "optFilledStr")] + pub opt_filled_str: Option, + pub number: i8, + #[serde(rename = "optNumber")] + pub opt_number: Option, + pub bool: bool, + #[serde(rename = "optBool")] + pub opt_bool: Option, + pub en: EnvEnum, + #[serde(rename = "optEnum")] + pub opt_enum: Option, + pub object: EnvObject, + #[serde(rename = "optObject")] + pub opt_object: Option, + pub array: Vec, +} + +impl Env { + pub fn new() -> Env { + Env { + str: String::new(), + opt_str: None, + opt_filled_str: None, + number: 0, + opt_number: None, + bool: false, + opt_bool: None, + en: EnvEnum::_MAX_, + opt_enum: None, + object: EnvObject::new(), + opt_object: None, + array: vec![], + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_enum/mod.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_enum/mod.rs new file mode 100644 index 00000000..c33e3439 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_enum/mod.rs @@ -0,0 +1,53 @@ +use polywrap_wasm_rs::{EnumTypeError}; +use serde::{Serialize, Deserialize}; +use std::convert::TryFrom; + +#[derive(Clone, Copy, Debug, Deserialize, Serialize)] +pub enum EnvEnum { + #[serde(rename = "FIRST")] + FIRST, + #[serde(rename = "SECOND")] + SECOND, + _MAX_ +} + +pub fn sanitize_env_enum_value(value: i32) -> Result<(), EnumTypeError> { + if value < 0 && value >= EnvEnum::_MAX_ as i32 { + return Err(EnumTypeError::EnumProcessingError(format!("Invalid value for enum 'EnvEnum': {}", value.to_string()))); + } + Ok(()) +} + +pub fn get_env_enum_value(key: &str) -> Result { + match key { + "FIRST" => Ok(EnvEnum::FIRST), + "SECOND" => Ok(EnvEnum::SECOND), + "_MAX_" => Ok(EnvEnum::_MAX_), + err => Err(EnumTypeError::EnumProcessingError(format!("Invalid key for enum 'EnvEnum': {}", err))) + } +} + +pub fn get_env_enum_key(value: EnvEnum) -> Result { + if sanitize_env_enum_value(value as i32).is_ok() { + match value { + EnvEnum::FIRST => Ok("FIRST".to_string()), + EnvEnum::SECOND => Ok("SECOND".to_string()), + EnvEnum::_MAX_ => Ok("_MAX_".to_string()), + } + } else { + Err(EnumTypeError::EnumProcessingError(format!("Invalid value for enum 'EnvEnum': {}", (value as i32).to_string()))) + } +} + +impl TryFrom for EnvEnum { + type Error = EnumTypeError; + + fn try_from(v: i32) -> Result { + match v { + x if x == EnvEnum::FIRST as i32 => Ok(EnvEnum::FIRST), + x if x == EnvEnum::SECOND as i32 => Ok(EnvEnum::SECOND), + x if x == EnvEnum::_MAX_ as i32 => Ok(EnvEnum::_MAX_), + _ => Err(EnumTypeError::ParseEnumError(format!("Invalid value for enum 'EnvEnum': {}", (v as i32).to_string()))), + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_object/mod.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_object/mod.rs new file mode 100644 index 00000000..317f9e31 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/env_object/mod.rs @@ -0,0 +1,24 @@ +use serde::{Serialize, Deserialize}; +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct EnvObject { + pub prop: String, +} + +impl EnvObject { + pub fn new() -> EnvObject { + EnvObject { + prop: String::new(), + } + } +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/mod.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/mod.rs new file mode 100644 index 00000000..5b3edfd0 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/mod.rs @@ -0,0 +1,30 @@ +pub mod entry; +pub mod env_object; +pub use env_object::EnvObject; +pub mod env_enum; +pub use env_enum::{ + get_env_enum_key, + get_env_enum_value, + sanitize_env_enum_value, + EnvEnum +}; +pub mod env; +pub use env::Env; + +pub mod module; +pub use module::{ + Module, + ModuleTrait, + method_no_env_wrapped, + ArgsMethodNoEnv, + method_require_env_wrapped, + ArgsMethodRequireEnv, + method_optional_env_wrapped, + ArgsMethodOptionalEnv +}; + +// Override print!(...) & println!(...) macros +#[macro_export] +macro_rules! println { ($($args:tt)*) => { polywrap_wasm_rs::wrap_debug_log(format!($($args)*).as_str()); } } +#[macro_export] +macro_rules! print { ($($args:tt)*) => { polywrap_wasm_rs::wrap_debug_log(format!($($args)*).as_str()); } } diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/mod.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/mod.rs new file mode 100644 index 00000000..cffb22b3 --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/mod.rs @@ -0,0 +1,12 @@ +pub mod wrapped; +pub use wrapped::{ + method_no_env_wrapped, + ArgsMethodNoEnv, + method_require_env_wrapped, + ArgsMethodRequireEnv, + method_optional_env_wrapped, + ArgsMethodOptionalEnv +}; + +pub mod module; +pub use module::*; diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/module.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/module.rs new file mode 100644 index 00000000..d916a57f --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/module.rs @@ -0,0 +1,26 @@ +use polywrap_msgpack_serde::{ + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON +}; +use crate::{ + ArgsMethodNoEnv, + ArgsMethodRequireEnv, + ArgsMethodOptionalEnv, +}; +use crate::env::Env; + +pub struct Module; + +pub trait ModuleTrait { + fn method_no_env(args: ArgsMethodNoEnv) -> Result; + + fn method_require_env(args: ArgsMethodRequireEnv, env: Env) -> Result; + + fn method_optional_env(args: ArgsMethodOptionalEnv, env: Option) -> Result, String>; +} diff --git a/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/wrapped.rs b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/wrapped.rs new file mode 100644 index 00000000..56b702bd --- /dev/null +++ b/implementations/wrap-rust/src/__tests__/cases/003-env-types/output/module/wrapped.rs @@ -0,0 +1,89 @@ +use serde::{Deserialize, Serialize}; +use polywrap_msgpack_serde::{ + from_slice, + to_vec, + wrappers::polywrap_json::JSONString, + wrappers::polywrap_bigint::BigIntWrapper +}; +use polywrap_wasm_rs::{ + BigInt, + BigNumber, + Map, + JSON, + wrap_load_env +}; +use crate::module::{ModuleTrait, Module}; +use crate::Env; + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct ArgsMethodNoEnv { + pub arg: String, +} + +pub fn method_no_env_wrapped(args: &[u8], env_size: u32) -> Vec { + match from_slice::(args) { + Ok(args) => { + let result = Module::method_no_env(ArgsMethodNoEnv { + arg: args.arg, + }); + match result { + Ok(res) => { + to_vec(&res).unwrap() + } + Err(e) => { + panic!("{}", e.to_string()) + } + } + } + Err(e) => { + panic!("{}", e.to_string()) + } + } +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct ArgsMethodRequireEnv { +} + +pub fn method_require_env_wrapped(args: &[u8], env_size: u32) -> Vec { + if env_size == 0 { + panic!("Environment is not set, and it is required by method 'methodRequireEnv'"); + } + + let env_buf = wrap_load_env(env_size); + let env = Env::from_buffer(&env_buf).unwrap(); + + let result = Module::method_require_env(ArgsMethodRequireEnv { + }, env); + match result { + Ok(res) => { + to_vec(&res).unwrap() + } + Err(e) => { + panic!("{}", e.to_string()) + } + } +} + +#[derive(Clone, Debug, Deserialize, Serialize)] +pub struct ArgsMethodOptionalEnv { +} + +pub fn method_optional_env_wrapped(args: &[u8], env_size: u32) -> Vec { + let mut env: Option = None; + if env_size > 0 { + let env_buf = wrap_load_env(env_size); + env = Some(Env::from_buffer(&env_buf).unwrap()); + } + + let result = Module::method_optional_env(ArgsMethodOptionalEnv { + }, env); + match result { + Ok(res) => { + to_vec(&res).unwrap() + } + Err(e) => { + panic!("{}", e.to_string()) + } + } +} diff --git a/implementations/wrap-rust/src/helpers/property_deps.rs b/implementations/wrap-rust/src/helpers/property_deps.rs index bede4248..3cf97015 100644 --- a/implementations/wrap-rust/src/helpers/property_deps.rs +++ b/implementations/wrap-rust/src/helpers/property_deps.rs @@ -138,5 +138,5 @@ fn append_unique(vec: &mut Vec, item: PropertyDep) { } fn is_known_type(name: &str, root_type: &str) -> bool { - is_base_type(name) || is_builtin_type(name) || name == root_type + is_base_type(name) || is_builtin_type(name) || name == root_type || name == "Env" } diff --git a/implementations/wrap-rust/src/helpers/to_rust_init.rs b/implementations/wrap-rust/src/helpers/to_rust_init.rs index 3aea8aef..efa36190 100644 --- a/implementations/wrap-rust/src/helpers/to_rust_init.rs +++ b/implementations/wrap-rust/src/helpers/to_rust_init.rs @@ -39,7 +39,11 @@ pub fn _to_rust_init(value: &str) -> String { "BigNumber" => optional_modifier("BigNumber::default()", optional), "JSON" => optional_modifier("JSONString::from(JSON::Value::Null)", optional), _ => { - let rs_type = _to_rust(&type_str); + let rs_type = match optional { + true => _to_rust(&type_str), + false => _to_rust(format!("{}!", &type_str).as_str()) + }; + if type_str.starts_with("Enum_") { optional_modifier(&format!("{}::_MAX_", rs_type), optional) } else {