Struct Endpoint 

pub struct Endpoint {
    pub domain: String,
    pub name: String,
    pub scheme: Option<Scheme>,
    pub port: Option<u16>,
    pub authentication: Option<Authentication>,
    pub root: Option<String>,
    pub resources: Vec<Resource>,
}

Represents an API endpoint with a lookup table for calling various paths

Note

Paths use handlebars templating syntax for dynamic URL construction, powered by Tera

Fields

domain: String

The domain of the API endpoint

name: String

The name of the API endpoint (used mainly for logging and identification)

scheme: Option<Scheme>

The scheme of the API endpoint

port: Option<u16>

The port of the API endpoint

authentication: Option<Authentication>

Authentication credentials for accessing the API endpoint

root: Option<String>

Root path for the API endpoint

Example

“v3.0” for ORCiD API

resources: Vec<Resource>

Resource data for generating full paths for the API endpoint using templates

Implementations

impl Endpoint

pub fn at(domain: impl Into<String>) -> EndpointBuilder

Create an instance of Endpoint using the builder syntax

impl Endpoint

pub fn base(&self) -> String

Get the base URL for the API endpoint, constructed from scheme, domain, and port if not provided

pub fn context_with<Q, F>(&self, data: Option<Vec<Param>>) -> Context

where Q: QueryField + ValueValidator, F: QueryField,

Build context for endpoint paths using explicit query/field types.

Trait Implementations

impl Clone for Endpoint

fn clone(&self) -> Endpoint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Endpoint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Endpoint

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Endpoint

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<Location> for Endpoint

fn from(value: Location) -> Self

Converts to this type from the input type.

impl From<Repository> for Endpoint

fn from(value: Repository) -> Self

Converts to this type from the input type.

impl<'a> From<URI<'a>> for Endpoint

fn from(value: URI<'a>) -> Self

Converts to this type from the input type.

impl RestfulInterface for Endpoint

fn invoke_sync( &self, name: impl Into<String> + Clone, data: Option<Vec<Param>>, ) -> Result<ResponseContent, Error>

Invoke an endpoint resource with data and receive a response using EmptyField as the default query and field types.

Example

let ror = endpoints.find_by_name("ror");
let text = match &ror {
    | Some(endpoint) => {
        let response = endpoint.invoke_sync("status", None);
        endpoint.handle::<api::TextResponse>(response)
    }
    | None => Err("No ROR endpoint found".into()),
};
println!("ROR Status: {text:#?}");

fn invoke_sync_with<Q, F>( &self, name: impl Into<String> + Clone, data: Option<Vec<Param>>, ) -> Result<ResponseContent, Error>

where Q: QueryField + ValueValidator, F: QueryField,

Invoke an endpoint resource with data and receive a response using explicit query and field types.

Example

let orcid = endpoints.find_by_name("orcid");
let text = match &orcid {
    | Some(endpoint) => {
        let data = vec![
            api::Param::of_type(api::ParamStyle::QueryPair)
                .values(vec![
                    (Some("affiliation-org-name"), Some("Lyrasis")),
                    (Some("ror-org-id"), Some("\"https://ror.org/01qz5mb56\"")),
                ])
                .with_key("q"),
            api::Param::of_type(api::ParamStyle::FieldList)
                .values(vec![(Some("family-name"), None)])
                .with_key("fl"),
        ];
        let response = endpoint.invoke_sync_with::<api::orcid::SearchField, api::orcid::OutputColumn>("search", Some(data));
        endpoint.handle::<api::orcid::SearchResponse>(response)
    }
    | None => Err("No ORCiD endpoint found".into()),
};
println!("ORCiD Search Response: {text:#?}");

type Query = EmptyField

Query field type used for request building

type Field = EmptyField

Field list type used for response selection

fn context(&self, data: Option<Vec<Param>>) -> Context

Build context for endpoint paths

fn handle<R>( &self, response: Result<ResponseContent, Error>, ) -> Result<R, String>

where R: for<'de> Deserialize<'de>,

Handle a response from an endpoint request

fn parse_json<R>(&self, content: &str) -> Result<R, String>

where R: for<'de> Deserialize<'de>,

Parse JSON response string content

fn parse_xml<R>(&self, content: &str) -> Result<R, String>

where R: for<'de> Deserialize<'de>,

Parse XML response string content

impl Serialize for Endpoint

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Validate for Endpoint

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a> ValidateArgs<'v_a> for Endpoint

type Args = ()

fn validate_with_args(&self, args: Self::Args) -> Result<(), ValidationErrors>