Struct ShopDomain 

pub struct ShopDomain { /* private fields */ }

A validated Shopify shop domain.

This newtype validates and normalizes shop domains to the full shop.myshopify.com format.

Accepted Formats

• shop-name - normalized to shop-name.myshopify.com
• shop-name.myshopify.com - used as-is

Serialization

ShopDomain serializes to and deserializes from the full domain string:

use shopify_sdk::ShopDomain;

let domain = ShopDomain::new("my-store").unwrap();
let json = serde_json::to_string(&domain).unwrap();
assert_eq!(json, r#""my-store.myshopify.com""#);

Example

use shopify_sdk::ShopDomain;

// Short format is normalized
let domain = ShopDomain::new("my-store").unwrap();
assert_eq!(domain.as_ref(), "my-store.myshopify.com");
assert_eq!(domain.shop_name(), "my-store");

// Full format is accepted
let domain = ShopDomain::new("my-store.myshopify.com").unwrap();
assert_eq!(domain.as_ref(), "my-store.myshopify.com");

Implementations

impl ShopDomain

pub fn new(domain: impl Into<String>) -> Result<Self, ConfigError>

Creates a new validated shop domain.

Errors

Returns ConfigError::InvalidShopDomain if the domain is invalid.

pub fn shop_name(&self) -> &str

Returns the shop name portion of the domain.

For my-store.myshopify.com, this returns my-store.

Trait Implementations

impl AsRef<str> for ShopDomain

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for ShopDomain

fn clone(&self) -> ShopDomain

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ShopDomain

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ShopDomain

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ShopDomain

fn eq(&self, other: &ShopDomain) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ShopDomain

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ShopDomain

impl StructuralPartialEq for ShopDomain