@dashevo/wasm-dpp 0.23.0-dev.14 → 0.24.0-dev.10

package/src/data_contract/data_contract.rs

@@ -0,0 +1,290 @@
+#![allow(clippy::from_over_into)]
+
+use std::collections::BTreeMap;
+use std::convert::{TryFrom, TryInto};
+
+pub use serde::{Deserialize, Serialize};
+use serde_json::Value;
+use wasm_bindgen::prelude::*;
+
+use dpp::data_contract::{DataContract, SCHEMA_URI};
+use dpp::util::string_encoding::Encoding;
+
+use crate::errors::{from_dpp_err, RustConversionError};
+use crate::metadata::MetadataWasm;
+use crate::{bail_js, with_js_error};
+use crate::{buffer::Buffer, identifier::IdentifierWrapper};
+
+#[wasm_bindgen(js_name=DataContract)]
+#[derive(Debug, Clone)]
+pub struct DataContractWasm(DataContract);
+
+impl std::convert::From<DataContract> for DataContractWasm {
+    fn from(v: DataContract) -> Self {
+        DataContractWasm(v)
+    }
+}
+
+impl std::convert::Into<DataContract> for DataContractWasm {
+    fn into(self) -> DataContract {
+        self.0
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DataContractParameters {
+    #[serde(rename = "$schema")]
+    schema: String,
+    #[serde(rename = "$id")]
+    id: Vec<u8>,
+    owner_id: Vec<u8>,
+    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
+    documents: serde_json::Value,
+    #[serde(
+        skip_serializing_if = "serde_json::Value::is_null",
+        default,
+        rename = "$defs"
+    )]
+    defs: serde_json::Value,
+    protocol_version: u32,
+    version: u32,
+}
+
+#[wasm_bindgen(js_class=DataContract)]
+impl DataContractWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<DataContractWasm, JsValue> {
+        let parameters: DataContractParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        DataContract::from_raw_object(
+            serde_json::to_value(parameters).expect("Implements Serialize"),
+        )
+        .map_err(from_dpp_err)
+        .map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.owner_id.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getVersion)]
+    pub fn get_version(&self) -> u32 {
+        self.0.version
+    }
+
+    #[wasm_bindgen(js_name=setVersion)]
+    pub fn set_version(&mut self, v: u32) {
+        self.0.version = v;
+    }
+
+    #[wasm_bindgen(js_name=incrementVersion)]
+    pub fn increment_version(&mut self) {
+        self.0.increment_version()
+    }
+
+    #[wasm_bindgen(js_name=getJsonSchemaId)]
+    pub fn get_json_schema_id(&self) -> String {
+        self.0.id.to_string(Encoding::Base58)
+    }
+
+    #[wasm_bindgen(js_name=setJsonMetaSchema)]
+    pub fn set_json_meta_schema(&mut self, schema: String) {
+        self.0.schema = schema;
+    }
+
+    #[wasm_bindgen(js_name=getJsonMetaSchema)]
+    pub fn get_json_meta_schema(&self) -> String {
+        self.0.schema.clone()
+    }
+    #[wasm_bindgen(js_name=setDocuments)]
+    pub fn set_documents(&mut self, documents: JsValue) -> Result<(), JsValue> {
+        let json_value: Value = with_js_error!(serde_wasm_bindgen::from_value(documents))?;
+
+        let mut docs: BTreeMap<String, Value> = BTreeMap::new();
+        if let Value::Object(o) = json_value {
+            for (k, v) in o.into_iter() {
+                if !v.is_object() {
+                    bail_js!("is not an object")
+                }
+                docs.insert(k, v);
+            }
+            self.0.documents = docs;
+        } else {
+            bail_js!("the parameter 'documents' is not an JS object")
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDocuments)]
+    pub fn get_documents(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.documents.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=isDocumentDefined)]
+    pub fn is_document_defined(&self, doc_type: String) -> bool {
+        self.0.is_document_defined(&doc_type)
+    }
+
+    #[wasm_bindgen(js_name=setDocumentSchema)]
+    pub fn set_document_schema(
+        &mut self,
+        doc_type: String,
+        schema: JsValue,
+    ) -> Result<(), JsValue> {
+        let json_schema: Value = with_js_error!(serde_wasm_bindgen::from_value(schema))?;
+        self.0.set_document_schema(doc_type, json_schema);
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchema)]
+    pub fn get_document_schema(&mut self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let doc_schema = self.0.get_document_schema(doc_type).map_err(from_dpp_err)?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(doc_schema.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchemaRef)]
+    pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        with_js_error!(serde_wasm_bindgen::to_value(
+            &self
+                .0
+                .get_document_schema_ref(doc_type)
+                .map_err(from_dpp_err)?
+        ))
+    }
+
+    #[wasm_bindgen(js_name=setDefinitions)]
+    pub fn set_definitions(&mut self, definitions: JsValue) -> Result<(), JsValue> {
+        let json_value: Value = with_js_error!(serde_wasm_bindgen::from_value(definitions))?;
+        let mut definitions: BTreeMap<String, Value> = BTreeMap::new();
+        if let Value::Object(o) = json_value {
+            for (k, v) in o.into_iter() {
+                // v must be a Object
+                if !v.is_object() {
+                    bail_js!("{:?} is not an object", v);
+                }
+                definitions.insert(k, v);
+            }
+            if definitions.is_empty() {
+                bail_js!("`defitions` cannot be empty");
+            }
+            self.0.defs = Some(definitions);
+        } else {
+            bail_js!("the parameter 'definitions' is not an JS object");
+        }
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getDefinitions)]
+    pub fn get_definitions(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.defs.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=setEntropy)]
+    pub fn set_entropy(&mut self, e: Vec<u8>) -> Result<(), JsValue> {
+        let entropy: [u8; 32] = e.try_into().map_err(|_| {
+            RustConversionError::Error(String::from(
+                "unable to turn the data into 32 bytes array of bytes",
+            ))
+            .to_js_value()
+        })?;
+        self.0.entropy = entropy;
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&mut self) -> Buffer {
+        Buffer::from_bytes(&self.0.entropy)
+    }
+
+    #[wasm_bindgen(js_name=getBinaryProperties)]
+    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self
+            .0
+            .get_binary_properties(doc_type)
+            .map_err(from_dpp_err)?
+            .serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.0.metadata.clone().map(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=setMetadata)]
+    pub fn set_metadata(&mut self, metadata: MetadataWasm) {
+        self.0.metadata = Some(metadata.into());
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let object = with_js_error!(self.0.serialize(&serializer))?;
+
+        js_sys::Reflect::set(
+            &object,
+            &Into::<JsValue>::into("$id".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes(&self.0.id.buffer)),
+        )
+        .expect("target is an object");
+        js_sys::Reflect::set(
+            &object,
+            &Into::<JsValue>::into("ownerId".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes(&self.0.owner_id.buffer)),
+        )
+        .expect("target is an object");
+        Ok(object)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        with_js_error!(self.0.serialize(&serializer))
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = self.0.to_buffer().map_err(from_dpp_err)?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.hash().map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=from)]
+    pub fn from(v: JsValue) -> Result<DataContractWasm, JsValue> {
+        let json_contract: Value = with_js_error!(serde_wasm_bindgen::from_value(v))?;
+        Ok(DataContract::try_from(json_contract)
+            .map_err(from_dpp_err)?
+            .into())
+    }
+}
+
+#[wasm_bindgen(js_name=DataContractDefaults)]
+pub struct DataContractDefaults;
+
+#[wasm_bindgen(js_class=DataContractDefaults)]
+impl DataContractDefaults {
+    #[wasm_bindgen(getter = SCHEMA)]
+    pub fn get_default_schema() -> String {
+        SCHEMA_URI.to_string()
+    }
+}

package/src/data_contract/errors/data_contract_already_exists.rs

@@ -0,0 +1 @@
+// TODO: Implement

package/src/data_contract/errors/invalid_data_contract.rs

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDataContractError)]
+#[derive(Debug)]
+pub struct InvalidDataContractError {
+    // we have to store it as JsValue as the errors of 'class' Consensus are of different types
+    errors: Vec<JsValue>,
+    raw_data_contract: JsValue,
+}
+
+#[wasm_bindgen(js_class=InvalidDataContractError)]
+impl InvalidDataContractError {
+    pub fn new(errors: Vec<JsValue>, raw_data_contract: JsValue) -> Self {
+        InvalidDataContractError {
+            errors,
+            raw_data_contract,
+        }
+    }
+
+    #[wasm_bindgen(js_name=getErrors)]
+    pub fn get_errors(&self) -> Vec<JsValue> {
+        self.errors.clone().into_iter().map(JsValue::from).collect()
+    }
+
+    #[wasm_bindgen(js_name=getRawDataContract)]
+    pub fn get_raw_data_contract(&self) -> JsValue {
+        self.raw_data_contract.clone()
+    }
+}

package/src/data_contract/errors/invalid_document_type.rs

@@ -0,0 +1,33 @@
+use thiserror::Error;
+use wasm_bindgen::prelude::*;
+
+use crate::DataContractWasm;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Invalid Document Type")]
+pub struct InvalidDocumentTypeInDataContractError {
+    // we have to store it as JsValue as the errors of 'class' Consensus are of different types
+    doc_type: String,
+    data_contract: DataContractWasm,
+}
+
+#[wasm_bindgen]
+impl InvalidDocumentTypeInDataContractError {
+    #[wasm_bindgen(constructor)]
+    pub fn new(doc_type: String, data_contract: DataContractWasm) -> Self {
+        InvalidDocumentTypeInDataContractError {
+            doc_type,
+            data_contract,
+        }
+    }
+    #[wasm_bindgen(js_name = "getDocType")]
+    pub fn get_doc_type(&self) -> String {
+        self.doc_type.clone()
+    }
+
+    #[wasm_bindgen(js_name = "getDataContract")]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.data_contract.clone()
+    }
+}

package/src/data_contract/errors/mod.rs

@@ -0,0 +1,37 @@
+mod data_contract_already_exists;
+mod invalid_data_contract;
+mod invalid_document_type;
+
+use wasm_bindgen::prelude::*;
+
+use crate::errors::consensus_error::from_consensus_error;
+pub use data_contract_already_exists::*;
+use dpp::data_contract::errors::DataContractError;
+pub use invalid_data_contract::*;
+
+pub fn from_data_contract_to_js_error(e: DataContractError) -> JsValue {
+    match e {
+        DataContractError::InvalidDataContractError {
+            errors,
+            raw_data_contract,
+        } => {
+            let js_errors = errors.into_iter().map(from_consensus_error).collect();
+
+            InvalidDataContractError::new(
+                js_errors,
+                serde_wasm_bindgen::to_value(&raw_data_contract)
+                    .expect("statically known structure should be a valid JSON"),
+            )
+            .into()
+        }
+        DataContractError::InvalidDocumentTypeError {
+            doc_type,
+            data_contract,
+        } => invalid_document_type::InvalidDocumentTypeInDataContractError::new(
+            doc_type,
+            data_contract.into(),
+        )
+        .into(),
+        _ => todo!(),
+    }
+}

package/src/data_contract/index.rs

@@ -0,0 +1,61 @@
+use dpp::{data_contract::extra::IndexProperty, util::json_schema::Index};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IndexProperty)]
+#[derive(Debug, Clone)]
+pub struct IndexPropertyWasm {
+    inner: IndexProperty,
+}
+
+impl From<IndexProperty> for IndexPropertyWasm {
+    fn from(v: IndexProperty) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=IndexProperty)]
+impl IndexPropertyWasm {
+    #[wasm_bindgen(js_name=getName)]
+    pub fn get_name(&self) -> String {
+        self.inner.name.clone()
+    }
+
+    #[wasm_bindgen(js_name=isAscending)]
+    pub fn is_ascending(&self) -> bool {
+        self.inner.ascending
+    }
+}
+
+#[wasm_bindgen(js_name=IndexDefinition)]
+#[derive(Debug, Clone)]
+pub struct IndexDefinitionWasm {
+    inner: Index,
+}
+
+impl From<Index> for IndexDefinitionWasm {
+    fn from(v: Index) -> Self {
+        Self { inner: v }
+    }
+}
+
+#[wasm_bindgen(js_class=IndexDefinition)]
+impl IndexDefinitionWasm {
+    #[wasm_bindgen(js_name=getName)]
+    pub fn get_name(&self) -> String {
+        self.inner.name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getProperties)]
+    pub fn get_properties(&self) -> Vec<JsValue> {
+        self.inner
+            .properties
+            .iter()
+            .map(|property| IndexPropertyWasm::from(property.clone()).into())
+            .collect::<Vec<JsValue>>()
+    }
+
+    #[wasm_bindgen(js_name=isUnique)]
+    pub fn is_unique(&self) -> bool {
+        self.inner.unique
+    }
+}

package/src/data_contract/mod.rs

@@ -0,0 +1,10 @@
+#![allow(clippy::module_inception)]
+pub use data_contract::*;
+pub use state_transition::*;
+
+mod data_contract;
+pub mod errors;
+mod state_transition;
+
+mod index;
+pub use index::*;

package/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -0,0 +1,37 @@
+use dpp::data_contract::state_transition::DataContractCreateTransition;
+use wasm_bindgen::prelude::*;
+
+use crate::{buffer::Buffer, DataContractWasm};
+
+#[wasm_bindgen(js_name=DataContractCreateTransition)]
+pub struct DataContractCreateTransitionWasm(DataContractCreateTransition);
+
+impl From<DataContractCreateTransition> for DataContractCreateTransitionWasm {
+    fn from(v: DataContractCreateTransition) -> Self {
+        DataContractCreateTransitionWasm(v)
+    }
+}
+
+impl Into<DataContractCreateTransition> for DataContractCreateTransitionWasm {
+    fn into(self) -> DataContractCreateTransition {
+        self.0
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractCreateTransition)]
+impl DataContractCreateTransitionWasm {
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.data_contract.clone().into()
+    }
+
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.protocol_version.into()
+    }
+
+    #[wasm_bindgen(js_name=getEntropy)]
+    pub fn get_entropy(&self) -> Buffer {
+        Buffer::from_bytes(&self.0.entropy)
+    }
+}

package/src/data_contract/state_transition/mod.rs

@@ -0,0 +1,3 @@
+mod data_contract_create_transition;
+
+pub use data_contract_create_transition::*;

package/src/data_contract_factory/data_contract_factory.rs

@@ -0,0 +1,155 @@
+use std::convert::TryInto;
+
+use dpp::{
+    data_contract::{
+        validation::data_contract_validator::DataContractValidator, DataContractFactory,
+        EntropyGenerator,
+    },
+    prelude::Identifier,
+    version::ProtocolVersionValidator,
+};
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    data_contract::errors::InvalidDataContractError,
+    errors::{consensus_error::from_consensus_error, from_dpp_err, RustConversionError},
+    with_js_error, DataContractCreateTransitionWasm, DataContractParameters, DataContractWasm,
+};
+
+#[wasm_bindgen(js_name=DataContractValidator)]
+pub struct DataContractValidatorWasm(DataContractValidator);
+
+impl From<DataContractValidator> for DataContractValidatorWasm {
+    fn from(v: DataContractValidator) -> Self {
+        DataContractValidatorWasm(v)
+    }
+}
+
+impl Into<DataContractValidator> for DataContractValidatorWasm {
+    fn into(self) -> DataContractValidator {
+        self.0
+    }
+}
+
+#[wasm_bindgen(js_class=DataContractValidator)]
+impl DataContractValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        DataContractValidator::new(std::sync::Arc::new(ProtocolVersionValidator::default())).into()
+    }
+}
+
+#[wasm_bindgen(js_name=DataContractFactory)]
+pub struct DataContractFactoryWasm(DataContractFactory);
+
+impl From<DataContractFactory> for DataContractFactoryWasm {
+    fn from(v: DataContractFactory) -> Self {
+        DataContractFactoryWasm(v)
+    }
+}
+
+impl Into<DataContractFactory> for DataContractFactoryWasm {
+    fn into(self) -> DataContractFactory {
+        self.0
+    }
+}
+
+#[wasm_bindgen]
+extern "C" {
+    pub type ExternalEntropyGenerator;
+
+    #[wasm_bindgen(structural, method)]
+    pub fn generate(this: &ExternalEntropyGenerator) -> Vec<u8>;
+}
+
+impl EntropyGenerator for ExternalEntropyGenerator {
+    fn generate(&self) -> [u8; 32] {
+        // TODO: think about changing API to return an error but does it worth it for JS?
+        let res = ExternalEntropyGenerator::generate(self)
+            .try_into()
+            .expect("Bad entropy generator provided: should return 32 bytes");
+        res
+    }
+}
+#[wasm_bindgen(js_class=DataContractFactory)]
+impl DataContractFactoryWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        protocol_version: u32,
+        validate_data_contract: DataContractValidatorWasm,
+        external_entropy_generator_arg: Option<ExternalEntropyGenerator>,
+    ) -> DataContractFactoryWasm {
+        if let Some(external_entropy_generator) = external_entropy_generator_arg {
+            DataContractFactory::new_with_entropy_generator(
+                protocol_version,
+                validate_data_contract.into(),
+                Box::new(external_entropy_generator),
+            )
+        } else {
+            DataContractFactory::new(protocol_version, validate_data_contract.into()).into()
+        }
+        .into()
+    }
+
+    #[wasm_bindgen(js_name=create)]
+    pub fn create(
+        &self,
+        owner_id: Vec<u8>,
+        documents: JsValue,
+    ) -> Result<DataContractWasm, JsValue> {
+        let documents_json: serde_json::Value =
+            with_js_error!(serde_wasm_bindgen::from_value(documents))?;
+        let identifier = Identifier::from_bytes(&owner_id).map_err(from_dpp_err)?;
+        self.0
+            .create(identifier, documents_json)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createFromObject)]
+    pub async fn create_from_object(
+        &self,
+        object: JsValue,
+        skip_validation: Option<bool>,
+    ) -> Result<DataContractWasm, JsValue> {
+        let parameters: DataContractParameters =
+            with_js_error!(serde_wasm_bindgen::from_value(object.clone()))?;
+        let parameters_json = serde_json::to_value(parameters).expect("Implements Serialize");
+        let result = self
+            .0
+            .create_from_object(parameters_json, skip_validation.unwrap_or(false))
+            .await;
+        match result {
+            Ok(data_contract) => Ok(data_contract.into()),
+            Err(dpp::ProtocolError::InvalidDataContractError { errors, .. }) => {
+                let js_errors = errors.into_iter().map(from_consensus_error).collect();
+                Err(InvalidDataContractError::new(js_errors, object).into())
+            }
+            Err(other) => Err(from_dpp_err(other)),
+        }
+    }
+
+    #[wasm_bindgen(js_name=createFromBuffer)]
+    pub async fn create_from_buffer(
+        &self,
+        buffer: Vec<u8>,
+        skip_validation: Option<bool>,
+    ) -> Result<DataContractWasm, JsValue> {
+        self.0
+            .create_from_buffer(buffer, skip_validation.unwrap_or(false))
+            .await
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=createDataContractCreateTransition)]
+    pub async fn create_data_contract_create_transition(
+        &self,
+        data_contract: DataContractWasm,
+    ) -> Result<DataContractCreateTransitionWasm, JsValue> {
+        self.0
+            .create_data_contract_create_transition(data_contract.into())
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+}

package/src/data_contract_factory/mod.rs

@@ -0,0 +1 @@
+mod data_contract_factory;

package/src/document/errors/document_already_exists_error.rs

@@ -0,0 +1,28 @@
+use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+use dpp::prelude::DocumentTransition;
+use thiserror::Error;
+
+use super::*;
+
+#[wasm_bindgen]
+#[derive(Error, Debug)]
+#[error("Document already exists")]
+pub struct DocumentAlreadyExistsError {
+    document_transition: DocumentTransition,
+}
+
+#[wasm_bindgen]
+impl DocumentAlreadyExistsError {
+    #[wasm_bindgen(js_name=getDocumentTransition)]
+    pub fn get_document_transition(&self) -> JsValue {
+        from_document_transition_to_js_value(self.document_transition.clone())
+    }
+}
+
+impl DocumentAlreadyExistsError {
+    pub fn new(document_transition: DocumentTransition) -> DocumentAlreadyExistsError {
+        Self {
+            document_transition,
+        }
+    }
+}