Page MenuHomePhabricator
Differential D11515

[keyserver] expose getFarcasterUsers client method to JS on keyserver
ClosedPublic
Actions

Authored by varun on Apr 1 2024, 2:59 PM.
Tags
None
Referenced Files
F6200240: D11515.diff
Wed, Apr 23, 7:20 PM
Unknown Object (File)
Tue, Apr 22, 3:18 PM
Unknown Object (File)
Tue, Apr 22, 11:14 AM
Unknown Object (File)
Tue, Apr 22, 4:49 AM
Unknown Object (File)
Mon, Apr 21, 2:37 AM
Unknown Object (File)
Mon, Apr 14, 12:39 PM
Unknown Object (File)
Sat, Apr 12, 7:54 PM
Unknown Object (File)
Mar 15 2025, 5:45 AM
View All 64 Files
Subscribers
ashoat
atul
tomek

Details

Reviewers
atul
bartek
Commits
rCOMMd36ab4dcb7f8: [keyserver] expose getFarcasterUsers client method to JS on keyserver
Summary

@atul mentioned we need to call getFarcasterUsers from the keyserver, so this code makes that possible.

Test Plan

https://gist.github.com/vdhanan/0a0498c9e672d44e0e51331c78510f80

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

varun created this revision.Apr 1 2024, 2:59 PM
Herald added subscribers: tomek, ashoat. · View Herald TranscriptApr 1 2024, 2:59 PM
Harbormaster completed remote builds in B27899: Diff 38641.Apr 1 2024, 3:15 PM
varun requested review of this revision.Apr 1 2024, 3:15 PM
atul accepted this revision.Apr 1 2024, 8:21 PM
varun added inline comments.Apr 2 2024, 12:06 PM
keyserver/addons/rust-node-addon/src/identity_client/get_farcaster_users.rs
35 ↗(On Diff #38641)

i'll add a comment here and in lib/types/identity-service-types.js to keep the FarcasterUser types in sync

bartek accepted this revision.Apr 2 2024, 10:52 PM
This revision is now accepted and ready to land.Apr 2 2024, 10:52 PM
Closed by commit rCOMMd36ab4dcb7f8: [keyserver] expose getFarcasterUsers client method to JS on keyserver (authored by varun). · Explain WhyApr 4 2024, 6:42 PM
This revision was automatically updated to reflect the committed changes.
varun added a commit: rCOMMd36ab4dcb7f8: [keyserver] expose getFarcasterUsers client method to JS on keyserver.

Revision Contents
Changeset List

PathSize
keyserver/
addons/
rust-node-addon/
8 lines
src/
identity_client/
43 lines
1 line
lib/
types/
10 lines

Diff 38816

View Options

keyserver/addons/rust-node-addon/rust-binding-types.js

use std::collections::HashMap; use std::collections::HashMap;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use comm_lib::{ use comm_lib::{
aws::ddb::{ aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
}, },
database::{AttributeMap, DBItemAttributeError, DBItemError, DynamoDBError}, database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
DynamoDBError, TryFromAttribute,
},
}; };
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{DeviceListError, Error, FromAttributeValue}, error::{DeviceListError, Error, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::DatabaseClient;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines AttributeValue::S(format!(
value.0.to_rfc3339() value.0.to_rfc3339()
)) ))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute { impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp // remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX) .strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
Show All 11 Lines fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<AttributeMap> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type: String = attrs.take_attr(ATTR_DEVICE_TYPE)?;
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
DBItemError::new( DBItemError::new(
ATTR_DEVICE_TYPE.to_string(), ATTR_DEVICE_TYPE.to_string(),
raw_device_type.into(), raw_device_type.into(),
DBItemAttributeError::InvalidValue, DBItemAttributeError::InvalidValue,
) )
})?; })?;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines fn from(value: IdentityKeyInfo) -> Self {
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload = attrs.take_attr(ATTR_KEY_PAYLOAD)?;
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; let key_payload_signature = attrs.take_attr(ATTR_KEY_PAYLOAD_SIGNATURE)?;
let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
.remove(ATTR_SOCIAL_PROOF) .remove(ATTR_SOCIAL_PROOF)
.map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned()) .map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned())
.transpose()?; .transpose()?;
Ok(Self { Ok(Self {
key_payload, key_payload,
Show All 14 Lines fn from(value: PreKey) -> Self {
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key = attrs.take_attr(ATTR_PREKEY)?;
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; let pre_key_signature = attrs.take_attr(ATTR_PREKEY_SIGNATURE)?;
let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE),
)?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<AttributeMap> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned()) .and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok()) .and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis()) .filter(|val| *val == timestamp.timestamp_millis())
.is_some(); .is_some();
if !timestamps_match { if !timestamps_match {
warn!( warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})", "DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id, &user_id,
timestamp.to_rfc3339() timestamp.to_rfc3339()
); );
} }
// this should be a list of strings let device_ids: Vec<String> = attrs.take_attr(ATTR_DEVICE_IDS)?;
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None.into(),
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines let raw_datetime =
user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME); user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME);
// existing records will not have this field when // existing records will not have this field when
// updating device list for the first time // updating device list for the first time
if raw_datetime.is_none() { if raw_datetime.is_none() {
return Ok(None); return Ok(None);
} }
let timestamp = parse_date_time_attribute( let timestamp = DateTime::<Utc>::try_from_attr(
USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
raw_datetime, raw_datetime,
)?; )?;
Ok(Some(timestamp)) Ok(Some(timestamp))
} }
/// Generates update expression for current device list timestamp in users table. /// Generates update expression for current device list timestamp in users table.
/// The previous timestamp is used as a condition to ensure that the value hasn't changed /// The previous timestamp is used as a condition to ensure that the value hasn't changed
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines
View Options

keyserver/addons/rust-node-addon/src/identity_client/get_farcaster_users.rs

use std::collections::HashMap; use std::collections::HashMap;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use comm_lib::{ use comm_lib::{
aws::ddb::{ aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
}, },
database::{AttributeMap, DBItemAttributeError, DBItemError, DynamoDBError}, database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
DynamoDBError, TryFromAttribute,
},
}; };
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{DeviceListError, Error, FromAttributeValue}, error::{DeviceListError, Error, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::DatabaseClient;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines AttributeValue::S(format!(
value.0.to_rfc3339() value.0.to_rfc3339()
)) ))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute { impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp // remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX) .strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
Show All 11 Lines fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<AttributeMap> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type: String = attrs.take_attr(ATTR_DEVICE_TYPE)?;
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
DBItemError::new( DBItemError::new(
ATTR_DEVICE_TYPE.to_string(), ATTR_DEVICE_TYPE.to_string(),
raw_device_type.into(), raw_device_type.into(),
DBItemAttributeError::InvalidValue, DBItemAttributeError::InvalidValue,
) )
})?; })?;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines fn from(value: IdentityKeyInfo) -> Self {
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload = attrs.take_attr(ATTR_KEY_PAYLOAD)?;
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; let key_payload_signature = attrs.take_attr(ATTR_KEY_PAYLOAD_SIGNATURE)?;
let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
.remove(ATTR_SOCIAL_PROOF) .remove(ATTR_SOCIAL_PROOF)
.map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned()) .map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned())
.transpose()?; .transpose()?;
Ok(Self { Ok(Self {
key_payload, key_payload,
Show All 14 Lines fn from(value: PreKey) -> Self {
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key = attrs.take_attr(ATTR_PREKEY)?;
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; let pre_key_signature = attrs.take_attr(ATTR_PREKEY_SIGNATURE)?;
let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE),
)?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<AttributeMap> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned()) .and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok()) .and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis()) .filter(|val| *val == timestamp.timestamp_millis())
.is_some(); .is_some();
if !timestamps_match { if !timestamps_match {
warn!( warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})", "DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id, &user_id,
timestamp.to_rfc3339() timestamp.to_rfc3339()
); );
} }
// this should be a list of strings let device_ids: Vec<String> = attrs.take_attr(ATTR_DEVICE_IDS)?;
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None.into(),
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines let raw_datetime =
user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME); user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME);
// existing records will not have this field when // existing records will not have this field when
// updating device list for the first time // updating device list for the first time
if raw_datetime.is_none() { if raw_datetime.is_none() {
return Ok(None); return Ok(None);
} }
let timestamp = parse_date_time_attribute( let timestamp = DateTime::<Utc>::try_from_attr(
USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
raw_datetime, raw_datetime,
)?; )?;
Ok(Some(timestamp)) Ok(Some(timestamp))
} }
/// Generates update expression for current device list timestamp in users table. /// Generates update expression for current device list timestamp in users table.
/// The previous timestamp is used as a condition to ensure that the value hasn't changed /// The previous timestamp is used as a condition to ensure that the value hasn't changed
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines
View Options

keyserver/addons/rust-node-addon/src/identity_client/mod.rs

use std::collections::HashMap; use std::collections::HashMap;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use comm_lib::{ use comm_lib::{
aws::ddb::{ aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
}, },
database::{AttributeMap, DBItemAttributeError, DBItemError, DynamoDBError}, database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
DynamoDBError, TryFromAttribute,
},
}; };
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{DeviceListError, Error, FromAttributeValue}, error::{DeviceListError, Error, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::DatabaseClient;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines AttributeValue::S(format!(
value.0.to_rfc3339() value.0.to_rfc3339()
)) ))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute { impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp // remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX) .strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
Show All 11 Lines fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<AttributeMap> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type: String = attrs.take_attr(ATTR_DEVICE_TYPE)?;
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
DBItemError::new( DBItemError::new(
ATTR_DEVICE_TYPE.to_string(), ATTR_DEVICE_TYPE.to_string(),
raw_device_type.into(), raw_device_type.into(),
DBItemAttributeError::InvalidValue, DBItemAttributeError::InvalidValue,
) )
})?; })?;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines fn from(value: IdentityKeyInfo) -> Self {
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload = attrs.take_attr(ATTR_KEY_PAYLOAD)?;
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; let key_payload_signature = attrs.take_attr(ATTR_KEY_PAYLOAD_SIGNATURE)?;
let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
.remove(ATTR_SOCIAL_PROOF) .remove(ATTR_SOCIAL_PROOF)
.map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned()) .map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned())
.transpose()?; .transpose()?;
Ok(Self { Ok(Self {
key_payload, key_payload,
Show All 14 Lines fn from(value: PreKey) -> Self {
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key = attrs.take_attr(ATTR_PREKEY)?;
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; let pre_key_signature = attrs.take_attr(ATTR_PREKEY_SIGNATURE)?;
let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE),
)?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<AttributeMap> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned()) .and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok()) .and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis()) .filter(|val| *val == timestamp.timestamp_millis())
.is_some(); .is_some();
if !timestamps_match { if !timestamps_match {
warn!( warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})", "DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id, &user_id,
timestamp.to_rfc3339() timestamp.to_rfc3339()
); );
} }
// this should be a list of strings let device_ids: Vec<String> = attrs.take_attr(ATTR_DEVICE_IDS)?;
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None.into(),
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines let raw_datetime =
user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME); user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME);
// existing records will not have this field when // existing records will not have this field when
// updating device list for the first time // updating device list for the first time
if raw_datetime.is_none() { if raw_datetime.is_none() {
return Ok(None); return Ok(None);
} }
let timestamp = parse_date_time_attribute( let timestamp = DateTime::<Utc>::try_from_attr(
USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
raw_datetime, raw_datetime,
)?; )?;
Ok(Some(timestamp)) Ok(Some(timestamp))
} }
/// Generates update expression for current device list timestamp in users table. /// Generates update expression for current device list timestamp in users table.
/// The previous timestamp is used as a condition to ensure that the value hasn't changed /// The previous timestamp is used as a condition to ensure that the value hasn't changed
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines
View Options

lib/types/identity-service-types.js

use std::collections::HashMap; use std::collections::HashMap;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use comm_lib::{ use comm_lib::{
aws::ddb::{ aws::ddb::{
operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder}, operation::{get_item::GetItemOutput, query::builders::QueryFluentBuilder},
types::{ types::{
error::TransactionCanceledException, AttributeValue, DeleteRequest, Put, error::TransactionCanceledException, AttributeValue, DeleteRequest, Put,
TransactWriteItem, Update, WriteRequest, TransactWriteItem, Update, WriteRequest,
}, },
}, },
database::{AttributeMap, DBItemAttributeError, DBItemError, DynamoDBError}, database::{
AttributeExtractor, AttributeMap, DBItemAttributeError, DBItemError,
DynamoDBError, TryFromAttribute,
},
}; };
use tracing::{error, warn}; use tracing::{error, warn};
use crate::{ use crate::{
client_service::FlattenedDeviceKeyUpload, client_service::FlattenedDeviceKeyUpload,
constants::{ constants::{
devices_table::{self, *}, devices_table::{self, *},
USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
USERS_TABLE_PARTITION_KEY, USERS_TABLE_PARTITION_KEY,
}, },
database::parse_string_attribute,
ddb_utils::AttributesOptionExt, ddb_utils::AttributesOptionExt,
error::{DeviceListError, Error, FromAttributeValue}, error::{DeviceListError, Error, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
use super::{parse_date_time_attribute, DatabaseClient}; use super::DatabaseClient;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct DeviceRow { pub struct DeviceRow {
pub user_id: String, pub user_id: String,
pub device_id: String, pub device_id: String,
pub device_type: DeviceType, pub device_type: DeviceType,
pub device_key_info: IdentityKeyInfo, pub device_key_info: IdentityKeyInfo,
pub content_prekey: PreKey, pub content_prekey: PreKey,
▲ Show 20 Lines • Show All 76 Lines • ▼ Show 20 Lines AttributeValue::S(format!(
value.0.to_rfc3339() value.0.to_rfc3339()
)) ))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute { impl TryFrom<Option<AttributeValue>> for DeviceIDAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device- prefix // remove the device- prefix
let device_id = item_id let device_id = item_id
.strip_prefix(DEVICE_ITEM_KEY_PREFIX) .strip_prefix(DEVICE_ITEM_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
})? })?
.to_string(); .to_string();
Ok(Self(device_id)) Ok(Self(device_id))
} }
} }
impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute { impl TryFrom<Option<AttributeValue>> for DeviceListKeyAttribute {
type Error = DBItemError; type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> { fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?; let item_id = String::try_from_attr(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp // remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX) .strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError { .ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(), attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: item_id.clone().into(), attribute_value: item_id.clone().into(),
attribute_error: DBItemAttributeError::InvalidValue, attribute_error: DBItemAttributeError::InvalidValue,
Show All 11 Lines fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
Ok(Self(timestamp)) Ok(Self(timestamp))
} }
} }
impl TryFrom<AttributeMap> for DeviceRow { impl TryFrom<AttributeMap> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?; let DeviceIDAttribute(device_id) = attrs.remove(ATTR_ITEM_ID).try_into()?;
let raw_device_type = let raw_device_type: String = attrs.take_attr(ATTR_DEVICE_TYPE)?;
parse_string_attribute(ATTR_DEVICE_TYPE, attrs.remove(ATTR_DEVICE_TYPE))?;
let device_type = let device_type =
DeviceType::from_str_name(&raw_device_type).ok_or_else(|| { DeviceType::from_str_name(&raw_device_type).ok_or_else(|| {
DBItemError::new( DBItemError::new(
ATTR_DEVICE_TYPE.to_string(), ATTR_DEVICE_TYPE.to_string(),
raw_device_type.into(), raw_device_type.into(),
DBItemAttributeError::InvalidValue, DBItemAttributeError::InvalidValue,
) )
})?; })?;
▲ Show 20 Lines • Show All 72 Lines • ▼ Show 20 Lines fn from(value: IdentityKeyInfo) -> Self {
} }
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for IdentityKeyInfo { impl TryFrom<AttributeMap> for IdentityKeyInfo {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let key_payload = let key_payload = attrs.take_attr(ATTR_KEY_PAYLOAD)?;
parse_string_attribute(ATTR_KEY_PAYLOAD, attrs.remove(ATTR_KEY_PAYLOAD))?; let key_payload_signature = attrs.take_attr(ATTR_KEY_PAYLOAD_SIGNATURE)?;
let key_payload_signature = parse_string_attribute(
ATTR_KEY_PAYLOAD_SIGNATURE,
attrs.remove(ATTR_KEY_PAYLOAD_SIGNATURE),
)?;
// social proof is optional // social proof is optional
let social_proof = attrs let social_proof = attrs
.remove(ATTR_SOCIAL_PROOF) .remove(ATTR_SOCIAL_PROOF)
.map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned()) .map(|attr| attr.to_string(ATTR_SOCIAL_PROOF).cloned())
.transpose()?; .transpose()?;
Ok(Self { Ok(Self {
key_payload, key_payload,
Show All 14 Lines fn from(value: PreKey) -> Self {
]); ]);
AttributeValue::M(attrs) AttributeValue::M(attrs)
} }
} }
impl TryFrom<AttributeMap> for PreKey { impl TryFrom<AttributeMap> for PreKey {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let pre_key = let pre_key = attrs.take_attr(ATTR_PREKEY)?;
parse_string_attribute(ATTR_PREKEY, attrs.remove(ATTR_PREKEY))?; let pre_key_signature = attrs.take_attr(ATTR_PREKEY_SIGNATURE)?;
let pre_key_signature = parse_string_attribute(
ATTR_PREKEY_SIGNATURE,
attrs.remove(ATTR_PREKEY_SIGNATURE),
)?;
Ok(Self { Ok(Self {
pre_key, pre_key,
pre_key_signature, pre_key_signature,
}) })
} }
} }
impl TryFrom<AttributeMap> for DeviceListRow { impl TryFrom<AttributeMap> for DeviceListRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> { fn try_from(mut attrs: AttributeMap) -> Result<Self, Self::Error> {
let user_id = let user_id = attrs.take_attr(ATTR_USER_ID)?;
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) = let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?; attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync // validate timestamps are in sync
let timestamps_match = attrs let timestamps_match = attrs
.remove(ATTR_TIMESTAMP) .remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned()) .and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok()) .and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis()) .filter(|val| *val == timestamp.timestamp_millis())
.is_some(); .is_some();
if !timestamps_match { if !timestamps_match {
warn!( warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})", "DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id, &user_id,
timestamp.to_rfc3339() timestamp.to_rfc3339()
); );
} }
// this should be a list of strings let device_ids: Vec<String> = attrs.take_attr(ATTR_DEVICE_IDS)?;
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None.into(),
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self { Ok(Self {
user_id, user_id,
timestamp, timestamp,
device_ids, device_ids,
}) })
} }
} }
▲ Show 20 Lines • Show All 362 Lines • ▼ Show 20 Lines let raw_datetime =
user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME); user_item.remove(USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME);
// existing records will not have this field when // existing records will not have this field when
// updating device list for the first time // updating device list for the first time
if raw_datetime.is_none() { if raw_datetime.is_none() {
return Ok(None); return Ok(None);
} }
let timestamp = parse_date_time_attribute( let timestamp = DateTime::<Utc>::try_from_attr(
USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME, USERS_TABLE_DEVICELIST_TIMESTAMP_ATTRIBUTE_NAME,
raw_datetime, raw_datetime,
)?; )?;
Ok(Some(timestamp)) Ok(Some(timestamp))
} }
/// Generates update expression for current device list timestamp in users table. /// Generates update expression for current device list timestamp in users table.
/// The previous timestamp is used as a condition to ensure that the value hasn't changed /// The previous timestamp is used as a condition to ensure that the value hasn't changed
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines