gestalt-sdk 0.0.1-alpha.19

// Code generated by sdkgen. DO NOT EDIT.

//! Generated wire conversions for indexeddb.proto.

use crate::codec::support::{
    from_wire_status, from_wire_timestamp, from_wire_value, to_wire_timestamp, to_wire_value,
};
use crate::generated::v1;
use crate::indexeddb::{
    BeginTransactionRequest, ColumnDef, CountResponse, CreateObjectStoreRequest,
    CursorClientMessage, CursorClientMessageMsg, CursorCommand, CursorCommandCommand, CursorEntry,
    CursorKeyTarget, CursorResponse, CursorResponseResult, DeleteObjectStoreRequest,
    DeleteResponse, IndexQueryRequest, IndexSchema, KeyRange, KeyResponse, KeyValue, KeyValueArray,
    KeyValueKind, KeysResponse, ObjectStoreNameRequest, ObjectStoreRangeRequest,
    ObjectStoreRequest, ObjectStoreSchema, OpenCursorRequest, Record, RecordRequest,
    RecordResponse, RecordsResponse, TransactionAbortRequest, TransactionAbortResponse,
    TransactionBeginResponse, TransactionClientMessage, TransactionClientMessageMsg,
    TransactionCommitRequest, TransactionCommitResponse, TransactionOperation,
    TransactionOperationOperation, TransactionOperationResponse,
    TransactionOperationResponseResult, TransactionServerMessage, TransactionServerMessageMsg,
    TypedValue, TypedValueKind,
};

/// Converts a native `BeginTransactionRequest` to its wire message.
pub(crate) fn to_wire_begin_transaction_request(
    value: BeginTransactionRequest,
) -> v1::BeginTransactionRequest {
    v1::BeginTransactionRequest {
        stores: value.stores,
        mode: value.mode,
        durability_hint: value.durability_hint,
    }
}

/// Converts a native `ColumnDef` to its wire message.
pub(crate) fn to_wire_column_def(value: ColumnDef) -> v1::ColumnDef {
    v1::ColumnDef {
        name: value.name,
        r#type: value.r#type,
        primary_key: value.primary_key,
        not_null: value.not_null,
        unique: value.unique,
    }
}

/// Converts a wire `CountResponse` to its native message.
pub(crate) fn from_wire_count_response(value: v1::CountResponse) -> CountResponse {
    CountResponse { count: value.count }
}

/// Converts a native `CreateObjectStoreRequest` to its wire message.
pub(crate) fn to_wire_create_object_store_request(
    value: CreateObjectStoreRequest,
) -> v1::CreateObjectStoreRequest {
    v1::CreateObjectStoreRequest {
        name: value.name,
        schema: value.schema.map(to_wire_object_store_schema),
    }
}

/// Converts a native `CursorClientMessage` to its wire message.
pub(crate) fn to_wire_cursor_client_message(value: CursorClientMessage) -> v1::CursorClientMessage {
    v1::CursorClientMessage {
        msg: value.msg.map(to_wire_cursor_client_message_msg),
    }
}

pub(crate) fn to_wire_cursor_client_message_msg(
    value: CursorClientMessageMsg,
) -> v1::cursor_client_message::Msg {
    match value {
        CursorClientMessageMsg::Open(value) => {
            v1::cursor_client_message::Msg::Open(to_wire_open_cursor_request(value))
        }
        CursorClientMessageMsg::Command(value) => {
            v1::cursor_client_message::Msg::Command(to_wire_cursor_command(value))
        }
    }
}

/// Converts a native `CursorCommand` to its wire message.
pub(crate) fn to_wire_cursor_command(value: CursorCommand) -> v1::CursorCommand {
    v1::CursorCommand {
        command: value.command.map(to_wire_cursor_command_command),
    }
}

pub(crate) fn to_wire_cursor_command_command(
    value: CursorCommandCommand,
) -> v1::cursor_command::Command {
    match value {
        CursorCommandCommand::Next(value) => v1::cursor_command::Command::Next(value),
        CursorCommandCommand::ContinueToKey(value) => {
            v1::cursor_command::Command::ContinueToKey(to_wire_cursor_key_target(value))
        }
        CursorCommandCommand::Advance(value) => v1::cursor_command::Command::Advance(value),
        CursorCommandCommand::Update(value) => {
            v1::cursor_command::Command::Update(to_wire_record(value))
        }
        CursorCommandCommand::Delete(value) => v1::cursor_command::Command::Delete(value),
        CursorCommandCommand::Close(value) => v1::cursor_command::Command::Close(value),
    }
}

/// Converts a wire `CursorEntry` to its native message.
pub(crate) fn from_wire_cursor_entry(value: v1::CursorEntry) -> CursorEntry {
    CursorEntry {
        key: value.key.into_iter().map(from_wire_key_value).collect(),
        primary_key: value.primary_key,
        record: value.record.map(from_wire_record),
    }
}

/// Converts a native `CursorKeyTarget` to its wire message.
pub(crate) fn to_wire_cursor_key_target(value: CursorKeyTarget) -> v1::CursorKeyTarget {
    v1::CursorKeyTarget {
        key: value.key.into_iter().map(to_wire_key_value).collect(),
    }
}

/// Converts a wire `CursorResponse` to its native message.
pub(crate) fn from_wire_cursor_response(value: v1::CursorResponse) -> CursorResponse {
    CursorResponse {
        result: value.result.map(from_wire_cursor_response_result),
    }
}

pub(crate) fn from_wire_cursor_response_result(
    value: v1::cursor_response::Result,
) -> CursorResponseResult {
    match value {
        v1::cursor_response::Result::Entry(value) => {
            CursorResponseResult::Entry(from_wire_cursor_entry(value))
        }
        v1::cursor_response::Result::Done(value) => CursorResponseResult::Done(value),
    }
}

/// Converts a native `DeleteObjectStoreRequest` to its wire message.
pub(crate) fn to_wire_delete_object_store_request(
    value: DeleteObjectStoreRequest,
) -> v1::DeleteObjectStoreRequest {
    v1::DeleteObjectStoreRequest { name: value.name }
}

/// Converts a wire `DeleteResponse` to its native message.
pub(crate) fn from_wire_delete_response(value: v1::DeleteResponse) -> DeleteResponse {
    DeleteResponse {
        deleted: value.deleted,
    }
}

/// Converts a native `IndexQueryRequest` to its wire message.
pub(crate) fn to_wire_index_query_request(value: IndexQueryRequest) -> v1::IndexQueryRequest {
    v1::IndexQueryRequest {
        store: value.store,
        index: value.index,
        values: value.values.into_iter().map(to_wire_typed_value).collect(),
        range: value.range.map(to_wire_key_range),
    }
}

/// Converts a native `IndexSchema` to its wire message.
pub(crate) fn to_wire_index_schema(value: IndexSchema) -> v1::IndexSchema {
    v1::IndexSchema {
        name: value.name,
        key_path: value.key_path,
        unique: value.unique,
    }
}

/// Converts a native `KeyRange` to its wire message.
pub(crate) fn to_wire_key_range(value: KeyRange) -> v1::KeyRange {
    v1::KeyRange {
        lower: value.lower.map(to_wire_typed_value),
        upper: value.upper.map(to_wire_typed_value),
        lower_open: value.lower_open,
        upper_open: value.upper_open,
    }
}

/// Converts a wire `KeyResponse` to its native message.
pub(crate) fn from_wire_key_response(value: v1::KeyResponse) -> KeyResponse {
    KeyResponse { key: value.key }
}

/// Converts a native `KeyValue` to its wire message.
pub(crate) fn to_wire_key_value(value: KeyValue) -> v1::KeyValue {
    v1::KeyValue {
        kind: value.kind.map(to_wire_key_value_kind),
    }
}

/// Converts a wire `KeyValue` to its native message.
pub(crate) fn from_wire_key_value(value: v1::KeyValue) -> KeyValue {
    KeyValue {
        kind: value.kind.map(from_wire_key_value_kind),
    }
}

pub(crate) fn to_wire_key_value_kind(value: KeyValueKind) -> v1::key_value::Kind {
    match value {
        KeyValueKind::Scalar(value) => v1::key_value::Kind::Scalar(to_wire_typed_value(value)),
        KeyValueKind::Array(value) => v1::key_value::Kind::Array(to_wire_key_value_array(value)),
    }
}

pub(crate) fn from_wire_key_value_kind(value: v1::key_value::Kind) -> KeyValueKind {
    match value {
        v1::key_value::Kind::Scalar(value) => KeyValueKind::Scalar(from_wire_typed_value(value)),
        v1::key_value::Kind::Array(value) => KeyValueKind::Array(from_wire_key_value_array(value)),
    }
}

/// Converts a native `KeyValueArray` to its wire message.
pub(crate) fn to_wire_key_value_array(value: KeyValueArray) -> v1::KeyValueArray {
    v1::KeyValueArray {
        elements: value.elements.into_iter().map(to_wire_key_value).collect(),
    }
}

/// Converts a wire `KeyValueArray` to its native message.
pub(crate) fn from_wire_key_value_array(value: v1::KeyValueArray) -> KeyValueArray {
    KeyValueArray {
        elements: value
            .elements
            .into_iter()
            .map(from_wire_key_value)
            .collect(),
    }
}

/// Converts a wire `KeysResponse` to its native message.
pub(crate) fn from_wire_keys_response(value: v1::KeysResponse) -> KeysResponse {
    KeysResponse { keys: value.keys }
}

/// Converts a native `ObjectStoreNameRequest` to its wire message.
pub(crate) fn to_wire_object_store_name_request(
    value: ObjectStoreNameRequest,
) -> v1::ObjectStoreNameRequest {
    v1::ObjectStoreNameRequest { store: value.store }
}

/// Converts a native `ObjectStoreRangeRequest` to its wire message.
pub(crate) fn to_wire_object_store_range_request(
    value: ObjectStoreRangeRequest,
) -> v1::ObjectStoreRangeRequest {
    v1::ObjectStoreRangeRequest {
        store: value.store,
        range: value.range.map(to_wire_key_range),
    }
}

/// Converts a native `ObjectStoreRequest` to its wire message.
pub(crate) fn to_wire_object_store_request(value: ObjectStoreRequest) -> v1::ObjectStoreRequest {
    v1::ObjectStoreRequest {
        store: value.store,
        id: value.id,
    }
}

/// Converts a native `ObjectStoreSchema` to its wire message.
pub(crate) fn to_wire_object_store_schema(value: ObjectStoreSchema) -> v1::ObjectStoreSchema {
    v1::ObjectStoreSchema {
        indexes: value
            .indexes
            .into_iter()
            .map(to_wire_index_schema)
            .collect(),
        columns: value.columns.into_iter().map(to_wire_column_def).collect(),
    }
}

/// Converts a native `OpenCursorRequest` to its wire message.
pub(crate) fn to_wire_open_cursor_request(value: OpenCursorRequest) -> v1::OpenCursorRequest {
    v1::OpenCursorRequest {
        store: value.store,
        range: value.range.map(to_wire_key_range),
        direction: value.direction,
        keys_only: value.keys_only,
        index: value.index,
        values: value.values.into_iter().map(to_wire_typed_value).collect(),
    }
}

/// Converts a native `Record` to its wire message.
pub(crate) fn to_wire_record(value: Record) -> v1::Record {
    v1::Record {
        fields: value
            .fields
            .into_iter()
            .map(|(key, item)| (key, to_wire_typed_value(item)))
            .collect(),
    }
}

/// Converts a wire `Record` to its native message.
pub(crate) fn from_wire_record(value: v1::Record) -> Record {
    Record {
        fields: value
            .fields
            .into_iter()
            .map(|(key, item)| (key, from_wire_typed_value(item)))
            .collect(),
    }
}

/// Converts a native `RecordRequest` to its wire message.
pub(crate) fn to_wire_record_request(value: RecordRequest) -> v1::RecordRequest {
    v1::RecordRequest {
        store: value.store,
        record: value.record.map(to_wire_record),
    }
}

/// Converts a wire `RecordResponse` to its native message.
pub(crate) fn from_wire_record_response(value: v1::RecordResponse) -> RecordResponse {
    RecordResponse {
        record: value.record.map(from_wire_record),
    }
}

/// Converts a wire `RecordsResponse` to its native message.
pub(crate) fn from_wire_records_response(value: v1::RecordsResponse) -> RecordsResponse {
    RecordsResponse {
        records: value.records.into_iter().map(from_wire_record).collect(),
    }
}

/// Converts a native `TransactionAbortRequest` to its wire message.
pub(crate) fn to_wire_transaction_abort_request(
    value: TransactionAbortRequest,
) -> v1::TransactionAbortRequest {
    v1::TransactionAbortRequest {
        reason: value.reason,
    }
}

/// Converts a wire `TransactionAbortResponse` to its native message.
pub(crate) fn from_wire_transaction_abort_response(
    value: v1::TransactionAbortResponse,
) -> TransactionAbortResponse {
    TransactionAbortResponse {
        error: value.error.map(from_wire_status),
    }
}

/// Converts a wire `TransactionBeginResponse` to its native message.
pub(crate) fn from_wire_transaction_begin_response(
    _value: v1::TransactionBeginResponse,
) -> TransactionBeginResponse {
    TransactionBeginResponse {}
}

/// Converts a native `TransactionClientMessage` to its wire message.
pub(crate) fn to_wire_transaction_client_message(
    value: TransactionClientMessage,
) -> v1::TransactionClientMessage {
    v1::TransactionClientMessage {
        msg: value.msg.map(to_wire_transaction_client_message_msg),
    }
}

pub(crate) fn to_wire_transaction_client_message_msg(
    value: TransactionClientMessageMsg,
) -> v1::transaction_client_message::Msg {
    match value {
        TransactionClientMessageMsg::Begin(value) => {
            v1::transaction_client_message::Msg::Begin(to_wire_begin_transaction_request(value))
        }
        TransactionClientMessageMsg::Operation(value) => {
            v1::transaction_client_message::Msg::Operation(to_wire_transaction_operation(value))
        }
        TransactionClientMessageMsg::Commit(value) => {
            v1::transaction_client_message::Msg::Commit(to_wire_transaction_commit_request(value))
        }
        TransactionClientMessageMsg::Abort(value) => {
            v1::transaction_client_message::Msg::Abort(to_wire_transaction_abort_request(value))
        }
    }
}

/// Converts a native `TransactionCommitRequest` to its wire message.
pub(crate) fn to_wire_transaction_commit_request(
    _value: TransactionCommitRequest,
) -> v1::TransactionCommitRequest {
    v1::TransactionCommitRequest {}
}

/// Converts a wire `TransactionCommitResponse` to its native message.
pub(crate) fn from_wire_transaction_commit_response(
    value: v1::TransactionCommitResponse,
) -> TransactionCommitResponse {
    TransactionCommitResponse {
        error: value.error.map(from_wire_status),
    }
}

/// Converts a native `TransactionOperation` to its wire message.
pub(crate) fn to_wire_transaction_operation(
    value: TransactionOperation,
) -> v1::TransactionOperation {
    v1::TransactionOperation {
        request_id: value.request_id,
        operation: value.operation.map(to_wire_transaction_operation_operation),
    }
}

pub(crate) fn to_wire_transaction_operation_operation(
    value: TransactionOperationOperation,
) -> v1::transaction_operation::Operation {
    match value {
        TransactionOperationOperation::Get(value) => {
            v1::transaction_operation::Operation::Get(to_wire_object_store_request(value))
        }
        TransactionOperationOperation::GetKey(value) => {
            v1::transaction_operation::Operation::GetKey(to_wire_object_store_request(value))
        }
        TransactionOperationOperation::Add(value) => {
            v1::transaction_operation::Operation::Add(to_wire_record_request(value))
        }
        TransactionOperationOperation::Put(value) => {
            v1::transaction_operation::Operation::Put(to_wire_record_request(value))
        }
        TransactionOperationOperation::Delete(value) => {
            v1::transaction_operation::Operation::Delete(to_wire_object_store_request(value))
        }
        TransactionOperationOperation::Clear(value) => {
            v1::transaction_operation::Operation::Clear(to_wire_object_store_name_request(value))
        }
        TransactionOperationOperation::GetAll(value) => {
            v1::transaction_operation::Operation::GetAll(to_wire_object_store_range_request(value))
        }
        TransactionOperationOperation::GetAllKeys(value) => {
            v1::transaction_operation::Operation::GetAllKeys(to_wire_object_store_range_request(
                value,
            ))
        }
        TransactionOperationOperation::Count(value) => {
            v1::transaction_operation::Operation::Count(to_wire_object_store_range_request(value))
        }
        TransactionOperationOperation::DeleteRange(value) => {
            v1::transaction_operation::Operation::DeleteRange(to_wire_object_store_range_request(
                value,
            ))
        }
        TransactionOperationOperation::IndexGet(value) => {
            v1::transaction_operation::Operation::IndexGet(to_wire_index_query_request(value))
        }
        TransactionOperationOperation::IndexGetKey(value) => {
            v1::transaction_operation::Operation::IndexGetKey(to_wire_index_query_request(value))
        }
        TransactionOperationOperation::IndexGetAll(value) => {
            v1::transaction_operation::Operation::IndexGetAll(to_wire_index_query_request(value))
        }
        TransactionOperationOperation::IndexGetAllKeys(value) => {
            v1::transaction_operation::Operation::IndexGetAllKeys(to_wire_index_query_request(
                value,
            ))
        }
        TransactionOperationOperation::IndexCount(value) => {
            v1::transaction_operation::Operation::IndexCount(to_wire_index_query_request(value))
        }
        TransactionOperationOperation::IndexDelete(value) => {
            v1::transaction_operation::Operation::IndexDelete(to_wire_index_query_request(value))
        }
    }
}

/// Converts a wire `TransactionOperationResponse` to its native message.
pub(crate) fn from_wire_transaction_operation_response(
    value: v1::TransactionOperationResponse,
) -> TransactionOperationResponse {
    TransactionOperationResponse {
        request_id: value.request_id,
        error: value.error.map(from_wire_status),
        result: value
            .result
            .map(from_wire_transaction_operation_response_result),
    }
}

pub(crate) fn from_wire_transaction_operation_response_result(
    value: v1::transaction_operation_response::Result,
) -> TransactionOperationResponseResult {
    match value {
        v1::transaction_operation_response::Result::Empty(_) => {
            TransactionOperationResponseResult::Empty
        }
        v1::transaction_operation_response::Result::Record(value) => {
            TransactionOperationResponseResult::Record(from_wire_record_response(value))
        }
        v1::transaction_operation_response::Result::Records(value) => {
            TransactionOperationResponseResult::Records(from_wire_records_response(value))
        }
        v1::transaction_operation_response::Result::Key(value) => {
            TransactionOperationResponseResult::Key(from_wire_key_response(value))
        }
        v1::transaction_operation_response::Result::Keys(value) => {
            TransactionOperationResponseResult::Keys(from_wire_keys_response(value))
        }
        v1::transaction_operation_response::Result::Count(value) => {
            TransactionOperationResponseResult::Count(from_wire_count_response(value))
        }
        v1::transaction_operation_response::Result::Delete(value) => {
            TransactionOperationResponseResult::Delete(from_wire_delete_response(value))
        }
    }
}

/// Converts a wire `TransactionServerMessage` to its native message.
pub(crate) fn from_wire_transaction_server_message(
    value: v1::TransactionServerMessage,
) -> TransactionServerMessage {
    TransactionServerMessage {
        msg: value.msg.map(from_wire_transaction_server_message_msg),
    }
}

pub(crate) fn from_wire_transaction_server_message_msg(
    value: v1::transaction_server_message::Msg,
) -> TransactionServerMessageMsg {
    match value {
        v1::transaction_server_message::Msg::Begin(value) => {
            TransactionServerMessageMsg::Begin(from_wire_transaction_begin_response(value))
        }
        v1::transaction_server_message::Msg::Operation(value) => {
            TransactionServerMessageMsg::Operation(from_wire_transaction_operation_response(value))
        }
        v1::transaction_server_message::Msg::Commit(value) => {
            TransactionServerMessageMsg::Commit(from_wire_transaction_commit_response(value))
        }
        v1::transaction_server_message::Msg::Abort(value) => {
            TransactionServerMessageMsg::Abort(from_wire_transaction_abort_response(value))
        }
    }
}

/// Converts a native `TypedValue` to its wire message.
pub(crate) fn to_wire_typed_value(value: TypedValue) -> v1::TypedValue {
    v1::TypedValue {
        kind: value.kind.map(to_wire_typed_value_kind),
    }
}

/// Converts a wire `TypedValue` to its native message.
pub(crate) fn from_wire_typed_value(value: v1::TypedValue) -> TypedValue {
    TypedValue {
        kind: value.kind.map(from_wire_typed_value_kind),
    }
}

pub(crate) fn to_wire_typed_value_kind(value: TypedValueKind) -> v1::typed_value::Kind {
    match value {
        TypedValueKind::NullValue => {
            v1::typed_value::Kind::NullValue(prost_types::NullValue::NullValue as i32)
        }
        TypedValueKind::StringValue(value) => v1::typed_value::Kind::StringValue(value),
        TypedValueKind::IntValue(value) => v1::typed_value::Kind::IntValue(value),
        TypedValueKind::FloatValue(value) => v1::typed_value::Kind::FloatValue(value),
        TypedValueKind::BoolValue(value) => v1::typed_value::Kind::BoolValue(value),
        TypedValueKind::TimeValue(value) => {
            v1::typed_value::Kind::TimeValue(to_wire_timestamp(value))
        }
        TypedValueKind::BytesValue(value) => v1::typed_value::Kind::BytesValue(value),
        TypedValueKind::JsonValue(value) => v1::typed_value::Kind::JsonValue(to_wire_value(value)),
    }
}

pub(crate) fn from_wire_typed_value_kind(value: v1::typed_value::Kind) -> TypedValueKind {
    match value {
        v1::typed_value::Kind::NullValue(_) => TypedValueKind::NullValue,
        v1::typed_value::Kind::StringValue(value) => TypedValueKind::StringValue(value),
        v1::typed_value::Kind::IntValue(value) => TypedValueKind::IntValue(value),
        v1::typed_value::Kind::FloatValue(value) => TypedValueKind::FloatValue(value),
        v1::typed_value::Kind::BoolValue(value) => TypedValueKind::BoolValue(value),
        v1::typed_value::Kind::TimeValue(value) => {
            TypedValueKind::TimeValue(from_wire_timestamp(value))
        }
        v1::typed_value::Kind::BytesValue(value) => TypedValueKind::BytesValue(value),
        v1::typed_value::Kind::JsonValue(value) => {
            TypedValueKind::JsonValue(from_wire_value(value))
        }
    }
}