impl NearSchema derive macro

examples/abi/src/lib.rs

@@ -1,12 +1,13 @@
-use near_sdk::__private::schemars::JsonSchema;
-use near_sdk::borsh::{self, BorshDeserialize, BorshSchema, BorshSerialize};
-use near_sdk::near_bindgen;
+use near_sdk::borsh::{self, BorshDeserialize, BorshSerialize};
 use near_sdk::serde::{Deserialize, Serialize};
+use near_sdk::{near_bindgen, NearSchema};
 
-#[derive(JsonSchema, Serialize, Deserialize, BorshDeserialize, BorshSerialize, BorshSchema)]
+#[derive(NearSchema, Serialize, Deserialize, BorshDeserialize, BorshSerialize)]
+#[abi(json, borsh)]
 pub struct Pair(u32, u32);
 
-#[derive(JsonSchema, Serialize, Deserialize)]
+#[derive(NearSchema, Serialize, Deserialize)]
+#[abi(json, borsh)]
 pub struct DoublePair {
     first: Pair,
     second: Pair,

near-sdk-macros/src/core_impl/abi.rs

@@ -213,7 +213,7 @@ fn generate_abi_type(ty: &Type, serializer_type: &SerializerType) -> TokenStream
         },
         SerializerType::Borsh => quote! {
             near_sdk::__private::AbiType::Borsh {
-                type_schema: <#ty>::schema_container(),
+                type_schema: <#ty as near_sdk::borsh::BorshSchema>::schema_container(),
             }
         },
     }

near-sdk-macros/src/lib.rs

@@ -9,6 +9,8 @@ use proc_macro::TokenStream;
 use self::core_impl::*;
 use proc_macro2::Span;
 use quote::quote;
+#[cfg(feature = "abi")]
+use quote::ToTokens;
 use syn::visit::Visit;
 use syn::{File, ItemEnum, ItemImpl, ItemStruct, ItemTrait};
 
@@ -207,6 +209,174 @@ pub fn metadata(item: TokenStream) -> TokenStream {
     }
 }
 
+#[cfg(feature = "abi")]
+#[proc_macro_derive(NearSchema, attributes(abi, serde, borsh_skip, schemars, validate))]
+pub fn derive_near_schema(input: TokenStream) -> TokenStream {
+    let mut input = syn::parse_macro_input!(input as syn::DeriveInput);
+
+    let (mut json_schema, mut borsh_schema) = (false, false);
+    let mut type_attrs = vec![];
+    for attr in input.attrs {
+        match attr.parse_meta() {
+            // #[abi]
+            Ok(syn::Meta::Path(meta)) if meta.is_ident("abi") => {
+                return TokenStream::from(
+                    syn::Error::new_spanned(
+                        meta.into_token_stream(),
+                        "attribute requires at least one argument",
+                    )
+                    .to_compile_error(),
+                );
+            }
+            // #[abi(json, borsh)]
+            Ok(syn::Meta::List(meta)) if meta.path.is_ident("abi") => {
+                // #[abi()]
+                if meta.nested.is_empty() {
+                    return TokenStream::from(
+                        syn::Error::new_spanned(
+                            meta.into_token_stream(),
+                            "attribute requires at least one argument",
+                        )
+                        .to_compile_error(),
+                    );
+                }
+                json_schema = false;
+                for meta in meta.nested {
+                    match meta {
+                        syn::NestedMeta::Meta(m) if m.path().is_ident("json") => json_schema = true,
+                        syn::NestedMeta::Meta(m) if m.path().is_ident("borsh") => {
+                            borsh_schema = true
+                        }
+                        _ => {
+                            return TokenStream::from(
+                                syn::Error::new_spanned(
+                                    meta.into_token_stream(),
+                                    format!("invalid argument, expected: `json` or `borsh`",),
+                                )
+                                .to_compile_error(),
+                            );
+                        }
+                    }
+                }
+            }
+            // #[serde(..)], #[schemars(..)]
+            Ok(syn::Meta::List(meta))
+                if meta.path.is_ident("serde") || meta.path.is_ident("schemars") =>
+            {
+                type_attrs.push(attr)
+            }
+            _ => continue,
+        }
+    }
+    input.attrs = type_attrs;
+
+    let strip_unknown_attr = |attrs: &mut Vec<syn::Attribute>| {
+        attrs.retain(|attr| {
+            [
+                (json_schema, &["serde", "schemars", "validate"][..]),
+                (borsh_schema, &["borsh_skip"][..]),
+            ]
+            .iter()
+            .any(|&(case, paths)| case && paths.iter().any(|path| attr.path.is_ident(path)))
+        });
+    };
+
+    match &mut input.data {
+        syn::Data::Struct(data) => {
+            for field in &mut data.fields {
+                strip_unknown_attr(&mut field.attrs);
+            }
+        }
+        syn::Data::Enum(data) => {
+            for variant in &mut data.variants {
+                strip_unknown_attr(&mut variant.attrs);
+                for field in &mut variant.fields {
+                    strip_unknown_attr(&mut field.attrs);
+                }
+            }
+        }
+        syn::Data::Union(_) => {
+            return TokenStream::from(
+                syn::Error::new(Span::call_site(), "Near schema does not support unions yet.")
+                    .to_compile_error(),
+            );
+        }
+    }
+
+    let derive = match (json_schema, borsh_schema) {
+        // <unspecified> or #[abi(json)]
+        (_, false) => quote! {
+            #[derive(schemars::JsonSchema)]
+        },
+        // #[abi(borsh)]
+        (false, true) => quote! {
+            #[derive(borsh::BorshSchema)]
+        },
+        // #[abi(json, borsh)]
+        (true, true) => quote! {
+            #[derive(schemars::JsonSchema, borsh::BorshSchema)]
+        },
+    };
+
+    let input_ident = &input.ident;
+
+    let json_impl = if json_schema {
+        quote! {
+            #[automatically_derived]
+            impl schemars::JsonSchema for super::#input_ident {
+                fn schema_name() -> ::std::string::String {
+                    stringify!(#input_ident).to_string()
+                }
+
+                fn json_schema(gen: &mut schemars::gen::SchemaGenerator) -> schemars::schema::Schema {
+                    <#input_ident as schemars::JsonSchema>::json_schema(gen)
+                }
+            }
+        }
+    } else {
+        quote! {}
+    };
+
+    let borsh_impl = if borsh_schema {
+        quote! {
+            #[automatically_derived]
+            impl borsh::BorshSchema for super::#input_ident {
+                fn declaration() -> ::std::string::String {
+                    stringify!(#input_ident).to_string()
+                }
+
+                fn add_definitions_recursively(
+                    definitions: &mut borsh::maybestd::collections::HashMap<
+                        borsh::schema::Declaration,
+                        borsh::schema::Definition,
+                    >,
+                ) {
+                    <#input_ident as borsh::BorshSchema>::add_definitions_recursively(definitions);
+                }
+            }
+        }
+    } else {
+        quote! {}
+    };
+
+    TokenStream::from(quote! {
+        #[cfg(not(target_arch = "wasm32"))]
+        const _: () = {
+            mod __near_abi_private {
+                use super::*;
+                use near_sdk::borsh;
+                use near_sdk::__private::schemars;
+
+                #derive
+                #input
+
+                #json_impl
+                #borsh_impl
+            }
+        };
+    })
+}
+
 /// `PanicOnDefault` generates implementation for `Default` trait that panics with the following
 /// message `The contract is not initialized` when `default()` is called.
 /// This is a helpful macro in case the contract is required to be initialized with either `init` or

near-sdk/src/lib.rs

@@ -5,6 +5,8 @@
 #[cfg(test)]
 extern crate quickcheck;
 
+#[cfg(feature = "abi")]
+pub use near_sdk_macros::NearSchema;
 pub use near_sdk_macros::{
     ext_contract, metadata, near_bindgen, BorshStorageKey, FunctionError, PanicOnDefault,
 };