use std::collections::VecDeque;
use std::fmt;
use std::future::{Future, poll_fn};
use std::pin::Pin;
use std::task::{Context, Poll};
use chrono::{DateTime, Utc};
use futures_core::Stream;
use serde::Deserialize;
use serde::de::DeserializeOwned;
use crate::errors::Error;
use crate::generated::models::ResponseMeta;
use crate::options::{Platform, Source};
use crate::transport::OperationRequest;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
#[non_exhaustive]
pub struct Billing {
pub cost: Option<String>,
pub dataset_version: Option<String>,
pub disposition: Option<String>,
pub environment: Option<String>,
pub list_price: Option<String>,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct ResponseWire<T> {
data: T,
#[serde(default)]
platform: Option<Platform>,
#[serde(default)]
resource: Option<String>,
#[serde(default)]
captured_at: Option<DateTime<Utc>>,
#[serde(default)]
source: Option<Source>,
#[serde(default)]
meta: Option<ResponseMeta>,
}
impl<T> ResponseWire<T> {
pub(crate) fn into_response(self, request_id: Option<String>, billing: Billing) -> Response<T> {
Response {
data: self.data,
platform: self.platform,
resource: self.resource,
captured_at: self.captured_at,
source: self.source,
meta: self.meta,
request_id,
billing,
}
}
}
#[derive(Clone, Debug, PartialEq)]
#[non_exhaustive]
pub struct Response<T> {
pub data: T,
pub platform: Option<Platform>,
pub resource: Option<String>,
pub captured_at: Option<DateTime<Utc>>,
pub source: Option<Source>,
pub meta: Option<ResponseMeta>,
pub request_id: Option<String>,
pub billing: Billing,
}
impl<T> Response<T> {
pub(crate) fn with_data<U>(self, data: U) -> Response<U> {
Response {
data,
platform: self.platform,
resource: self.resource,
captured_at: self.captured_at,
source: self.source,
meta: self.meta,
request_id: self.request_id,
billing: self.billing,
}
}
}
#[derive(Clone)]
#[non_exhaustive]
pub struct Page<T> {
pub data: Vec<T>,
pub meta: ResponseMeta,
pub platform: Option<Platform>,
pub resource: Option<String>,
pub captured_at: Option<DateTime<Utc>>,
pub source: Option<Source>,
pub request_id: Option<String>,
pub billing: Billing,
request: OperationRequest,
}
impl<T> Page<T> {
pub(crate) fn from_wire(
wire: ResponseWire<Vec<T>>,
request_id: Option<String>,
billing: Billing,
request: OperationRequest,
) -> Self {
Self {
data: wire.data,
meta: wire.meta.unwrap_or_default(),
platform: wire.platform,
resource: wire.resource,
captured_at: wire.captured_at,
source: wire.source,
request_id,
billing,
request,
}
}
pub fn next_cursor(&self) -> Option<&str> {
self.meta
.cursors
.next
.as_deref()
.filter(|cursor| !cursor.is_empty())
}
pub fn has_next_page(&self) -> bool {
self.next_cursor().is_some()
}
}
impl<T: DeserializeOwned> Page<T> {
pub async fn next(&self) -> Result<Option<Page<T>>, Error> {
let Some(cursor) = self.next_cursor() else {
return Ok(None);
};
self.request.with_cursor(cursor).send_page().await.map(Some)
}
}
impl<T: fmt::Debug> fmt::Debug for Page<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Page")
.field("data", &self.data)
.field("meta", &self.meta)
.field("platform", &self.platform)
.field("resource", &self.resource)
.field("captured_at", &self.captured_at)
.field("source", &self.source)
.field("request_id", &self.request_id)
.field("billing", &self.billing)
.finish_non_exhaustive()
}
}
type PageFuture<T> = Pin<Box<dyn Future<Output = Result<Page<T>, Error>> + Send>>;
#[must_use = "items does nothing until you call next or poll it"]
pub struct Items<T> {
next_request: Option<Result<OperationRequest, Error>>,
pending: Option<PageFuture<T>>,
buffer: VecDeque<T>,
}
impl<T> Unpin for Items<T> {}
impl<T: DeserializeOwned + Send + 'static> Items<T> {
pub(crate) fn new(request: Result<OperationRequest, Error>) -> Self {
Self {
next_request: Some(request),
pending: None,
buffer: VecDeque::new(),
}
}
#[allow(clippy::should_implement_trait)]
pub async fn next(&mut self) -> Option<Result<T, Error>> {
poll_fn(|context| Pin::new(&mut *self).poll_next(context)).await
}
}
impl<T: DeserializeOwned + Send + 'static> Stream for Items<T> {
type Item = Result<T, Error>;
fn poll_next(self: Pin<&mut Self>, context: &mut Context<'_>) -> Poll<Option<Self::Item>> {
let this = self.get_mut();
loop {
if let Some(item) = this.buffer.pop_front() {
return Poll::Ready(Some(Ok(item)));
}
if let Some(pending) = this.pending.as_mut() {
let result = match pending.as_mut().poll(context) {
Poll::Pending => return Poll::Pending,
Poll::Ready(result) => result,
};
this.pending = None;
match result {
Ok(page) => {
this.next_request = page
.next_cursor()
.map(|cursor| Ok(page.request.with_cursor(cursor)));
this.buffer.extend(page.data);
continue;
}
Err(error) => {
this.next_request = None;
return Poll::Ready(Some(Err(error)));
}
}
}
match this.next_request.take() {
None => return Poll::Ready(None),
Some(Err(error)) => return Poll::Ready(Some(Err(error))),
Some(Ok(request)) => this.pending = Some(Box::pin(request.send_page())),
}
}
}
}
impl<T> fmt::Debug for Items<T> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter
.debug_struct("Items")
.field("buffered", &self.buffer.len())
.field("pending", &self.pending.is_some())
.finish_non_exhaustive()
}
}