use std::sync::{Arc, RwLock};
use std::time::Duration;
use serde::de::DeserializeOwned;
use serde_json::Value;
use crate::error::{Error, Result};
use crate::models::{Mutation, Status};
use crate::params::Params;
use crate::transport::{
DEFAULT_DOWNLOAD_TIMEOUT, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, RetryPolicy, Transport,
};
use crate::types::{BatchObject, Language};
pub const DEFAULT_BASE_URL: &str = "https://api.music.yandex.net";
pub const DEFAULT_DEVICE: &str =
"os=Rust; os_version=; manufacturer=yamuse; model=yamuse; clid=; device_id=random; uuid=random";
pub const BATCH_CHUNK: usize = 250;
#[derive(Debug)]
struct Inner {
transport: Transport,
base_url: String,
language: Language,
device: String,
token: Option<String>,
account: RwLock<Option<Status>>,
}
#[derive(Debug, Clone)]
pub struct Client {
inner: Arc<Inner>,
}
impl Client {
#[must_use]
pub fn builder() -> ClientBuilder {
ClientBuilder::default()
}
pub fn anonymous() -> Result<Self> {
ClientBuilder::default().build()
}
pub async fn init(&self) -> Result<&Self> {
self.refresh_account().await?;
Ok(self)
}
pub async fn refresh_account(&self) -> Result<Status> {
let status = self.account_status().await?;
if let Ok(mut guard) = self.inner.account.write() {
*guard = Some(status.clone());
}
Ok(status)
}
#[must_use]
pub fn me(&self) -> Option<Status> {
self.inner.account.read().ok()?.clone()
}
#[must_use]
pub fn account_uid(&self) -> Option<i64> {
self.inner.account.read().ok()?.as_ref()?.uid()
}
#[must_use]
pub fn token(&self) -> Option<&str> {
self.inner.token.as_deref()
}
#[must_use]
pub fn base_url(&self) -> &str {
&self.inner.base_url
}
#[must_use]
pub fn language(&self) -> Language {
self.inner.language
}
#[must_use]
pub fn device(&self) -> &str {
&self.inner.device
}
#[must_use]
pub fn transport(&self) -> &Transport {
&self.inner.transport
}
pub async fn get_raw(&self, path: &str, params: Params) -> Result<Value> {
self.get_value(path, params).await
}
pub(crate) fn url(&self, path: &str) -> String {
format!("{}{path}", self.inner.base_url)
}
pub(crate) fn resolve_uid(&self, user_id: Option<i64>) -> Result<i64> {
user_id
.or_else(|| self.account_uid())
.ok_or(Error::IdMissing(
"user id: pass one explicitly or call init() first",
))
}
pub(crate) async fn get<T: DeserializeOwned>(&self, path: &str, params: Params) -> Result<T> {
self.inner.transport.get(&self.url(path), ¶ms).await
}
pub(crate) fn decode<T: DeserializeOwned>(&self, value: Value) -> Result<T> {
self.inner.transport.decode(value)
}
pub(crate) async fn get_value(&self, path: &str, params: Params) -> Result<Value> {
self.inner
.transport
.get_value(&self.url(path), ¶ms, &[])
.await
}
pub(crate) async fn get_with_headers<T: DeserializeOwned>(
&self,
path: &str,
params: Params,
headers: &[(&str, &str)],
) -> Result<T> {
self.inner
.transport
.get_with_headers(&self.url(path), ¶ms, headers)
.await
}
pub(crate) async fn post_form<T: DeserializeOwned>(
&self,
path: &str,
form: Params,
) -> Result<T> {
self.inner.transport.post_form(&self.url(path), form).await
}
pub(crate) async fn post_form_value(&self, path: &str, form: Params) -> Result<Value> {
self.post_form_value_with(path, &Params::new(), form, &[])
.await
}
pub(crate) async fn post_form_value_with(
&self,
path: &str,
query: &Params,
form: Params,
headers: &[(&str, &str)],
) -> Result<Value> {
self.inner
.transport
.post_form_value(&self.url(path), query, form, headers)
.await
}
pub(crate) async fn post_json_value(&self, path: &str, json: &Value) -> Result<Value> {
self.inner
.transport
.post_json_value(&self.url(path), json, &[])
.await
}
pub(crate) async fn post_raw_json_value(
&self,
path: &str,
json: String,
headers: &[(&str, &str)],
) -> Result<Value> {
self.inner
.transport
.post_raw_json_value(&self.url(path), json, headers)
.await
}
pub(crate) async fn put_value(&self, path: &str, json: &Value) -> Result<Value> {
self.inner.transport.put_value(&self.url(path), json).await
}
pub(crate) async fn delete_value(&self, path: &str, json: &Value) -> Result<Value> {
self.inner
.transport
.delete_value(&self.url(path), json)
.await
}
pub(crate) async fn post_form_absolute(&self, url: &str, form: Params) -> Result<Value> {
self.inner
.transport
.post_form_value(url, &Params::new(), form, &[])
.await
}
pub(crate) async fn get_batch<T: DeserializeOwned>(
&self,
object: BatchObject,
ids: impl IntoIterator<Item = impl std::fmt::Display>,
extra: Params,
) -> Result<Vec<T>> {
let kind = object.as_str();
let suffix = if object == BatchObject::Playlist {
"/list"
} else {
""
};
let path = format!("/{kind}s{suffix}");
let key = format!("{kind}-ids");
let ids: Vec<String> = ids.into_iter().map(|id| id.to_string()).collect();
if ids.len() <= BATCH_CHUNK {
return self.post_form(&path, extra.add_all(&key, ids)).await;
}
let mut all = Vec::with_capacity(ids.len());
for chunk in ids.chunks(BATCH_CHUNK) {
let form = extra.clone().add_all(&key, chunk);
all.extend(self.post_form::<Vec<T>>(&path, form).await?);
}
Ok(all)
}
pub(crate) async fn mutate_batch(
&self,
path: &str,
key: &str,
ids: impl IntoIterator<Item = impl std::fmt::Display>,
) -> Result<Mutation> {
let ids: Vec<String> = ids.into_iter().map(|id| id.to_string()).collect();
if ids.len() <= BATCH_CHUNK {
let value = self
.post_form_value(path, Params::new().add_all(key, ids))
.await?;
return Self::acknowledged(&value);
}
let mut last = Mutation::default();
for chunk in ids.chunks(BATCH_CHUNK) {
let value = self
.post_form_value(path, Params::new().add_all(key, chunk))
.await?;
last = Self::acknowledged(&value)?;
}
Ok(last)
}
pub(crate) fn acknowledged(value: &Value) -> Result<Mutation> {
let rejected =
|| Error::InvalidResponse(format!("the api did not acknowledge the mutation: {value}"));
match value {
Value::String(marker) if marker == "ok" => Ok(Mutation::default()),
Value::Object(map) => {
if map.contains_key("revision") {
return Ok(Mutation {
revision: map.get("revision").and_then(Value::as_i64),
});
}
if map.get("status") == Some(&Value::String("ok".into())) {
return Ok(Mutation::default());
}
Err(rejected())
},
_ => Err(rejected()),
}
}
pub(crate) fn acknowledged_loosely(value: &Value) -> Result<Mutation> {
match Self::acknowledged(value) {
Ok(mutation) => Ok(mutation),
Err(err) if value.is_object() => {
let _ = err;
Ok(Mutation::default())
},
Err(err) => Err(err),
}
}
}
#[derive(Clone)]
pub struct ClientBuilder {
token: Option<String>,
base_url: String,
language: Language,
device: String,
user_agent: String,
headers: Vec<(String, String)>,
timeout: Duration,
download_timeout: Duration,
retry: RetryPolicy,
http: Option<reqwest::Client>,
on_field_repair: Option<crate::transport::FieldRepairHook>,
}
impl std::fmt::Debug for ClientBuilder {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ClientBuilder")
.field("base_url", &self.base_url)
.field("language", &self.language)
.field("device", &self.device)
.field("user_agent", &self.user_agent)
.field("timeout", &self.timeout)
.field("download_timeout", &self.download_timeout)
.field("retry", &self.retry)
.field("has_token", &self.token.is_some())
.field("on_field_repair", &self.on_field_repair.is_some())
.finish_non_exhaustive()
}
}
impl Default for ClientBuilder {
fn default() -> Self {
Self {
token: None,
base_url: DEFAULT_BASE_URL.to_owned(),
language: Language::default(),
device: DEFAULT_DEVICE.to_owned(),
user_agent: DEFAULT_USER_AGENT.to_owned(),
headers: Vec::new(),
timeout: DEFAULT_TIMEOUT,
download_timeout: DEFAULT_DOWNLOAD_TIMEOUT,
retry: RetryPolicy::default(),
http: None,
on_field_repair: None,
}
}
}
impl ClientBuilder {
#[must_use]
pub fn token(mut self, token: impl Into<String>) -> Self {
self.token = Some(token.into());
self
}
#[must_use]
pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
let mut base_url = base_url.into();
base_url.truncate(base_url.trim_end_matches('/').len());
self.base_url = base_url;
self
}
#[must_use]
pub fn language(mut self, language: Language) -> Self {
self.language = language;
self
}
#[must_use]
pub fn device(mut self, device: impl Into<String>) -> Self {
self.device = device.into();
self
}
#[must_use]
pub fn user_agent(mut self, user_agent: impl Into<String>) -> Self {
self.user_agent = user_agent.into();
self
}
#[must_use]
pub fn header(mut self, name: impl Into<String>, value: impl Into<String>) -> Self {
self.headers.push((name.into(), value.into()));
self
}
#[must_use]
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub fn download_timeout(mut self, timeout: Duration) -> Self {
self.download_timeout = timeout;
self
}
#[must_use]
pub fn retry(mut self, retry: RetryPolicy) -> Self {
self.retry = retry;
self
}
#[must_use]
pub fn http_client(mut self, http: reqwest::Client) -> Self {
self.http = Some(http);
self
}
#[must_use]
pub fn on_field_repair(
mut self,
hook: impl Fn(&crate::tolerant::FieldRepair) + Send + Sync + 'static,
) -> Self {
self.on_field_repair = Some(std::sync::Arc::new(hook));
self
}
pub fn build(self) -> Result<Client> {
let http = match self.http {
Some(http) => http,
None => reqwest::Client::builder()
.build()
.map_err(|e| Error::Network(format!("could not build the http client: {e}")))?,
};
let transport = Transport::new(
http,
self.token.as_deref(),
self.language.as_str(),
&self.user_agent,
&self.headers,
self.timeout,
self.download_timeout,
self.retry,
self.on_field_repair,
)?;
Ok(Client {
inner: Arc::new(Inner {
transport,
base_url: self.base_url,
language: self.language,
device: self.device,
token: self.token,
account: RwLock::new(None),
}),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn urls_are_built_against_the_configured_origin() {
let client = Client::builder()
.base_url("https://example.test/")
.build()
.unwrap();
assert_eq!(client.base_url(), "https://example.test");
assert_eq!(client.url("/tracks/1"), "https://example.test/tracks/1");
}
#[test]
fn an_anonymous_client_carries_no_token() {
let client = Client::anonymous().unwrap();
assert!(client.token().is_none());
assert!(client.account_uid().is_none());
assert!(client.me().is_none());
}
#[test]
fn builder_options_land_on_the_client() {
let client = Client::builder()
.token("t")
.language(Language::En)
.device("os=Test")
.build()
.unwrap();
assert_eq!(client.token(), Some("t"));
assert_eq!(client.language(), Language::En);
assert_eq!(client.device(), "os=Test");
}
#[test]
fn a_uid_is_required_when_init_has_not_run() {
let client = Client::anonymous().unwrap();
assert!(client.resolve_uid(None).is_err());
assert_eq!(client.resolve_uid(Some(42)).unwrap(), 42);
}
#[test]
fn a_token_with_illegal_header_bytes_is_rejected_at_build_time() {
assert!(Client::builder().token("bad\nvalue").build().is_err());
}
#[test]
fn success_markers_cover_both_shapes_the_api_uses() {
assert_eq!(
Client::acknowledged(&Value::String("ok".into())).unwrap(),
Mutation::default()
);
assert_eq!(
Client::acknowledged(&serde_json::json!({"revision": 42}))
.unwrap()
.revision,
Some(42)
);
assert_eq!(
Client::acknowledged(&serde_json::json!({"status": "ok"})).unwrap(),
Mutation::default()
);
}
#[test]
fn an_unacknowledged_mutation_is_an_error_rather_than_a_quiet_false() {
for value in [
Value::String("nope".into()),
serde_json::json!({}),
Value::Null,
serde_json::json!({"status": "error"}),
serde_json::json!([]),
] {
let err = Client::acknowledged(&value).unwrap_err();
assert!(matches!(err, Error::InvalidResponse(_)), "{value}: {err:?}");
assert!(err.to_string().contains("did not acknowledge"), "{err}");
}
}
#[test]
fn a_revision_that_is_not_a_number_still_counts_as_acknowledged() {
let mutation = Client::acknowledged(&serde_json::json!({"revision": "42"})).unwrap();
assert_eq!(mutation.revision, None);
}
#[test]
fn the_clip_endpoints_accept_any_object_they_answer_with() {
assert!(Client::acknowledged_loosely(&serde_json::json!({"anything": 1})).is_ok());
assert_eq!(
Client::acknowledged_loosely(&serde_json::json!({"revision": 7}))
.unwrap()
.revision,
Some(7)
);
assert!(Client::acknowledged_loosely(&Value::Null).is_err());
assert!(Client::acknowledged_loosely(&Value::String("nope".into())).is_err());
}
#[test]
fn clones_share_the_account_cache() {
let client = Client::anonymous().unwrap();
let clone = client.clone();
assert!(client.me().is_none());
assert!(clone.me().is_none());
assert!(Arc::ptr_eq(&client.inner, &clone.inner));
}
}