Server Test Typescript

[package]

name = "pokemon-service-server-sdk"

version = "0.0.1"

authors = ["protocoltest@example.com"]

description = "test"

edition = "2021"

[package.metadata.smithy]

codegen-version = "ci"

protocol = "aws.protocols#restJson1"

[dependencies.aws-smithy-http-server]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"

[dependencies.aws-smithy-json]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"

[dependencies.aws-smithy-runtime-api]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"

[dependencies.aws-smithy-types]

path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"

[dependencies.futures-util]

version = "0.3"

[dependencies.http]

version = "0.2.9"

[dependencies.hyper]

version = "0.14.12"

features = ["server", "http1", "http2", "tcp", "stream"]

[dependencies.mime]

version = "0.3"

[dependencies.napi]

version = "2.11"

features = ["tokio_rt", "napi8"]

[dependencies.napi-derive]

version = "2.11"

[dependencies.nom]

version = "7"

[dependencies.percent-encoding]

version = "2.0.0"

[dependencies.pin-project-lite]

version = "0.2"

[dependencies.socket2]

version = "0.4"

[dependencies.tokio]

version = "1.20.1"

features = ["full"]

[dependencies.tower]

version = "0.4"

[dependencies.tracing]

version = "0.1"

[build-dependencies.napi-build]

version = "2.0"

[dev-dependencies.hyper]

[dev-dependencies.tokio]

version = "1.23.1"

[features]

rt-tokio = ["aws-smithy-types/rt-tokio"]

default = ["rt-tokio", "request-id"]

[lib]

crate-type = ["cdylib"]

                    message: format!(

                        "Value at '{}/name' failed to satisfy constraint: Member must not be null",

                        path

                    ),

                    path: path + "/name",

                },

            }

        }

    }

    impl ::std::convert::From<ConstraintViolation>

    {

        fn from(constraint_violation: ConstraintViolation) -> Self {

            let first_validation_exception_field =

                constraint_violation.as_validation_exception_field("".to_owned());

            let validation_exception = crate::error::ValidationException {

                message: format!(

                    "1 validation error detected. {}",

                    &first_validation_exception_field.message

                ),

                field_list: Some(vec![first_validation_exception_field]),

//!

//! # let app = PokemonService::builder(

//! #     PokemonServiceConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let server = app.into_make_service();

//! let bind: SocketAddr = "127.0.0.1:6969".parse()

//!     .expect("unable to parse the server bind address and port");

//! ::hyper::Server::bind(&bind).serve(server).await.unwrap();

//! # }

//! ```

//!

//! ### Running on Lambda

//!

//! ```rust,ignore

//! use pokemon_service_server_sdk::server::routing::LambdaHandler;

//! use pokemon_service_server_sdk::PokemonService;

//!

//! # async fn dummy() {

//! # let app = PokemonService::builder(

//! #     PokemonServiceConfig::builder()

//! #         .build()

//! # ).build_unchecked();

//! let handler = LambdaHandler::new(app);

//! lambda_http::run(handler).await.unwrap();

//! # }

//! ```

//!

//! # Building the PokemonService

//!

//! To construct [`PokemonService`] we use [`PokemonServiceBuilder`] returned by [`PokemonService::builder`].

//!

//! ## Plugins

//!

//! The [`PokemonService::builder`] method, returning [`PokemonServiceBuilder`],

//! accepts a config object on which plugins can be registered.

//! Plugins allow you to build middleware which is aware of the operation it is being applied to.

//!

//! ```rust,no_run

//! # use pokemon_service_server_sdk::server::plugin::IdentityPlugin as LoggingPlugin;

//! # use pokemon_service_server_sdk::server::plugin::IdentityPlugin as MetricsPlugin;

//! # use ::hyper::Body;

//! use pokemon_service_server_sdk::server::plugin::HttpPlugins;

//! use pokemon_service_server_sdk::{PokemonService, PokemonServiceConfig, PokemonServiceBuilder};

//!

//! let http_plugins = HttpPlugins::new()

//!         .push(LoggingPlugin)

//!         .push(MetricsPlugin);

//! let config = PokemonServiceConfig::builder().build();

//! ```

//!

//! Check out [`crate::server::plugin`] to learn more about plugins.

//!

//! ## Handlers

//!

//! [`PokemonServiceBuilder`] provides a setter method for each operation in your Smithy model. The setter methods expect an async function as input, matching the signature for the corresponding operation in your Smithy model.

//! We call these async functions **handlers**. This is where your application business logic lives.

//!

//! Every handler must take an `Input`, and optional [`extractor arguments`](crate::server::request), while returning:

//!     todo!()

//! }

//!

//! async fn get_server_statistics(input: input::GetServerStatisticsInput) -> Result<output::GetServerStatisticsOutput, error::GetServerStatisticsError> {

//!     todo!()

//! }

//!

//! ```

//!

//! [`serve`]: https://docs.rs/hyper/0.14.16/hyper/server/struct.Builder.html#method.serve

//! [`tower::make::MakeService`]: https://docs.rs/tower/latest/tower/make/trait.MakeService.html

//! [HTTP binding traits]: https://smithy.io/2.0/spec/http-bindings.html

//! [operations]: https://smithy.io/2.0/spec/service-types.html#operation

//! [Service]: https://docs.rs/tower-service/latest/tower_service/trait.Service.html

pub use crate::service::{

    MissingOperationsError, PokemonService, PokemonServiceBuilder, PokemonServiceConfig,

    PokemonServiceConfigBuilder,

};

/// Contains the types that are re-exported from the `aws-smithy-http-server` crate.

pub mod server {

    // Re-export all types from the `aws-smithy-http-server` crate.

}

/// Crate version number.

pub static PKG_VERSION: &str = env!("CARGO_PKG_VERSION");

/// All error types that operations can return. Documentation on these types is copied from the model.

pub mod error;

/// Input structures for operations. Documentation on these types is copied from the model.

pub mod input;

/// Data structures used by operation inputs/outputs. Documentation on these types is copied from the model.

pub mod model;

/// All operations that this crate can perform.

pub mod operation;

/// A collection of types representing each operation defined in the service closure.

///

/// [zero-sized types](https://doc.rust-lang.org/nomicon/exotic-sizes.html#zero-sized-types-zsts) (ZSTs) to

/// operation specific information to the [`Layer`](::tower::Layer) being applied.

pub mod operation_shape;

/// Output structures for operations. Documentation on these types is copied from the model.

pub mod output;

mod service;

pub mod ts_operation_adaptor;

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`GetPokemonSpeciesInput`](crate::input::GetPokemonSpeciesInput) using modelled bindings.

    pub struct GetPokemonSpeciesInputFuture {

    }

}

impl std::future::Future for GetPokemonSpeciesInputFuture {

    type Output = Result<

        crate::input::GetPokemonSpeciesInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::GetPokemonSpeciesInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = GetPokemonSpeciesInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_get_pokemon_species::de_get_pokemon_species_http_request(

                request,

            )

            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        GetPokemonSpeciesInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::GetPokemonSpeciesOutput

{

        match crate::protocol_serde::shape_get_pokemon_species::ser_get_pokemon_species_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::GetPokemonSpeciesError

{

        match crate::protocol_serde::shape_get_pokemon_species::ser_get_pokemon_species_http_error(

            &self,

        ) {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`CheckHealthInput`](crate::input::CheckHealthInput) using modelled bindings.

    pub struct CheckHealthInputFuture {

    }

}

impl std::future::Future for CheckHealthInputFuture {

    type Output = Result<

        crate::input::CheckHealthInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::CheckHealthInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = CheckHealthInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_check_health::de_check_health_http_request(request).await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        CheckHealthInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::CheckHealthOutput

{

        match crate::protocol_serde::shape_check_health::ser_check_health_http_response(self) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::CheckHealthError

{

        match crate::protocol_serde::shape_check_health::ser_check_health_http_error(&self) {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`DoNothingInput`](crate::input::DoNothingInput) using modelled bindings.

    pub struct DoNothingInputFuture {

    }

}

impl std::future::Future for DoNothingInputFuture {

    type Output = Result<

        crate::input::DoNothingInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::DoNothingInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = DoNothingInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_do_nothing::de_do_nothing_http_request(request).await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        DoNothingInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::DoNothingOutput

{

        match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_response(self) {

            Ok(response) => response,

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

impl

    > for crate::error::DoNothingError

{

        match crate::protocol_serde::shape_do_nothing::ser_do_nothing_http_error(&self) {

            Ok(mut response) => {

                response.extensions_mut().insert(

                );

                response

            }

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

::pin_project_lite::pin_project! {

    /// A [`Future`](std::future::Future) aggregating the body bytes of a [`Request`] and constructing the

    /// [`GetServerStatisticsInput`](crate::input::GetServerStatisticsInput) using modelled bindings.

    pub struct GetServerStatisticsInputFuture {

    }

}

impl std::future::Future for GetServerStatisticsInputFuture {

    type Output = Result<

        crate::input::GetServerStatisticsInput,

    >;

    fn poll(

        self: std::pin::Pin<&mut Self>,

        cx: &mut std::task::Context<'_>,

    ) -> std::task::Poll<Self::Output> {

        let this = self.project();

        this.inner.as_mut().poll(cx)

    }

}

impl<B>

        B,

    > for crate::input::GetServerStatisticsInput

where

    B: 'static,

    B::Data: Send,

{

    type Future = GetServerStatisticsInputFuture;

    fn from_request(request: ::http::Request<B>) -> Self::Future {

        let fut = async move {

                request.headers(),

                &crate::mimes::CONTENT_TYPE_APPLICATION_JSON,

            ) {

            }

            crate::protocol_serde::shape_get_server_statistics::de_get_server_statistics_http_request(request)

                            .await

        };

        use ::futures_util::future::TryFutureExt;

                        ::tracing::debug!(error = %e, "failed to deserialize request");

        GetServerStatisticsInputFuture {

            inner: Box::pin(fut),

        }

    }

}

impl

    > for crate::output::GetServerStatisticsOutput

{

        match crate::protocol_serde::shape_get_server_statistics::ser_get_server_statistics_http_response(self) {

                        Ok(response) => response,

                        Err(e) => {

                            ::tracing::error!(error = %e, "failed to serialize response");

                        }

                    }

    }

}

impl

    > for crate::error::GetServerStatisticsError

{

        match crate::protocol_serde::shape_get_server_statistics::ser_get_server_statistics_http_error(&self) {

            Ok(mut response) => {

                response

            },

            Err(e) => {

                ::tracing::error!(error = %e, "failed to serialize response");

            }

        }

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

/// Retrieve information about a Pokémon species.

pub struct GetPokemonSpecies;

            "com.aws.example#GetPokemonSpecies",

            "com.aws.example",

            "GetPokemonSpecies",

        );

    type Input = crate::input::GetPokemonSpeciesInput;

    type Output = crate::output::GetPokemonSpeciesOutput;

    type Error = crate::error::GetPokemonSpeciesError;

}

        >,

    >;

    >;

    fn request_fmt() -> Self::RequestFmt {

    }

    fn response_fmt() -> Self::ResponseFmt {

    }

}

/// Health check operation, to check the service is up Not yet a deep check

pub struct CheckHealth;

            "com.aws.example#CheckHealth",

            "com.aws.example",

            "CheckHealth",

        );

    type Input = crate::input::CheckHealthInput;

    type Output = crate::output::CheckHealthOutput;

    type Error = crate::error::CheckHealthError;

}

        >,

    >;

    >;

    fn request_fmt() -> Self::RequestFmt {

    }

    fn response_fmt() -> Self::ResponseFmt {

    }

}

/// DoNothing operation, used to stress test the framework.

pub struct DoNothing;

            "com.aws.example#DoNothing",

            "com.aws.example",

            "DoNothing",

        );

    type Input = crate::input::DoNothingInput;

    type Output = crate::output::DoNothingOutput;

    type Error = crate::error::DoNothingError;

}

        >,

    >;

    >;

    fn request_fmt() -> Self::RequestFmt {

    }

    fn response_fmt() -> Self::ResponseFmt {

    }

}

/// Retrieve HTTP server statistiscs, such as calls count.

pub struct GetServerStatistics;

            "com.aws.example#GetServerStatistics",

            "com.aws.example",

            "GetServerStatistics",

        );

    type Input = crate::input::GetServerStatisticsInput;

    type Output = crate::output::GetServerStatisticsOutput;

    type Error = crate::error::GetServerStatisticsError;

}

        >,

    >;

    >;

    fn request_fmt() -> Self::RequestFmt {

    }

    fn response_fmt() -> Self::ResponseFmt {

    }

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(clippy::unnecessary_wraps)]

pub async fn de_check_health_http_request<B>(

    #[allow(unused_variables)] request: ::http::Request<B>,

) -> std::result::Result<

    crate::input::CheckHealthInput,

>

where

    B::Data: Send,

{

    Ok({

        #[allow(unused_mut)]

        let mut input = crate::input::check_health_input_internal::Builder::default();

        #[allow(unused_variables)]

        let ::aws_smithy_runtime_api::http::RequestParts {

            uri, headers, body, ..

        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();

        input.build()

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn ser_check_health_http_response(

    #[allow(unused_variables)] output: crate::output::CheckHealthOutput,

) -> std::result::Result<

> {

    Ok({

        #[allow(unused_mut)]

        let mut builder = ::http::Response::builder();

            builder,

            ::http::header::CONTENT_TYPE,

            "application/json",

        );

        let http_status: u16 = 200;

        builder = builder.status(http_status);

        let payload = "";

        let content_length = payload.len();

            builder,

            ::http::header::CONTENT_LENGTH,

            content_length,

        );

        builder.body(body)?

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn ser_check_health_http_error(

    error: &crate::error::CheckHealthError,

) -> std::result::Result<

> {

    Ok({

        match error {

            crate::error::CheckHealthError::InternalServerError(output) => {

                let payload = crate::protocol_serde::shape_internal_server_error::ser_internal_server_error_error(output)?;

                #[allow(unused_mut)]

                let mut builder = ::http::Response::builder();

                    builder,

                    ::http::header::CONTENT_TYPE,

                    "application/json",

                );

                    builder,

                    ::http::header::HeaderName::from_static("x-amzn-errortype"),

                    "InternalServerError",

                );

                let content_length = payload.len();

                    builder,

                    ::http::header::CONTENT_LENGTH,

                    content_length,

                );

                builder

                    .status(500)

            }

        }

    })

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(clippy::unnecessary_wraps)]

pub async fn de_do_nothing_http_request<B>(

    #[allow(unused_variables)] request: ::http::Request<B>,

) -> std::result::Result<

    crate::input::DoNothingInput,

>

where

    B::Data: Send,

{

    Ok({

        #[allow(unused_mut)]

        let mut input = crate::input::do_nothing_input_internal::Builder::default();

        #[allow(unused_variables)]

        let ::aws_smithy_runtime_api::http::RequestParts {

            uri, headers, body, ..

        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();

        input.build()

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn ser_do_nothing_http_response(

    #[allow(unused_variables)] output: crate::output::DoNothingOutput,

) -> std::result::Result<

> {

    Ok({

        #[allow(unused_mut)]

        let mut builder = ::http::Response::builder();

            builder,

            ::http::header::CONTENT_TYPE,

            "application/json",

        );

        let http_status: u16 = 200;

        builder = builder.status(http_status);

        let payload =

            crate::protocol_serde::shape_do_nothing_output::ser_do_nothing_output_output_output(

                &output,

            )?;

        let content_length = payload.len();

            builder,

            ::http::header::CONTENT_LENGTH,

            content_length,

        );

        builder.body(body)?

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn ser_do_nothing_http_error(

    error: &crate::error::DoNothingError,

) -> std::result::Result<

> {

    Ok({

        match error {

            crate::error::DoNothingError::InternalServerError(output) => {

                let payload = crate::protocol_serde::shape_internal_server_error::ser_internal_server_error_error(output)?;

                #[allow(unused_mut)]

                let mut builder = ::http::Response::builder();

                    builder,

                    ::http::header::CONTENT_TYPE,

                    "application/json",

                );

                    builder,

                    ::http::header::HeaderName::from_static("x-amzn-errortype"),

                    "InternalServerError",

                );

                let content_length = payload.len();

                    builder,

                    ::http::header::CONTENT_LENGTH,

                    content_length,

                );

                builder

                    .status(500)

            }

        }

    })

}

// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.

#[allow(clippy::unnecessary_wraps)]

pub async fn de_get_pokemon_species_http_request<B>(

    #[allow(unused_variables)] request: ::http::Request<B>,

) -> std::result::Result<

    crate::input::GetPokemonSpeciesInput,

>

where

    B::Data: Send,

{

    Ok({

        #[allow(unused_mut)]

        let mut input = crate::input::get_pokemon_species_input_internal::Builder::default();

        #[allow(unused_variables)]

        let ::aws_smithy_runtime_api::http::RequestParts {

            uri, headers, body, ..

        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();

        let input_string = uri.path();

        let (input_string, (_, m1)) =

            ::nom::sequence::tuple::<_, _, ::nom::error::Error<&str>, _>((

                ::nom::sequence::preceded(

                    ::nom::bytes::complete::tag("/"),

                    ::nom::bytes::complete::tag::<_, _, ::nom::error::Error<&str>>(

                        "pokemon-species",

                    ),

                ),

                ::nom::sequence::preceded(

                    ::nom::bytes::complete::tag("/"),

                    ::nom::branch::alt::<_, _, ::nom::error::Error<&str>, _>((

                        ::nom::bytes::complete::take_until("/"),

                        ::nom::combinator::rest,

                    )),

                ),

            ))(input_string)?;

        debug_assert_eq!("", input_string);

        input =

            input.set_name(crate::protocol_serde::shape_get_pokemon_species_input::de_name(m1)?);

        input.build()?

    })

}

#[allow(clippy::unnecessary_wraps)]

pub fn ser_get_pokemon_species_http_response(

    #[allow(unused_variables)] output: crate::output::GetPokemonSpeciesOutput,