Page MenuHomePhabricator
Differential D13132

Implement ChangeThreadSubscriptionSpec and add ThreadSubscription to createThickRawThreadInfo
ClosedPublic
Actions

Authored by marcin on Aug 21 2024, 9:47 AM.
Tags
None
Referenced Files
F6231688: D13132.id43796.diff
Thu, Apr 24, 10:25 AM
Unknown Object (File)
Sun, Apr 13, 10:05 AM
Unknown Object (File)
Sun, Apr 6, 8:31 AM
Unknown Object (File)
Mar 18 2025, 2:10 PM
Unknown Object (File)
Feb 28 2025, 7:49 PM
Unknown Object (File)
Feb 28 2025, 7:49 PM
Unknown Object (File)
Feb 17 2025, 3:34 PM
Unknown Object (File)
Feb 6 2025, 9:07 AM
View All 62 Files
Subscribers
ashoat

Details

Reviewers
tomek
kamil
Commits
rCOMM7cf8d0f3e544: Implement ChangeThreadSubscriptionSpec and add ThreadSubscription to…
Summary

This differential implements DMOperation and necessary spec for changing thread subscription. Additionally createThickRawThreadInfo is modified to accept information about subscription. This way users will get to now other members subscriptions when they are added or join the thread.

Test Plan
  1. Apply this patch: https://gist.github.com/marcinwasowicz/e0e48311f76df2acbacd0ac59e888a9c
  2. Send message from one web user to another.
  3. Ensure that both have new thread in redux and the sender has non-default subscription.

Diff Detail

Repository
rCOMM Comm
Branch
marcin/eng-8506
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

marcin created this revision.Aug 21 2024, 9:47 AM
Herald added a subscriber: ashoat. · View Herald TranscriptAug 21 2024, 9:47 AM
Harbormaster completed remote builds in B31198: Diff 43552.Aug 21 2024, 10:19 AM
marcin requested review of this revision.Aug 21 2024, 10:19 AM
tomek accepted this revision.Aug 28 2024, 6:24 AM
tomek added inline comments.
lib/shared/dm-ops/change-thread-subscription.js
67–73

This is tricky because it is possible we haven't yet received an update about the viewer joining this thread, but the update should be processed later and is valid. We shouldn't throw it away. Added a comment to the relevant issue https://linear.app/comm/issue/ENG-9000/create-validators-and-their-conversion-functions#comment-fc572ece.

For now, I guess we can keep it as is.

lib/shared/dm-ops/create-thread-spec.js
107
lib/types/dm-ops.js
55
This revision is now accepted and ready to land.Aug 28 2024, 6:24 AM
marcin updated this revision to Diff 43796.Aug 29 2024, 3:31 AM
  1. Addres review
  2. Rebase before landing
marcin added inline comments.Aug 29 2024, 3:32 AM
lib/shared/dm-ops/dm-op-utils.js
176–179 ↗(On Diff #43796)

The fact that I had to do this suggests that ThreadSubscription should be passed from` ThickRawThreadInfo` to ThreadInfo.

This revision was landed with ongoing or failed builds.Aug 29 2024, 3:41 AM
Closed by commit rCOMM7cf8d0f3e544: Implement ChangeThreadSubscriptionSpec and add ThreadSubscription to… (authored by Marcin Wąsowicz <marcinwasowicz@MacBook-Pro-Marcin.local>). · Explain Why
This revision was automatically updated to reflect the committed changes.
Marcin Wąsowicz <marcinwasowicz@MacBook-Pro-Marcin.local> added a commit: rCOMM7cf8d0f3e544: Implement ChangeThreadSubscriptionSpec and add ThreadSubscription to….
Harbormaster completed remote builds in B31365: Diff 43796.Aug 29 2024, 3:47 AM

Revision Contents
Changeset List

Diff 43552

View Options

lib/shared/dm-ops/add-viewer-to-thread-members-spec.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
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 = parse_string_attribute(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: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
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 {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(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()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

lib/shared/dm-ops/change-thread-subscription.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
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 = parse_string_attribute(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: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
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 {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(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()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

lib/shared/dm-ops/create-sidebar-spec.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
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 = parse_string_attribute(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: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
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 {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(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()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

lib/shared/dm-ops/create-thread-spec.js

// TODO: get rid of this // TODO: get rid of this
#![allow(dead_code)] #![allow(dead_code)]
use std::collections::HashMap; use std::collections::HashMap;
use aws_sdk_dynamodb::model::AttributeValue; use aws_sdk_dynamodb::model::AttributeValue;
use chrono::{DateTime, Utc}; use chrono::{DateTime, Utc};
use tracing::warn;
use crate::{ use crate::{
constants::devices_table::*, constants::devices_table::*,
database::parse_string_attribute, database::parse_string_attribute,
error::{DBItemAttributeError, DBItemError, FromAttributeValue}, error::{DBItemAttributeError, DBItemError, FromAttributeValue},
grpc_services::protos::unauth::DeviceType, grpc_services::protos::unauth::DeviceType,
}; };
Show All 34 Lines
struct DeviceListKeyAttribute(DateTime<Utc>); struct DeviceListKeyAttribute(DateTime<Utc>);
impl From<DeviceIDAttribute> for AttributeValue { impl From<DeviceIDAttribute> for AttributeValue {
fn from(value: DeviceIDAttribute) -> Self { fn from(value: DeviceIDAttribute) -> Self {
AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0)) AttributeValue::S(format!("{DEVICE_ITEM_KEY_PREFIX}{}", value.0))
} }
} }
impl From<DeviceListKeyAttribute> for AttributeValue {
fn from(value: DeviceListKeyAttribute) -> Self {
AttributeValue::S(format!(
"{DEVICE_LIST_KEY_PREFIX}{}",
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 = parse_string_attribute(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: Some(AttributeValue::S(item_id.clone())), attribute_value: Some(AttributeValue::S(item_id.clone())),
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 {
type Error = DBItemError;
fn try_from(value: Option<AttributeValue>) -> Result<Self, Self::Error> {
let item_id = parse_string_attribute(ATTR_ITEM_ID, value)?;
// remove the device-list- prefix, then parse the timestamp
let timestamp: DateTime<Utc> = item_id
.strip_prefix(DEVICE_LIST_KEY_PREFIX)
.ok_or_else(|| DBItemError {
attribute_name: ATTR_ITEM_ID.to_string(),
attribute_value: Some(AttributeValue::S(item_id.clone())),
attribute_error: DBItemAttributeError::InvalidValue,
})
.and_then(|s| {
s.parse().map_err(|e| {
DBItemError::new(
ATTR_ITEM_ID.to_string(),
Some(AttributeValue::S(item_id.clone())),
DBItemAttributeError::InvalidTimestamp(e),
)
})
})?;
Ok(Self(timestamp))
}
}
impl TryFrom<RawAttributes> for DeviceRow { impl TryFrom<RawAttributes> for DeviceRow {
type Error = DBItemError; type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> { fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id = let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(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()?;
▲ Show 20 Lines • Show All 95 Lines • ▼ Show 20 Lines if let Some(social_proof) = value.social_proof {
ATTR_SOCIAL_PROOF.to_string(), ATTR_SOCIAL_PROOF.to_string(),
AttributeValue::S(social_proof), AttributeValue::S(social_proof),
); );
} }
attrs attrs
} }
} }
impl TryFrom<RawAttributes> for DeviceListRow {
type Error = DBItemError;
fn try_from(mut attrs: RawAttributes) -> Result<Self, Self::Error> {
let user_id =
parse_string_attribute(ATTR_USER_ID, attrs.remove(ATTR_USER_ID))?;
let DeviceListKeyAttribute(timestamp) =
attrs.remove(ATTR_ITEM_ID).try_into()?;
// validate timestamps are in sync
let timestamps_match = attrs
.remove(ATTR_TIMESTAMP)
.and_then(|attr| attr.as_n().ok().cloned())
.and_then(|val| val.parse::<i64>().ok())
.filter(|val| *val == timestamp.timestamp_millis())
.is_some();
if !timestamps_match {
warn!(
"DeviceList timestamp mismatch for (userID={}, itemID={})",
&user_id,
timestamp.to_rfc3339()
);
}
// this should be a list of strings
let device_ids = attrs
.remove(ATTR_DEVICE_IDS)
.ok_or_else(|| {
DBItemError::new(
ATTR_DEVICE_IDS.to_string(),
None,
DBItemAttributeError::Missing,
)
})?
.to_vec(ATTR_DEVICE_IDS)?
.iter()
.map(|v| v.to_string("device_ids[?]").cloned())
.collect::<Result<Vec<String>, DBItemError>>()?;
Ok(Self {
user_id,
timestamp,
device_ids,
})
}
}
impl From<DeviceListRow> for RawAttributes {
fn from(device_list: DeviceListRow) -> Self {
let mut attrs = HashMap::new();
attrs.insert(
ATTR_USER_ID.to_string(),
AttributeValue::S(device_list.user_id.clone()),
);
attrs.insert(
ATTR_ITEM_ID.to_string(),
DeviceListKeyAttribute(device_list.timestamp).into(),
);
attrs.insert(
ATTR_TIMESTAMP.to_string(),
AttributeValue::N(device_list.timestamp.timestamp_millis().to_string()),
);
bartekAuthorUnsubmitted
Done
Inline Actions

Note that we use RFC 3339 string for ItemID while the ATTR_TIMESTAMP uses milliseconds number. Generally I use the former everywhere (simpler parsing without NaiveDateTime conversions) but I thought the latter is easier for DDB to sort by (it's used only as index sorting key and not read anywhere else)

bartek: Note that we use RFC 3339 string for `ItemID` while the `ATTR_TIMESTAMP` uses milliseconds…
attrs.insert(
ATTR_DEVICE_IDS.to_string(),
AttributeValue::L(
device_list
.device_ids
.into_iter()
.map(AttributeValue::S)
.collect(),
),
);
attrs
}
}
View Options

lib/shared/dm-ops/dm-op-specs.js

Loading...
View Options

lib/shared/dm-ops/join-thread-spec.js

Loading...
View Options

lib/types/dm-ops.js

Loading...