gestalt/
indexeddb.rs

1// Code generated by sdkgen. DO NOT EDIT.
2
3//! Generated native types and clients for indexeddb.proto.
4
5use crate::codec::host_service::{HostServiceChannel, connect_host_service, plain_channel};
6use crate::codec::indexeddb::{
7    from_wire_count_response, from_wire_cursor_response, from_wire_delete_response,
8    from_wire_key_response, from_wire_keys_response, from_wire_record_response,
9    from_wire_records_response, from_wire_transaction_server_message, to_wire_create_index_request,
10    to_wire_create_object_store_request, to_wire_cursor_client_message,
11    to_wire_delete_index_request, to_wire_delete_object_store_request, to_wire_index_query_request,
12    to_wire_object_store_name_request, to_wire_object_store_range_request,
13    to_wire_object_store_request, to_wire_record_request, to_wire_transaction_client_message,
14};
15use crate::generated::v1;
16use crate::rpc_support::{GestaltError, RpcStatus};
17use tokio_stream::StreamExt;
18
19/// Open enum for `gestalt.provider.v1.CursorDirection`; unknown numeric values are preserved.
20pub type CursorDirection = i32;
21
22/// CursorDirection controls IndexedDB cursor traversal order.
23///
24/// Named values of `CursorDirection`.
25pub mod cursor_direction {
26    /// CURSOR_NEXT.
27    pub const CURSOR_NEXT: i32 = 0;
28    /// CURSOR_NEXT_UNIQUE.
29    pub const CURSOR_NEXT_UNIQUE: i32 = 1;
30    /// CURSOR_PREV.
31    pub const CURSOR_PREV: i32 = 2;
32    /// CURSOR_PREV_UNIQUE.
33    pub const CURSOR_PREV_UNIQUE: i32 = 3;
34}
35
36/// Open enum for `gestalt.provider.v1.TransactionDurabilityHint`; unknown numeric values are preserved.
37pub type TransactionDurabilityHint = i32;
38
39/// TransactionDurabilityHint mirrors the W3C IndexedDB durability option as a
40/// provider hint. It is not a portable durability guarantee.
41///
42/// Named values of `TransactionDurabilityHint`.
43pub mod transaction_durability_hint {
44    /// TRANSACTION_DURABILITY_DEFAULT.
45    pub const TRANSACTION_DURABILITY_DEFAULT: i32 = 0;
46    /// TRANSACTION_DURABILITY_STRICT.
47    pub const TRANSACTION_DURABILITY_STRICT: i32 = 1;
48    /// TRANSACTION_DURABILITY_RELAXED.
49    pub const TRANSACTION_DURABILITY_RELAXED: i32 = 2;
50}
51
52/// Open enum for `gestalt.provider.v1.TransactionMode`; unknown numeric values are preserved.
53pub type TransactionMode = i32;
54
55/// TransactionMode controls whether a transaction may mutate scoped stores.
56///
57/// Named values of `TransactionMode`.
58pub mod transaction_mode {
59    /// TRANSACTION_READONLY.
60    pub const TRANSACTION_READONLY: i32 = 0;
61    /// TRANSACTION_READWRITE.
62    pub const TRANSACTION_READWRITE: i32 = 1;
63}
64
65/// BeginTransactionRequest starts an IndexedDB transaction stream.
66///
67/// Native message type for `gestalt.provider.v1.BeginTransactionRequest`.
68#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
69#[serde(rename_all = "camelCase")]
70pub struct BeginTransactionRequest {
71    /// The `stores` field.
72    pub stores: Vec<String>,
73    /// The `mode` field.
74    pub mode: TransactionMode,
75    /// The `durability_hint` field.
76    pub durability_hint: TransactionDurabilityHint,
77}
78
79/// ColumnDef is reserved for providers that preserve SQL-style column metadata.
80///
81/// Native message type for `gestalt.provider.v1.ColumnDef`.
82#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
83#[serde(rename_all = "camelCase")]
84pub struct ColumnDef {
85    /// The `name` field.
86    pub name: String,
87    /// The `type` field.
88    pub r#type: i32,
89    /// The `primary_key` field.
90    pub primary_key: bool,
91    /// The `not_null` field.
92    pub not_null: bool,
93    /// The `unique` field.
94    pub unique: bool,
95}
96
97/// CountResponse reports how many rows matched a query.
98///
99/// Native message type for `gestalt.provider.v1.CountResponse`.
100#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
101#[serde(rename_all = "camelCase")]
102pub struct CountResponse {
103    /// The `count` field.
104    pub count: i64,
105}
106
107/// CreateIndexRequest adds a secondary index to an existing object store.
108///
109/// Native message type for `gestalt.provider.v1.CreateIndexRequest`.
110#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
111#[serde(rename_all = "camelCase")]
112pub struct CreateIndexRequest {
113    /// The `store` field.
114    pub store: String,
115    /// The `name` field.
116    pub name: String,
117    /// The `key_path` field.
118    pub key_path: Vec<String>,
119    /// The `unique` field.
120    pub unique: bool,
121}
122
123/// CreateObjectStoreRequest creates a new object store.
124///
125/// Native message type for `gestalt.provider.v1.CreateObjectStoreRequest`.
126#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
127#[serde(rename_all = "camelCase")]
128pub struct CreateObjectStoreRequest {
129    /// The `name` field.
130    pub name: String,
131    /// The `schema` field; None when unset.
132    pub schema: Option<ObjectStoreSchema>,
133}
134
135/// Values of the `msg` oneof in `CursorClientMessage`; the message field is None when unset.
136#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
137#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
138pub enum CursorClientMessageMsg {
139    /// The `open` variant.
140    Open(OpenCursorRequest),
141    /// The `command` variant.
142    Command(CursorCommand),
143}
144
145/// CursorClientMessage is one frame in the bidirectional cursor stream.
146///
147/// Native message type for `gestalt.provider.v1.CursorClientMessage`.
148#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
149#[serde(rename_all = "camelCase")]
150pub struct CursorClientMessage {
151    /// The `msg` oneof; None when unset.
152    pub msg: Option<CursorClientMessageMsg>,
153}
154
155/// Values of the `command` oneof in `CursorCommand`; the message field is None when unset.
156#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
157#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
158pub enum CursorCommandCommand {
159    /// The `next` variant.
160    Next(bool),
161    /// The `continue_to_key` variant.
162    ContinueToKey(CursorKeyTarget),
163    /// The `advance` variant.
164    Advance(i32),
165    /// The `update` variant.
166    Update(Record),
167    /// The `delete` variant.
168    Delete(bool),
169    /// The `close` variant.
170    Close(bool),
171}
172
173/// CursorCommand advances, mutates, or closes an open cursor.
174///
175/// Native message type for `gestalt.provider.v1.CursorCommand`.
176#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
177#[serde(rename_all = "camelCase")]
178pub struct CursorCommand {
179    /// The `command` oneof; None when unset.
180    pub command: Option<CursorCommandCommand>,
181}
182
183/// CursorEntry is one streamed cursor row.
184///
185/// Native message type for `gestalt.provider.v1.CursorEntry`.
186#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
187#[serde(rename_all = "camelCase")]
188pub struct CursorEntry {
189    /// One full IndexedDB key (scalar or array).
190    /// <https://www.w3.org/TR/IndexedDB/#dom-idbcursor-key>
191    ///
192    /// The `key` field; None when unset.
193    pub key: Option<KeyValue>,
194    /// The `primary_key` field.
195    pub primary_key: String,
196    /// The `record` field; None when unset.
197    pub record: Option<Record>,
198}
199
200/// CursorKeyTarget addresses a specific cursor position.
201///
202/// Native message type for `gestalt.provider.v1.CursorKeyTarget`.
203#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
204#[serde(rename_all = "camelCase")]
205pub struct CursorKeyTarget {
206    /// The `key` field; None when unset.
207    pub key: Option<KeyValue>,
208}
209
210/// Values of the `result` oneof in `CursorResponse`; the message field is None when unset.
211#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
212#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
213pub enum CursorResponseResult {
214    /// The `entry` variant.
215    Entry(CursorEntry),
216    /// The `done` variant.
217    Done(bool),
218}
219
220/// CursorResponse is one streamed cursor frame.
221///
222/// Native message type for `gestalt.provider.v1.CursorResponse`.
223#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
224#[serde(rename_all = "camelCase")]
225pub struct CursorResponse {
226    /// The `result` oneof; None when unset.
227    pub result: Option<CursorResponseResult>,
228}
229
230/// DeleteIndexRequest removes a secondary index from an existing object store.
231///
232/// Native message type for `gestalt.provider.v1.DeleteIndexRequest`.
233#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
234#[serde(rename_all = "camelCase")]
235pub struct DeleteIndexRequest {
236    /// The `store` field.
237    pub store: String,
238    /// The `name` field.
239    pub name: String,
240}
241
242/// DeleteObjectStoreRequest removes an object store.
243///
244/// Native message type for `gestalt.provider.v1.DeleteObjectStoreRequest`.
245#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
246#[serde(rename_all = "camelCase")]
247pub struct DeleteObjectStoreRequest {
248    /// The `name` field.
249    pub name: String,
250}
251
252/// DeleteResponse reports how many rows were deleted.
253///
254/// Native message type for `gestalt.provider.v1.DeleteResponse`.
255#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
256#[serde(rename_all = "camelCase")]
257pub struct DeleteResponse {
258    /// The `deleted` field.
259    pub deleted: i64,
260}
261
262/// IndexQueryRequest addresses a secondary index plus an optional query.
263///
264/// Native message type for `gestalt.provider.v1.IndexQueryRequest`.
265#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
266#[serde(rename_all = "camelCase")]
267pub struct IndexQueryRequest {
268    /// The `store` field.
269    pub store: String,
270    /// The `index` field.
271    pub index: String,
272    /// The `query` field; None when unset.
273    pub query: Option<IndexedDBQuery>,
274    /// The `count` field; None when unset.
275    pub count: Option<u32>,
276}
277
278/// IndexSchema describes one secondary index on an object store.
279///
280/// Native message type for `gestalt.provider.v1.IndexSchema`.
281#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
282#[serde(rename_all = "camelCase")]
283pub struct IndexSchema {
284    /// The `name` field.
285    pub name: String,
286    /// The `key_path` field.
287    pub key_path: Vec<String>,
288    /// The `unique` field.
289    pub unique: bool,
290}
291
292/// Values of the `query` oneof in `IndexedDBQuery`; the message field is None when unset.
293#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
294#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
295pub enum IndexedDBQueryQuery {
296    /// The `key` variant.
297    Key(KeyValue),
298    /// The `range` variant.
299    Range(KeyRange),
300}
301
302/// IndexedDBQuery is a single IndexedDB query argument: an exact key or a key
303/// range. An absent IndexedDBQuery (or an unset oneof) means "all records",
304/// matching a W3C query argument of undefined/null.
305///
306/// Native message type for `gestalt.provider.v1.IndexedDBQuery`.
307#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
308#[serde(rename_all = "camelCase")]
309pub struct IndexedDBQuery {
310    /// The `query` oneof; None when unset.
311    pub query: Option<IndexedDBQueryQuery>,
312}
313
314/// KeyRange constrains a query or cursor by lower and upper bounds. Bounds are
315/// full IndexedDB keys (scalar or array), matching W3C IDBKeyRange. An absent
316/// lower/upper means unbounded on that side.
317/// <https://www.w3.org/TR/IndexedDB/#keyrange>
318///
319/// Native message type for `gestalt.provider.v1.KeyRange`.
320#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
321#[serde(rename_all = "camelCase")]
322pub struct KeyRange {
323    /// The `lower` field; None when unset.
324    pub lower: Option<KeyValue>,
325    /// The `upper` field; None when unset.
326    pub upper: Option<KeyValue>,
327    /// The `lower_open` field.
328    pub lower_open: bool,
329    /// The `upper_open` field.
330    pub upper_open: bool,
331}
332
333/// KeyResponse wraps one primary key.
334///
335/// Native message type for `gestalt.provider.v1.KeyResponse`.
336#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
337#[serde(rename_all = "camelCase")]
338pub struct KeyResponse {
339    /// The `key` field.
340    pub key: String,
341}
342
343/// Values of the `kind` oneof in `KeyValue`; the message field is None when unset.
344#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
345#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
346pub enum KeyValueKind {
347    /// The `scalar` variant.
348    Scalar(TypedValue),
349    /// The `array` variant.
350    Array(KeyValueArray),
351}
352
353/// KeyValue represents one IndexedDB key: a scalar (string, number, date,
354/// binary) or a nested array of keys, per the W3C spec.
355/// <https://www.w3.org/TR/IndexedDB/#key-construct>
356///
357/// Native message type for `gestalt.provider.v1.KeyValue`.
358#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
359#[serde(rename_all = "camelCase")]
360pub struct KeyValue {
361    /// The `kind` oneof; None when unset.
362    pub kind: Option<KeyValueKind>,
363}
364
365/// Native message type for `gestalt.provider.v1.KeyValueArray`.
366#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
367#[serde(rename_all = "camelCase")]
368pub struct KeyValueArray {
369    /// The `elements` field.
370    pub elements: Vec<KeyValue>,
371}
372
373/// KeysResponse wraps repeated primary keys.
374///
375/// Native message type for `gestalt.provider.v1.KeysResponse`.
376#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
377#[serde(rename_all = "camelCase")]
378pub struct KeysResponse {
379    /// The `keys` field.
380    pub keys: Vec<String>,
381}
382
383/// ObjectStoreNameRequest addresses an object store without a specific row key.
384///
385/// Native message type for `gestalt.provider.v1.ObjectStoreNameRequest`.
386#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
387#[serde(rename_all = "camelCase")]
388pub struct ObjectStoreNameRequest {
389    /// The `store` field.
390    pub store: String,
391}
392
393/// ObjectStoreRangeRequest addresses an object store plus an optional query.
394///
395/// Native message type for `gestalt.provider.v1.ObjectStoreRangeRequest`.
396#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
397#[serde(rename_all = "camelCase")]
398pub struct ObjectStoreRangeRequest {
399    /// The `store` field.
400    pub store: String,
401    /// The `query` field; None when unset.
402    pub query: Option<IndexedDBQuery>,
403    /// The `count` field; None when unset.
404    pub count: Option<u32>,
405}
406
407/// ObjectStoreRequest addresses one object store row by primary key.
408///
409/// Native message type for `gestalt.provider.v1.ObjectStoreRequest`.
410#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
411#[serde(rename_all = "camelCase")]
412pub struct ObjectStoreRequest {
413    /// The `store` field.
414    pub store: String,
415    /// The `id` field.
416    pub id: String,
417}
418
419/// ObjectStoreSchema describes the indexes and columns attached to an object
420/// store.
421///
422/// Native message type for `gestalt.provider.v1.ObjectStoreSchema`.
423#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
424#[serde(rename_all = "camelCase")]
425pub struct ObjectStoreSchema {
426    /// The `indexes` field.
427    pub indexes: Vec<IndexSchema>,
428    /// The `columns` field.
429    pub columns: Vec<ColumnDef>,
430}
431
432/// OpenCursorRequest starts a streaming cursor over an object store or index.
433///
434/// Native message type for `gestalt.provider.v1.OpenCursorRequest`.
435#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
436#[serde(rename_all = "camelCase")]
437pub struct OpenCursorRequest {
438    /// The `store` field.
439    pub store: String,
440    /// The `index` field.
441    pub index: String,
442    /// The `query` field; None when unset.
443    pub query: Option<IndexedDBQuery>,
444    /// The `direction` field.
445    pub direction: CursorDirection,
446    /// keys_only suppresses row payloads and returns only keys.
447    ///
448    /// The `keys_only` field.
449    pub keys_only: bool,
450}
451
452/// Record is one JSON-like row in an object store.
453///
454/// Native message type for `gestalt.provider.v1.Record`.
455#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
456#[serde(rename_all = "camelCase")]
457pub struct Record {
458    /// The `fields` field.
459    pub fields: std::collections::BTreeMap<String, TypedValue>,
460}
461
462/// RecordRequest addresses one object store and carries one row payload.
463///
464/// Native message type for `gestalt.provider.v1.RecordRequest`.
465#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
466#[serde(rename_all = "camelCase")]
467pub struct RecordRequest {
468    /// The `store` field.
469    pub store: String,
470    /// The `record` field; None when unset.
471    pub record: Option<Record>,
472}
473
474/// RecordResponse wraps one row payload.
475///
476/// Native message type for `gestalt.provider.v1.RecordResponse`.
477#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
478#[serde(rename_all = "camelCase")]
479pub struct RecordResponse {
480    /// The `record` field; None when unset.
481    pub record: Option<Record>,
482}
483
484/// RecordsResponse wraps repeated row payloads.
485///
486/// Native message type for `gestalt.provider.v1.RecordsResponse`.
487#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
488#[serde(rename_all = "camelCase")]
489pub struct RecordsResponse {
490    /// The `records` field.
491    pub records: Vec<Record>,
492}
493
494/// Native message type for `gestalt.provider.v1.TransactionAbortRequest`.
495#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
496#[serde(rename_all = "camelCase")]
497pub struct TransactionAbortRequest {
498    /// The `reason` field.
499    pub reason: String,
500}
501
502/// TransactionAbortResponse acknowledges abort or reports an abort failure.
503///
504/// Native message type for `gestalt.provider.v1.TransactionAbortResponse`.
505#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
506#[serde(rename_all = "camelCase")]
507pub struct TransactionAbortResponse {
508    /// The `error` field; None when unset.
509    pub error: Option<RpcStatus>,
510}
511
512/// Native message type for `gestalt.provider.v1.TransactionBeginResponse`.
513#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
514#[serde(rename_all = "camelCase")]
515pub struct TransactionBeginResponse {}
516
517/// Values of the `msg` oneof in `TransactionClientMessage`; the message field is None when unset.
518#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
519#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
520pub enum TransactionClientMessageMsg {
521    /// The `begin` variant.
522    Begin(BeginTransactionRequest),
523    /// The `operation` variant.
524    Operation(TransactionOperation),
525    /// The `commit` variant.
526    Commit(TransactionCommitRequest),
527    /// The `abort` variant.
528    Abort(TransactionAbortRequest),
529}
530
531/// TransactionClientMessage is one client frame in the transaction stream. The
532/// first frame must be BeginTransactionRequest.
533///
534/// Native message type for `gestalt.provider.v1.TransactionClientMessage`.
535#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
536#[serde(rename_all = "camelCase")]
537pub struct TransactionClientMessage {
538    /// The `msg` oneof; None when unset.
539    pub msg: Option<TransactionClientMessageMsg>,
540}
541
542/// Native message type for `gestalt.provider.v1.TransactionCommitRequest`.
543#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
544#[serde(rename_all = "camelCase")]
545pub struct TransactionCommitRequest {}
546
547/// TransactionCommitResponse carries a non-OK status when commit failed after
548/// the provider accepted the commit frame and rolled the transaction back.
549///
550/// Native message type for `gestalt.provider.v1.TransactionCommitResponse`.
551#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
552#[serde(rename_all = "camelCase")]
553pub struct TransactionCommitResponse {
554    /// The `error` field; None when unset.
555    pub error: Option<RpcStatus>,
556}
557
558/// Values of the `operation` oneof in `TransactionOperation`; the message field is None when unset.
559#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
560#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
561pub enum TransactionOperationOperation {
562    /// The `get` variant.
563    Get(ObjectStoreRequest),
564    /// The `get_key` variant.
565    GetKey(ObjectStoreRequest),
566    /// The `add` variant.
567    Add(RecordRequest),
568    /// The `put` variant.
569    Put(RecordRequest),
570    /// The `delete` variant.
571    Delete(ObjectStoreRequest),
572    /// The `clear` variant.
573    Clear(ObjectStoreNameRequest),
574    /// The `get_all` variant.
575    GetAll(ObjectStoreRangeRequest),
576    /// The `get_all_keys` variant.
577    GetAllKeys(ObjectStoreRangeRequest),
578    /// The `count` variant.
579    Count(ObjectStoreRangeRequest),
580    /// The `delete_range` variant.
581    DeleteRange(ObjectStoreRangeRequest),
582    /// The `index_get` variant.
583    IndexGet(IndexQueryRequest),
584    /// The `index_get_key` variant.
585    IndexGetKey(IndexQueryRequest),
586    /// The `index_get_all` variant.
587    IndexGetAll(IndexQueryRequest),
588    /// The `index_get_all_keys` variant.
589    IndexGetAllKeys(IndexQueryRequest),
590    /// The `index_count` variant.
591    IndexCount(IndexQueryRequest),
592    /// The `index_delete` variant.
593    IndexDelete(IndexQueryRequest),
594}
595
596/// TransactionOperation is one ordered transaction-scoped object store or index
597/// operation. Cursor operations are intentionally excluded from the initial
598/// transaction contract.
599///
600/// Native message type for `gestalt.provider.v1.TransactionOperation`.
601#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
602#[serde(rename_all = "camelCase")]
603pub struct TransactionOperation {
604    /// The `request_id` field.
605    pub request_id: u64,
606    /// The `operation` oneof; None when unset.
607    pub operation: Option<TransactionOperationOperation>,
608}
609
610/// Values of the `result` oneof in `TransactionOperationResponse`; the message field is None when unset.
611#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
612#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
613pub enum TransactionOperationResponseResult {
614    /// The `empty` variant.
615    Empty,
616    /// The `record` variant.
617    Record(RecordResponse),
618    /// The `records` variant.
619    Records(RecordsResponse),
620    /// The `key` variant.
621    Key(KeyResponse),
622    /// The `keys` variant.
623    Keys(KeysResponse),
624    /// The `count` variant.
625    Count(CountResponse),
626    /// The `delete` variant.
627    Delete(DeleteResponse),
628}
629
630/// TransactionOperationResponse is the ordered response to one operation.
631/// Non-OK error marks the transaction failed and causes rollback in phase 1.
632///
633/// Native message type for `gestalt.provider.v1.TransactionOperationResponse`.
634#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
635#[serde(rename_all = "camelCase")]
636pub struct TransactionOperationResponse {
637    /// The `request_id` field.
638    pub request_id: u64,
639    /// The `error` field; None when unset.
640    pub error: Option<RpcStatus>,
641    /// The `result` oneof; None when unset.
642    pub result: Option<TransactionOperationResponseResult>,
643}
644
645/// Values of the `msg` oneof in `TransactionServerMessage`; the message field is None when unset.
646#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
647#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
648pub enum TransactionServerMessageMsg {
649    /// The `begin` variant.
650    Begin(TransactionBeginResponse),
651    /// The `operation` variant.
652    Operation(TransactionOperationResponse),
653    /// The `commit` variant.
654    Commit(TransactionCommitResponse),
655    /// The `abort` variant.
656    Abort(TransactionAbortResponse),
657}
658
659/// Native message type for `gestalt.provider.v1.TransactionServerMessage`.
660#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
661#[serde(rename_all = "camelCase")]
662pub struct TransactionServerMessage {
663    /// The `msg` oneof; None when unset.
664    pub msg: Option<TransactionServerMessageMsg>,
665}
666
667/// Values of the `kind` oneof in `TypedValue`; the message field is None when unset.
668#[allow(clippy::enum_variant_names, clippy::large_enum_variant)]
669#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
670pub enum TypedValueKind {
671    /// The `null_value` variant.
672    NullValue,
673    /// The `string_value` variant.
674    StringValue(String),
675    /// The `int_value` variant.
676    IntValue(i64),
677    /// The `float_value` variant.
678    FloatValue(f64),
679    /// The `bool_value` variant.
680    BoolValue(bool),
681    /// The `time_value` variant.
682    TimeValue(std::time::SystemTime),
683    /// The `bytes_value` variant.
684    BytesValue(Vec<u8>),
685    /// The `json_value` variant.
686    JsonValue(serde_json::Value),
687}
688
689/// TypedValue stores one scalar or structured value in an IndexedDB record.
690///
691/// Native message type for `gestalt.provider.v1.TypedValue`.
692#[derive(Clone, Debug, Default, PartialEq, serde::Serialize, serde::Deserialize)]
693#[serde(rename_all = "camelCase")]
694pub struct TypedValue {
695    /// The `kind` oneof; None when unset.
696    pub kind: Option<TypedValueKind>,
697}
698
699/// IndexedDB models the shared Gestalt IndexedDB-provider protocol.
700///
701/// Client for the `gestalt.provider.v1.IndexedDB` service.
702pub struct IndexedDB {
703    inner: v1::indexed_db_client::IndexedDbClient<HostServiceChannel>,
704    timeout: Option<std::time::Duration>,
705}
706
707impl IndexedDB {
708    /// Creates a client over an established channel.
709    pub fn new(channel: tonic::transport::Channel) -> Self {
710        Self {
711            inner: v1::indexed_db_client::IndexedDbClient::new(plain_channel(channel)),
712            timeout: None,
713        }
714    }
715
716    /// Sets a deadline applied to every unary call; calls that run past it
717    /// fail with DEADLINE_EXCEEDED. Streaming calls are unaffected.
718    pub fn with_timeout(mut self, timeout: std::time::Duration) -> Self {
719        self.timeout = Some(timeout);
720        self
721    }
722
723    /// Connects to the `indexeddb` host service described by the environment.
724    pub async fn connect() -> Result<Self, GestaltError> {
725        Self::connect_named("").await
726    }
727
728    /// Connects to the named `indexeddb` host-service binding.
729    pub async fn connect_named(name: &str) -> Result<Self, GestaltError> {
730        Ok(Self {
731            inner: v1::indexed_db_client::IndexedDbClient::new(
732                connect_host_service("indexeddb", name).await?,
733            ),
734            timeout: None,
735        })
736    }
737
738    /// Lifecycle
739    ///
740    /// Calls `gestalt.provider.v1.IndexedDB.CreateObjectStore`.
741    pub async fn create_object_store(
742        &mut self,
743        name: String,
744        schema: Option<ObjectStoreSchema>,
745    ) -> Result<(), GestaltError> {
746        let request = CreateObjectStoreRequest { name, schema };
747        let mut tonic_request = tonic::Request::new(to_wire_create_object_store_request(request));
748        if let Some(timeout) = self.timeout {
749            tonic_request.set_timeout(timeout);
750        }
751        self.inner.create_object_store(tonic_request).await?;
752        Ok(())
753    }
754
755    /// Lifecycle
756    ///
757    /// Calls `gestalt.provider.v1.IndexedDB.CreateObjectStore` with the full request and response messages.
758    pub async fn create_object_store_raw(
759        &mut self,
760        request: CreateObjectStoreRequest,
761    ) -> Result<(), GestaltError> {
762        let mut tonic_request = tonic::Request::new(to_wire_create_object_store_request(request));
763        if let Some(timeout) = self.timeout {
764            tonic_request.set_timeout(timeout);
765        }
766        self.inner.create_object_store(tonic_request).await?;
767        Ok(())
768    }
769
770    /// Calls `gestalt.provider.v1.IndexedDB.DeleteObjectStore`.
771    pub async fn delete_object_store(&mut self, name: String) -> Result<(), GestaltError> {
772        let request = DeleteObjectStoreRequest { name };
773        let mut tonic_request = tonic::Request::new(to_wire_delete_object_store_request(request));
774        if let Some(timeout) = self.timeout {
775            tonic_request.set_timeout(timeout);
776        }
777        self.inner.delete_object_store(tonic_request).await?;
778        Ok(())
779    }
780
781    /// Calls `gestalt.provider.v1.IndexedDB.DeleteObjectStore` with the full request and response messages.
782    pub async fn delete_object_store_raw(
783        &mut self,
784        request: DeleteObjectStoreRequest,
785    ) -> Result<(), GestaltError> {
786        let mut tonic_request = tonic::Request::new(to_wire_delete_object_store_request(request));
787        if let Some(timeout) = self.timeout {
788            tonic_request.set_timeout(timeout);
789        }
790        self.inner.delete_object_store(tonic_request).await?;
791        Ok(())
792    }
793
794    /// Calls `gestalt.provider.v1.IndexedDB.CreateIndex`.
795    pub async fn create_index(
796        &mut self,
797        store: String,
798        name: String,
799        key_path: Vec<String>,
800        unique: bool,
801    ) -> Result<(), GestaltError> {
802        let request = CreateIndexRequest {
803            store,
804            name,
805            key_path,
806            unique,
807        };
808        let mut tonic_request = tonic::Request::new(to_wire_create_index_request(request));
809        if let Some(timeout) = self.timeout {
810            tonic_request.set_timeout(timeout);
811        }
812        self.inner.create_index(tonic_request).await?;
813        Ok(())
814    }
815
816    /// Calls `gestalt.provider.v1.IndexedDB.CreateIndex` with the full request and response messages.
817    pub async fn create_index_raw(
818        &mut self,
819        request: CreateIndexRequest,
820    ) -> Result<(), GestaltError> {
821        let mut tonic_request = tonic::Request::new(to_wire_create_index_request(request));
822        if let Some(timeout) = self.timeout {
823            tonic_request.set_timeout(timeout);
824        }
825        self.inner.create_index(tonic_request).await?;
826        Ok(())
827    }
828
829    /// Calls `gestalt.provider.v1.IndexedDB.DeleteIndex`.
830    pub async fn delete_index(&mut self, store: String, name: String) -> Result<(), GestaltError> {
831        let request = DeleteIndexRequest { store, name };
832        let mut tonic_request = tonic::Request::new(to_wire_delete_index_request(request));
833        if let Some(timeout) = self.timeout {
834            tonic_request.set_timeout(timeout);
835        }
836        self.inner.delete_index(tonic_request).await?;
837        Ok(())
838    }
839
840    /// Calls `gestalt.provider.v1.IndexedDB.DeleteIndex` with the full request and response messages.
841    pub async fn delete_index_raw(
842        &mut self,
843        request: DeleteIndexRequest,
844    ) -> Result<(), GestaltError> {
845        let mut tonic_request = tonic::Request::new(to_wire_delete_index_request(request));
846        if let Some(timeout) = self.timeout {
847            tonic_request.set_timeout(timeout);
848        }
849        self.inner.delete_index(tonic_request).await?;
850        Ok(())
851    }
852
853    /// Primary key CRUD
854    ///
855    /// Calls `gestalt.provider.v1.IndexedDB.Get`.
856    pub async fn get(&mut self, store: String, id: String) -> Result<RecordResponse, GestaltError> {
857        let request = ObjectStoreRequest { store, id };
858        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
859        if let Some(timeout) = self.timeout {
860            tonic_request.set_timeout(timeout);
861        }
862        let response = self.inner.get(tonic_request).await?;
863        Ok(from_wire_record_response(response.into_inner()))
864    }
865
866    /// Primary key CRUD
867    ///
868    /// Calls `gestalt.provider.v1.IndexedDB.Get` with the full request and response messages.
869    pub async fn get_raw(
870        &mut self,
871        request: ObjectStoreRequest,
872    ) -> Result<RecordResponse, GestaltError> {
873        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
874        if let Some(timeout) = self.timeout {
875            tonic_request.set_timeout(timeout);
876        }
877        let response = self.inner.get(tonic_request).await?;
878        Ok(from_wire_record_response(response.into_inner()))
879    }
880
881    /// Calls `gestalt.provider.v1.IndexedDB.GetKey`.
882    pub async fn get_key(
883        &mut self,
884        store: String,
885        id: String,
886    ) -> Result<KeyResponse, GestaltError> {
887        let request = ObjectStoreRequest { store, id };
888        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
889        if let Some(timeout) = self.timeout {
890            tonic_request.set_timeout(timeout);
891        }
892        let response = self.inner.get_key(tonic_request).await?;
893        Ok(from_wire_key_response(response.into_inner()))
894    }
895
896    /// Calls `gestalt.provider.v1.IndexedDB.GetKey` with the full request and response messages.
897    pub async fn get_key_raw(
898        &mut self,
899        request: ObjectStoreRequest,
900    ) -> Result<KeyResponse, GestaltError> {
901        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
902        if let Some(timeout) = self.timeout {
903            tonic_request.set_timeout(timeout);
904        }
905        let response = self.inner.get_key(tonic_request).await?;
906        Ok(from_wire_key_response(response.into_inner()))
907    }
908
909    /// Calls `gestalt.provider.v1.IndexedDB.Add`.
910    pub async fn add(&mut self, store: String, record: Option<Record>) -> Result<(), GestaltError> {
911        let request = RecordRequest { store, record };
912        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
913        if let Some(timeout) = self.timeout {
914            tonic_request.set_timeout(timeout);
915        }
916        self.inner.add(tonic_request).await?;
917        Ok(())
918    }
919
920    /// Calls `gestalt.provider.v1.IndexedDB.Add` with the full request and response messages.
921    pub async fn add_raw(&mut self, request: RecordRequest) -> Result<(), GestaltError> {
922        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
923        if let Some(timeout) = self.timeout {
924            tonic_request.set_timeout(timeout);
925        }
926        self.inner.add(tonic_request).await?;
927        Ok(())
928    }
929
930    /// Calls `gestalt.provider.v1.IndexedDB.Put`.
931    pub async fn put(&mut self, store: String, record: Option<Record>) -> Result<(), GestaltError> {
932        let request = RecordRequest { store, record };
933        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
934        if let Some(timeout) = self.timeout {
935            tonic_request.set_timeout(timeout);
936        }
937        self.inner.put(tonic_request).await?;
938        Ok(())
939    }
940
941    /// Calls `gestalt.provider.v1.IndexedDB.Put` with the full request and response messages.
942    pub async fn put_raw(&mut self, request: RecordRequest) -> Result<(), GestaltError> {
943        let mut tonic_request = tonic::Request::new(to_wire_record_request(request));
944        if let Some(timeout) = self.timeout {
945            tonic_request.set_timeout(timeout);
946        }
947        self.inner.put(tonic_request).await?;
948        Ok(())
949    }
950
951    /// Calls `gestalt.provider.v1.IndexedDB.Delete`.
952    pub async fn delete(&mut self, store: String, id: String) -> Result<(), GestaltError> {
953        let request = ObjectStoreRequest { store, id };
954        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
955        if let Some(timeout) = self.timeout {
956            tonic_request.set_timeout(timeout);
957        }
958        self.inner.delete(tonic_request).await?;
959        Ok(())
960    }
961
962    /// Calls `gestalt.provider.v1.IndexedDB.Delete` with the full request and response messages.
963    pub async fn delete_raw(&mut self, request: ObjectStoreRequest) -> Result<(), GestaltError> {
964        let mut tonic_request = tonic::Request::new(to_wire_object_store_request(request));
965        if let Some(timeout) = self.timeout {
966            tonic_request.set_timeout(timeout);
967        }
968        self.inner.delete(tonic_request).await?;
969        Ok(())
970    }
971
972    /// Bulk operations (with optional query)
973    ///
974    /// Calls `gestalt.provider.v1.IndexedDB.Clear`.
975    pub async fn clear(&mut self, store: String) -> Result<(), GestaltError> {
976        let request = ObjectStoreNameRequest { store };
977        let mut tonic_request = tonic::Request::new(to_wire_object_store_name_request(request));
978        if let Some(timeout) = self.timeout {
979            tonic_request.set_timeout(timeout);
980        }
981        self.inner.clear(tonic_request).await?;
982        Ok(())
983    }
984
985    /// Bulk operations (with optional query)
986    ///
987    /// Calls `gestalt.provider.v1.IndexedDB.Clear` with the full request and response messages.
988    pub async fn clear_raw(&mut self, request: ObjectStoreNameRequest) -> Result<(), GestaltError> {
989        let mut tonic_request = tonic::Request::new(to_wire_object_store_name_request(request));
990        if let Some(timeout) = self.timeout {
991            tonic_request.set_timeout(timeout);
992        }
993        self.inner.clear(tonic_request).await?;
994        Ok(())
995    }
996
997    /// Calls `gestalt.provider.v1.IndexedDB.GetAll`.
998    pub async fn get_all(
999        &mut self,
1000        store: String,
1001        query: Option<IndexedDBQuery>,
1002        options: IndexedDBGetAllOptions,
1003    ) -> Result<RecordsResponse, GestaltError> {
1004        let request = ObjectStoreRangeRequest {
1005            store,
1006            query,
1007            count: options.count,
1008        };
1009        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1010        if let Some(timeout) = self.timeout {
1011            tonic_request.set_timeout(timeout);
1012        }
1013        let response = self.inner.get_all(tonic_request).await?;
1014        Ok(from_wire_records_response(response.into_inner()))
1015    }
1016
1017    /// Calls `gestalt.provider.v1.IndexedDB.GetAll` with the full request and response messages.
1018    pub async fn get_all_raw(
1019        &mut self,
1020        request: ObjectStoreRangeRequest,
1021    ) -> Result<RecordsResponse, GestaltError> {
1022        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1023        if let Some(timeout) = self.timeout {
1024            tonic_request.set_timeout(timeout);
1025        }
1026        let response = self.inner.get_all(tonic_request).await?;
1027        Ok(from_wire_records_response(response.into_inner()))
1028    }
1029
1030    /// Calls `gestalt.provider.v1.IndexedDB.GetAllKeys`.
1031    pub async fn get_all_keys(
1032        &mut self,
1033        store: String,
1034        query: Option<IndexedDBQuery>,
1035        options: IndexedDBGetAllKeysOptions,
1036    ) -> Result<KeysResponse, GestaltError> {
1037        let request = ObjectStoreRangeRequest {
1038            store,
1039            query,
1040            count: options.count,
1041        };
1042        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1043        if let Some(timeout) = self.timeout {
1044            tonic_request.set_timeout(timeout);
1045        }
1046        let response = self.inner.get_all_keys(tonic_request).await?;
1047        Ok(from_wire_keys_response(response.into_inner()))
1048    }
1049
1050    /// Calls `gestalt.provider.v1.IndexedDB.GetAllKeys` with the full request and response messages.
1051    pub async fn get_all_keys_raw(
1052        &mut self,
1053        request: ObjectStoreRangeRequest,
1054    ) -> Result<KeysResponse, GestaltError> {
1055        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1056        if let Some(timeout) = self.timeout {
1057            tonic_request.set_timeout(timeout);
1058        }
1059        let response = self.inner.get_all_keys(tonic_request).await?;
1060        Ok(from_wire_keys_response(response.into_inner()))
1061    }
1062
1063    /// Calls `gestalt.provider.v1.IndexedDB.Count`.
1064    pub async fn count(
1065        &mut self,
1066        store: String,
1067        query: Option<IndexedDBQuery>,
1068    ) -> Result<i64, GestaltError> {
1069        let request = ObjectStoreRangeRequest {
1070            store,
1071            query,
1072            ..Default::default()
1073        };
1074        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1075        if let Some(timeout) = self.timeout {
1076            tonic_request.set_timeout(timeout);
1077        }
1078        let response =
1079            from_wire_count_response(self.inner.count(tonic_request).await?.into_inner());
1080        Ok(response.count)
1081    }
1082
1083    /// Calls `gestalt.provider.v1.IndexedDB.Count` with the full request and response messages.
1084    pub async fn count_raw(
1085        &mut self,
1086        request: ObjectStoreRangeRequest,
1087    ) -> Result<CountResponse, GestaltError> {
1088        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1089        if let Some(timeout) = self.timeout {
1090            tonic_request.set_timeout(timeout);
1091        }
1092        let response = self.inner.count(tonic_request).await?;
1093        Ok(from_wire_count_response(response.into_inner()))
1094    }
1095
1096    /// Calls `gestalt.provider.v1.IndexedDB.DeleteRange`.
1097    pub async fn delete_range(
1098        &mut self,
1099        store: String,
1100        query: Option<IndexedDBQuery>,
1101    ) -> Result<DeleteResponse, GestaltError> {
1102        let request = ObjectStoreRangeRequest {
1103            store,
1104            query,
1105            ..Default::default()
1106        };
1107        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1108        if let Some(timeout) = self.timeout {
1109            tonic_request.set_timeout(timeout);
1110        }
1111        let response = self.inner.delete_range(tonic_request).await?;
1112        Ok(from_wire_delete_response(response.into_inner()))
1113    }
1114
1115    /// Calls `gestalt.provider.v1.IndexedDB.DeleteRange` with the full request and response messages.
1116    pub async fn delete_range_raw(
1117        &mut self,
1118        request: ObjectStoreRangeRequest,
1119    ) -> Result<DeleteResponse, GestaltError> {
1120        let mut tonic_request = tonic::Request::new(to_wire_object_store_range_request(request));
1121        if let Some(timeout) = self.timeout {
1122            tonic_request.set_timeout(timeout);
1123        }
1124        let response = self.inner.delete_range(tonic_request).await?;
1125        Ok(from_wire_delete_response(response.into_inner()))
1126    }
1127
1128    /// Index queries
1129    ///
1130    /// Calls `gestalt.provider.v1.IndexedDB.IndexGet`.
1131    pub async fn index_get(
1132        &mut self,
1133        store: String,
1134        index: String,
1135        query: Option<IndexedDBQuery>,
1136    ) -> Result<RecordResponse, GestaltError> {
1137        let request = IndexQueryRequest {
1138            store,
1139            index,
1140            query,
1141            ..Default::default()
1142        };
1143        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1144        if let Some(timeout) = self.timeout {
1145            tonic_request.set_timeout(timeout);
1146        }
1147        let response = self.inner.index_get(tonic_request).await?;
1148        Ok(from_wire_record_response(response.into_inner()))
1149    }
1150
1151    /// Index queries
1152    ///
1153    /// Calls `gestalt.provider.v1.IndexedDB.IndexGet` with the full request and response messages.
1154    pub async fn index_get_raw(
1155        &mut self,
1156        request: IndexQueryRequest,
1157    ) -> Result<RecordResponse, GestaltError> {
1158        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1159        if let Some(timeout) = self.timeout {
1160            tonic_request.set_timeout(timeout);
1161        }
1162        let response = self.inner.index_get(tonic_request).await?;
1163        Ok(from_wire_record_response(response.into_inner()))
1164    }
1165
1166    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetKey`.
1167    pub async fn index_get_key(
1168        &mut self,
1169        store: String,
1170        index: String,
1171        query: Option<IndexedDBQuery>,
1172    ) -> Result<KeyResponse, GestaltError> {
1173        let request = IndexQueryRequest {
1174            store,
1175            index,
1176            query,
1177            ..Default::default()
1178        };
1179        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1180        if let Some(timeout) = self.timeout {
1181            tonic_request.set_timeout(timeout);
1182        }
1183        let response = self.inner.index_get_key(tonic_request).await?;
1184        Ok(from_wire_key_response(response.into_inner()))
1185    }
1186
1187    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetKey` with the full request and response messages.
1188    pub async fn index_get_key_raw(
1189        &mut self,
1190        request: IndexQueryRequest,
1191    ) -> Result<KeyResponse, GestaltError> {
1192        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1193        if let Some(timeout) = self.timeout {
1194            tonic_request.set_timeout(timeout);
1195        }
1196        let response = self.inner.index_get_key(tonic_request).await?;
1197        Ok(from_wire_key_response(response.into_inner()))
1198    }
1199
1200    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAll`.
1201    pub async fn index_get_all(
1202        &mut self,
1203        store: String,
1204        index: String,
1205        query: Option<IndexedDBQuery>,
1206        options: IndexedDBIndexGetAllOptions,
1207    ) -> Result<RecordsResponse, GestaltError> {
1208        let request = IndexQueryRequest {
1209            store,
1210            index,
1211            query,
1212            count: options.count,
1213        };
1214        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1215        if let Some(timeout) = self.timeout {
1216            tonic_request.set_timeout(timeout);
1217        }
1218        let response = self.inner.index_get_all(tonic_request).await?;
1219        Ok(from_wire_records_response(response.into_inner()))
1220    }
1221
1222    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAll` with the full request and response messages.
1223    pub async fn index_get_all_raw(
1224        &mut self,
1225        request: IndexQueryRequest,
1226    ) -> Result<RecordsResponse, GestaltError> {
1227        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1228        if let Some(timeout) = self.timeout {
1229            tonic_request.set_timeout(timeout);
1230        }
1231        let response = self.inner.index_get_all(tonic_request).await?;
1232        Ok(from_wire_records_response(response.into_inner()))
1233    }
1234
1235    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAllKeys`.
1236    pub async fn index_get_all_keys(
1237        &mut self,
1238        store: String,
1239        index: String,
1240        query: Option<IndexedDBQuery>,
1241        options: IndexedDBIndexGetAllKeysOptions,
1242    ) -> Result<KeysResponse, GestaltError> {
1243        let request = IndexQueryRequest {
1244            store,
1245            index,
1246            query,
1247            count: options.count,
1248        };
1249        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1250        if let Some(timeout) = self.timeout {
1251            tonic_request.set_timeout(timeout);
1252        }
1253        let response = self.inner.index_get_all_keys(tonic_request).await?;
1254        Ok(from_wire_keys_response(response.into_inner()))
1255    }
1256
1257    /// Calls `gestalt.provider.v1.IndexedDB.IndexGetAllKeys` with the full request and response messages.
1258    pub async fn index_get_all_keys_raw(
1259        &mut self,
1260        request: IndexQueryRequest,
1261    ) -> Result<KeysResponse, GestaltError> {
1262        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1263        if let Some(timeout) = self.timeout {
1264            tonic_request.set_timeout(timeout);
1265        }
1266        let response = self.inner.index_get_all_keys(tonic_request).await?;
1267        Ok(from_wire_keys_response(response.into_inner()))
1268    }
1269
1270    /// Calls `gestalt.provider.v1.IndexedDB.IndexCount`.
1271    pub async fn index_count(
1272        &mut self,
1273        store: String,
1274        index: String,
1275        query: Option<IndexedDBQuery>,
1276    ) -> Result<i64, GestaltError> {
1277        let request = IndexQueryRequest {
1278            store,
1279            index,
1280            query,
1281            ..Default::default()
1282        };
1283        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1284        if let Some(timeout) = self.timeout {
1285            tonic_request.set_timeout(timeout);
1286        }
1287        let response =
1288            from_wire_count_response(self.inner.index_count(tonic_request).await?.into_inner());
1289        Ok(response.count)
1290    }
1291
1292    /// Calls `gestalt.provider.v1.IndexedDB.IndexCount` with the full request and response messages.
1293    pub async fn index_count_raw(
1294        &mut self,
1295        request: IndexQueryRequest,
1296    ) -> Result<CountResponse, GestaltError> {
1297        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1298        if let Some(timeout) = self.timeout {
1299            tonic_request.set_timeout(timeout);
1300        }
1301        let response = self.inner.index_count(tonic_request).await?;
1302        Ok(from_wire_count_response(response.into_inner()))
1303    }
1304
1305    /// Calls `gestalt.provider.v1.IndexedDB.IndexDelete`.
1306    pub async fn index_delete(
1307        &mut self,
1308        store: String,
1309        index: String,
1310        query: Option<IndexedDBQuery>,
1311    ) -> Result<DeleteResponse, GestaltError> {
1312        let request = IndexQueryRequest {
1313            store,
1314            index,
1315            query,
1316            ..Default::default()
1317        };
1318        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1319        if let Some(timeout) = self.timeout {
1320            tonic_request.set_timeout(timeout);
1321        }
1322        let response = self.inner.index_delete(tonic_request).await?;
1323        Ok(from_wire_delete_response(response.into_inner()))
1324    }
1325
1326    /// Calls `gestalt.provider.v1.IndexedDB.IndexDelete` with the full request and response messages.
1327    pub async fn index_delete_raw(
1328        &mut self,
1329        request: IndexQueryRequest,
1330    ) -> Result<DeleteResponse, GestaltError> {
1331        let mut tonic_request = tonic::Request::new(to_wire_index_query_request(request));
1332        if let Some(timeout) = self.timeout {
1333            tonic_request.set_timeout(timeout);
1334        }
1335        let response = self.inner.index_delete(tonic_request).await?;
1336        Ok(from_wire_delete_response(response.into_inner()))
1337    }
1338
1339    /// Cursor iteration (bidirectional stream)
1340    ///
1341    /// Calls `gestalt.provider.v1.IndexedDB.OpenCursor`, returning a stream of converted frames.
1342    pub async fn open_cursor(
1343        &mut self,
1344        requests: impl tokio_stream::Stream<Item = CursorClientMessage> + Send + 'static,
1345    ) -> Result<IndexedDBOpenCursorStream, GestaltError> {
1346        let response = self
1347            .inner
1348            .open_cursor(requests.map(to_wire_cursor_client_message))
1349            .await?;
1350        Ok(IndexedDBOpenCursorStream {
1351            inner: response.into_inner(),
1352        })
1353    }
1354
1355    /// Transaction stream. The first client message must be
1356    /// BeginTransactionRequest. Stream close before commit aborts the transaction.
1357    ///
1358    /// Calls `gestalt.provider.v1.IndexedDB.Transaction`, returning a stream of converted frames.
1359    pub async fn transaction(
1360        &mut self,
1361        requests: impl tokio_stream::Stream<Item = TransactionClientMessage> + Send + 'static,
1362    ) -> Result<IndexedDBTransactionStream, GestaltError> {
1363        let response = self
1364            .inner
1365            .transaction(requests.map(to_wire_transaction_client_message))
1366            .await?;
1367        Ok(IndexedDBTransactionStream {
1368            inner: response.into_inner(),
1369        })
1370    }
1371}
1372
1373/// Optional parameters of [`IndexedDB::get_all`]; the default value leaves every
1374/// option unset.
1375#[derive(Clone, Debug, Default)]
1376pub struct IndexedDBGetAllOptions {
1377    /// The `count` field; None when unset.
1378    pub count: Option<u32>,
1379}
1380
1381/// Optional parameters of [`IndexedDB::get_all_keys`]; the default value leaves every
1382/// option unset.
1383#[derive(Clone, Debug, Default)]
1384pub struct IndexedDBGetAllKeysOptions {
1385    /// The `count` field; None when unset.
1386    pub count: Option<u32>,
1387}
1388
1389/// Optional parameters of [`IndexedDB::index_get_all`]; the default value leaves every
1390/// option unset.
1391#[derive(Clone, Debug, Default)]
1392pub struct IndexedDBIndexGetAllOptions {
1393    /// The `count` field; None when unset.
1394    pub count: Option<u32>,
1395}
1396
1397/// Optional parameters of [`IndexedDB::index_get_all_keys`]; the default value leaves every
1398/// option unset.
1399#[derive(Clone, Debug, Default)]
1400pub struct IndexedDBIndexGetAllKeysOptions {
1401    /// The `count` field; None when unset.
1402    pub count: Option<u32>,
1403}
1404
1405/// Cursor iteration (bidirectional stream)
1406///
1407/// Stream of converted `CursorResponse` frames; transport errors convert to GestaltError.
1408pub struct IndexedDBOpenCursorStream {
1409    inner: tonic::Streaming<v1::CursorResponse>,
1410}
1411
1412impl IndexedDBOpenCursorStream {
1413    /// Receives the next frame, or None when the stream ends.
1414    pub async fn recv(&mut self) -> Result<Option<CursorResponse>, GestaltError> {
1415        Ok(self.inner.message().await?.map(from_wire_cursor_response))
1416    }
1417}
1418
1419/// Transaction stream. The first client message must be
1420/// BeginTransactionRequest. Stream close before commit aborts the transaction.
1421///
1422/// Stream of converted `TransactionServerMessage` frames; transport errors convert to GestaltError.
1423pub struct IndexedDBTransactionStream {
1424    inner: tonic::Streaming<v1::TransactionServerMessage>,
1425}
1426
1427impl IndexedDBTransactionStream {
1428    /// Receives the next frame, or None when the stream ends.
1429    pub async fn recv(&mut self) -> Result<Option<TransactionServerMessage>, GestaltError> {
1430        Ok(self
1431            .inner
1432            .message()
1433            .await?
1434            .map(from_wire_transaction_server_message))
1435    }
1436}
gestalt/indexeddb.rs

gestalt/
indexeddb.rs
