browser_commander/playwright/protocol/
api_request_context.rs1#![allow(clippy::all, missing_docs, unused_imports)]
5
6use serde::{Deserialize, Serialize};
7
8use super::*;
9use crate::playwright::connection::{
10 Binary, Channel, ChannelType, ObjectRef, ProtocolError, ProtocolEvent, Ref,
11};
12
13#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
15pub struct APIRequestContextInitializer {
16 #[serde(rename = "tracing")]
17 pub tracing: Ref<Tracing>,
18}
19
20#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
22pub struct APIRequestContextFetchParams {
23 #[serde(rename = "url")]
24 pub url: String,
25 #[serde(rename = "encodedParams", default, skip_serializing_if = "Option::is_none")]
26 pub encoded_params: Option<String>,
27 #[serde(rename = "params", default, skip_serializing_if = "Option::is_none")]
28 pub params: Option<Vec<NameValue>>,
29 #[serde(rename = "method", default, skip_serializing_if = "Option::is_none")]
30 pub method: Option<String>,
31 #[serde(rename = "headers", default, skip_serializing_if = "Option::is_none")]
32 pub headers: Option<Vec<NameValue>>,
33 #[serde(rename = "postData", default, skip_serializing_if = "Option::is_none")]
34 pub post_data: Option<Binary>,
35 #[serde(rename = "jsonData", default, skip_serializing_if = "Option::is_none")]
36 pub json_data: Option<String>,
37 #[serde(rename = "formData", default, skip_serializing_if = "Option::is_none")]
38 pub form_data: Option<Vec<NameValue>>,
39 #[serde(rename = "multipartData", default, skip_serializing_if = "Option::is_none")]
40 pub multipart_data: Option<Vec<FormField>>,
41 #[serde(rename = "failOnStatusCode", default, skip_serializing_if = "Option::is_none")]
42 pub fail_on_status_code: Option<bool>,
43 #[serde(rename = "ignoreHTTPSErrors", default, skip_serializing_if = "Option::is_none")]
44 pub ignore_https_errors: Option<bool>,
45 #[serde(rename = "maxRedirects", default, skip_serializing_if = "Option::is_none")]
46 pub max_redirects: Option<i64>,
47 #[serde(rename = "maxRetries", default, skip_serializing_if = "Option::is_none")]
48 pub max_retries: Option<i64>,
49}
50
51#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
53pub struct APIRequestContextFetchResult {
54 #[serde(rename = "response")]
55 pub response: APIResponse,
56}
57
58#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
60pub struct APIRequestContextFetchResponseBodyParams {
61 #[serde(rename = "fetchUid")]
62 pub fetch_uid: String,
63}
64
65#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
67pub struct APIRequestContextFetchResponseBodyResult {
68 #[serde(rename = "binary", default, skip_serializing_if = "Option::is_none")]
69 pub binary: Option<Binary>,
70}
71
72#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
74pub struct APIRequestContextFetchLogParams {
75 #[serde(rename = "fetchUid")]
76 pub fetch_uid: String,
77}
78
79#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
81pub struct APIRequestContextFetchLogResult {
82 #[serde(rename = "log")]
83 pub log: Vec<String>,
84}
85
86#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
88pub struct APIRequestContextStorageStateParams {
89 #[serde(rename = "indexedDB", default, skip_serializing_if = "Option::is_none")]
90 pub indexed_db: Option<bool>,
91 #[serde(rename = "opfs", default, skip_serializing_if = "Option::is_none")]
92 pub opfs: Option<bool>,
93}
94
95#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
97pub struct APIRequestContextStorageStateResult {
98 #[serde(rename = "cookies")]
99 pub cookies: Vec<NetworkCookie>,
100 #[serde(rename = "origins")]
101 pub origins: Vec<OriginStorage>,
102}
103
104#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
106pub struct APIRequestContextDisposeAPIResponseParams {
107 #[serde(rename = "fetchUid")]
108 pub fetch_uid: String,
109}
110
111#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
113pub struct APIRequestContextDisposeParams {
114 #[serde(rename = "reason", default, skip_serializing_if = "Option::is_none")]
115 pub reason: Option<String>,
116}
117
118#[derive(Debug, Clone, PartialEq)]
120pub enum APIRequestContextEvent {
121 Unknown {
123 method: String,
125 params: serde_json::Value,
127 },
128}
129
130impl ProtocolEvent for APIRequestContextEvent {
131 fn parse(method: &str, params: serde_json::Value) -> Result<Self, serde_json::Error> {
132 match method {
133 _ => Ok(Self::Unknown { method: method.to_string(), params }),
134 }
135 }
136}
137
138#[derive(Debug, Clone)]
140pub struct APIRequestContext {
141 channel: Channel,
142}
143
144impl ChannelType for APIRequestContext {
145 const INTERFACE: &'static str = "APIRequestContext";
146 type Initializer = APIRequestContextInitializer;
147 type Event = APIRequestContextEvent;
148
149 fn accepts(interface: &str) -> bool {
150 matches!(interface, "APIRequestContext")
151 }
152
153 fn from_channel(channel: Channel) -> Self {
154 Self { channel }
155 }
156
157 fn channel(&self) -> &Channel {
158 &self.channel
159 }
160}
161
162impl APIRequestContext {
163 pub async fn fetch(&self, params: APIRequestContextFetchParams) -> Result<APIRequestContextFetchResult, ProtocolError> {
165 self.channel.send("fetch", ¶ms).await
166 }
167
168 pub async fn fetch_response_body(&self, params: APIRequestContextFetchResponseBodyParams) -> Result<APIRequestContextFetchResponseBodyResult, ProtocolError> {
170 self.channel.send("fetchResponseBody", ¶ms).await
171 }
172
173 pub async fn fetch_log(&self, params: APIRequestContextFetchLogParams) -> Result<APIRequestContextFetchLogResult, ProtocolError> {
175 self.channel.send("fetchLog", ¶ms).await
176 }
177
178 pub async fn storage_state(&self, params: APIRequestContextStorageStateParams) -> Result<APIRequestContextStorageStateResult, ProtocolError> {
180 self.channel.send("storageState", ¶ms).await
181 }
182
183 pub async fn dispose_api_response(&self, params: APIRequestContextDisposeAPIResponseParams) -> Result<(), ProtocolError> {
185 self.channel.send_no_result("disposeAPIResponse", ¶ms).await
186 }
187
188 pub async fn dispose(&self, params: APIRequestContextDisposeParams) -> Result<(), ProtocolError> {
190 self.channel.send_no_result("dispose", ¶ms).await
191 }
192}