1use serde::{Deserialize, Serialize};
6use serde_json::value::RawValue;
7use serde_json::Value;
8
9fn default_true() -> bool {
10 true
11}
12
13pub const ENGINE_HANDSHAKE: &str = "engine.handshake";
15pub const QUERY_FIND_MANY: &str = "query.findMany";
16pub const QUERY_FIND_FIRST: &str = "query.findFirst";
17pub const QUERY_FIND_UNIQUE: &str = "query.findUnique";
18pub const QUERY_FIND_UNIQUE_OR_THROW: &str = "query.findUniqueOrThrow";
19pub const QUERY_FIND_FIRST_OR_THROW: &str = "query.findFirstOrThrow";
20pub const QUERY_CREATE: &str = "query.create";
21pub const QUERY_CREATE_MANY: &str = "query.createMany";
22pub const QUERY_UPDATE: &str = "query.update";
23pub const QUERY_DELETE: &str = "query.delete";
24pub const QUERY_COUNT: &str = "query.count";
25pub const QUERY_GROUP_BY: &str = "query.groupBy";
27pub const SCHEMA_VALIDATE: &str = "schema.validate";
29
30pub const TRANSACTION_START: &str = "transaction.start";
33pub const TRANSACTION_COMMIT: &str = "transaction.commit";
35pub const TRANSACTION_ROLLBACK: &str = "transaction.rollback";
37pub const TRANSACTION_BATCH: &str = "transaction.batch";
39
40#[derive(Debug, Clone, Serialize, Deserialize)]
49#[serde(rename_all = "camelCase")]
50pub struct HandshakeParams {
51 pub protocol_version: u32,
53
54 #[serde(skip_serializing_if = "Option::is_none")]
56 pub client_name: Option<String>,
57
58 #[serde(skip_serializing_if = "Option::is_none")]
60 pub client_version: Option<String>,
61}
62
63#[derive(Debug, Clone, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct HandshakeResult {
67 pub engine_version: String,
69
70 pub protocol_version: u32,
72}
73
74#[derive(Debug, Clone, Serialize, Deserialize)]
80#[serde(rename_all = "camelCase")]
81pub struct FindManyParams {
82 pub protocol_version: u32,
84
85 pub model: String,
87
88 #[serde(skip_serializing_if = "Option::is_none")]
91 pub args: Option<Value>,
92
93 #[serde(skip_serializing_if = "Option::is_none")]
95 pub transaction_id: Option<String>,
96
97 #[serde(skip_serializing_if = "Option::is_none")]
100 pub chunk_size: Option<usize>,
101}
102
103#[derive(Debug, Clone, Serialize, Deserialize)]
109#[serde(rename_all = "camelCase")]
110pub struct FindFirstParams {
111 pub protocol_version: u32,
112 pub model: String,
113 #[serde(skip_serializing_if = "Option::is_none")]
114 pub args: Option<Value>,
115 #[serde(skip_serializing_if = "Option::is_none")]
117 pub transaction_id: Option<String>,
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
126#[serde(rename_all = "camelCase")]
127pub struct FindUniqueParams {
128 pub protocol_version: u32,
129 pub model: String,
130 pub filter: Value,
131 #[serde(skip_serializing_if = "Option::is_none")]
133 pub transaction_id: Option<String>,
134}
135
136pub type FindUniqueOrThrowParams = FindUniqueParams;
138
139pub type FindFirstOrThrowParams = FindFirstParams;
141
142#[derive(Debug, Clone, Serialize, Deserialize)]
148#[serde(rename_all = "camelCase")]
149pub struct CreateParams {
150 pub protocol_version: u32,
151 pub model: String,
152 pub data: Value,
153 #[serde(skip_serializing_if = "Option::is_none")]
155 pub transaction_id: Option<String>,
156 #[serde(default = "default_true")]
158 pub return_data: bool,
159}
160
161#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(rename_all = "camelCase")]
168pub struct CreateManyParams {
169 pub protocol_version: u32,
170 pub model: String,
171 pub data: Vec<Value>,
172 #[serde(skip_serializing_if = "Option::is_none")]
174 pub transaction_id: Option<String>,
175 #[serde(default = "default_true")]
177 pub return_data: bool,
178}
179
180#[derive(Debug, Clone, Serialize, Deserialize)]
186#[serde(rename_all = "camelCase")]
187pub struct UpdateParams {
188 pub protocol_version: u32,
189 pub model: String,
190 pub filter: Value,
191 pub data: Value,
192 #[serde(skip_serializing_if = "Option::is_none")]
194 pub transaction_id: Option<String>,
195 #[serde(default = "default_true")]
197 pub return_data: bool,
198}
199
200#[derive(Debug, Clone, Serialize, Deserialize)]
206#[serde(rename_all = "camelCase")]
207pub struct DeleteParams {
208 pub protocol_version: u32,
209 pub model: String,
210 pub filter: Value,
211 #[serde(skip_serializing_if = "Option::is_none")]
213 pub transaction_id: Option<String>,
214 #[serde(default = "default_true")]
216 pub return_data: bool,
217}
218
219#[derive(Debug, Clone, Serialize, Deserialize)]
225#[serde(rename_all = "camelCase")]
226pub struct CountParams {
227 pub protocol_version: u32,
228 pub model: String,
229 #[serde(skip_serializing_if = "Option::is_none")]
231 pub args: Option<Value>,
232 #[serde(skip_serializing_if = "Option::is_none")]
234 pub transaction_id: Option<String>,
235}
236
237#[derive(Debug, Clone, Serialize, Deserialize)]
243#[serde(rename_all = "camelCase")]
244pub struct GroupByParams {
245 pub protocol_version: u32,
246 pub model: String,
247 #[serde(skip_serializing_if = "Option::is_none")]
249 pub args: Option<Value>,
250 #[serde(skip_serializing_if = "Option::is_none")]
252 pub transaction_id: Option<String>,
253}
254
255#[derive(Debug, Clone, Serialize, Deserialize)]
261pub struct QueryResult {
262 pub data: Vec<Value>,
264}
265
266#[derive(Debug, Clone, Serialize, Deserialize)]
268pub struct MutationResult {
269 pub count: usize,
271
272 #[serde(skip_serializing_if = "Option::is_none")]
274 pub data: Option<Vec<Value>>,
275}
276
277#[derive(Debug, Clone, Serialize, Deserialize)]
287#[serde(rename_all = "camelCase")]
288pub struct SchemaValidateParams {
289 pub protocol_version: u32,
290 pub schema: String,
291}
292
293#[derive(Debug, Clone, Serialize, Deserialize)]
297pub struct SchemaValidateResult {
298 pub valid: bool,
300
301 #[serde(skip_serializing_if = "Option::is_none")]
303 pub errors: Option<Vec<String>>,
304}
305
306#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
312#[serde(rename_all = "camelCase")]
313pub enum IsolationLevel {
314 ReadUncommitted,
316 ReadCommitted,
318 RepeatableRead,
320 Serializable,
322}
323
324impl IsolationLevel {
325 pub fn as_sql(&self) -> &'static str {
327 match self {
328 IsolationLevel::ReadUncommitted => "READ UNCOMMITTED",
329 IsolationLevel::ReadCommitted => "READ COMMITTED",
330 IsolationLevel::RepeatableRead => "REPEATABLE READ",
331 IsolationLevel::Serializable => "SERIALIZABLE",
332 }
333 }
334}
335
336#[derive(Debug, Clone, Serialize, Deserialize)]
338#[serde(rename_all = "camelCase")]
339pub struct TransactionStartParams {
340 pub protocol_version: u32,
341 #[serde(skip_serializing_if = "Option::is_none")]
344 pub timeout_ms: Option<u64>,
345 #[serde(skip_serializing_if = "Option::is_none")]
347 pub isolation_level: Option<IsolationLevel>,
348}
349
350#[derive(Debug, Clone, Serialize, Deserialize)]
352#[serde(rename_all = "camelCase")]
353pub struct TransactionStartResult {
354 pub id: String,
357}
358
359#[derive(Debug, Clone, Serialize, Deserialize)]
361#[serde(rename_all = "camelCase")]
362pub struct TransactionCommitParams {
363 pub protocol_version: u32,
364 pub id: String,
366}
367
368#[derive(Debug, Clone, Serialize, Deserialize)]
370pub struct TransactionCommitResult {}
371
372#[derive(Debug, Clone, Serialize, Deserialize)]
374#[serde(rename_all = "camelCase")]
375pub struct TransactionRollbackParams {
376 pub protocol_version: u32,
377 pub id: String,
379}
380
381#[derive(Debug, Clone, Serialize, Deserialize)]
383pub struct TransactionRollbackResult {}
384
385#[derive(Debug, Clone, Serialize, Deserialize)]
387#[serde(rename_all = "camelCase")]
388pub struct BatchOperation {
389 pub method: String,
391 pub params: Value,
393}
394
395#[derive(Debug, Clone, Serialize, Deserialize)]
397#[serde(rename_all = "camelCase")]
398pub struct TransactionBatchParams {
399 pub protocol_version: u32,
400 pub operations: Vec<BatchOperation>,
402 #[serde(skip_serializing_if = "Option::is_none")]
404 pub isolation_level: Option<IsolationLevel>,
405 #[serde(skip_serializing_if = "Option::is_none")]
407 pub timeout_ms: Option<u64>,
408}
409
410#[derive(Debug, Clone, Serialize, Deserialize)]
412pub struct TransactionBatchResult {
413 pub results: Vec<Box<RawValue>>,
415}