Page MenuHomePhabricator
Differential D11607

[keyserver] Update `createPersonalThreads` to support both `[Traditional/Farcaster]RelationshipRequest`
ClosedPublic
Actions

Authored by atul on Apr 9 2024, 9:17 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Mar 10, 8:50 AM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
Unknown Object (File)
Sat, Mar 8, 2:15 PM
View All 96 Files
Subscribers
ashoat

Details

Reviewers
ginsu
varun
tomek
will
Commits
rCOMMef12de0da55f: [keyserver] Update `createPersonalThreads` to support both `…
Summary

Now that we may get userIDsToFID instead of userIDs, we need to transform back to list of userIDs via Object.keys to maintain existing behavior.

Depends on D11606

Test Plan
  1. Set breakpoints and add log statements to ensure that userIDs gets constructed as expected for both traditional and farcaster relationship requests.
  2. Check keyserverDB to ensure that threads are created as expected

(need to go through again before landing)

Diff Detail

Repository
rCOMM Comm
Branch
arcpatch-D11607_1 (branched from master)
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

atul created this revision.Apr 9 2024, 9:17 PM
Herald added a subscriber: ashoat. · View Herald TranscriptApr 9 2024, 9:17 PM
atul updated this revision to Diff 38966.Apr 9 2024, 9:21 PM

fix import

Harbormaster failed remote builds in B28108: Diff 38964!Apr 9 2024, 9:33 PM
Harbormaster completed remote builds in B28110: Diff 38966.Apr 9 2024, 9:38 PM
atul requested review of this revision.Apr 9 2024, 9:38 PM
atul added a child revision: D11609: [lib] Narrow `TraditionalRelationshipRequest` to exclude 'farcaster' action.Apr 9 2024, 9:41 PM
tomek accepted this revision.Apr 10 2024, 6:47 AM
tomek added inline comments.
keyserver/src/updaters/relationship-updaters.js
337–339 ↗(On Diff #38966)

How about checking the type property?

This revision is now accepted and ready to land.Apr 10 2024, 6:47 AM
atul added inline comments.Apr 10 2024, 12:18 PM
keyserver/src/updaters/relationship-updaters.js
337–339 ↗(On Diff #38966)

Tried this initially, but flow wasn't able to figure out that FARCASTER_MUTUAL requests have userIDsToFID and the rest have userIDs

3cf86a.png (1×2 px, 656 KB)

atul updated this revision to Diff 39005.Apr 10 2024, 12:18 PM

rebasing stack

atul attached a referenced file: F1510994: 3cf86a.png. (Show Details)Apr 10 2024, 12:18 PM
Harbormaster completed remote builds in B28137: Diff 39005.Apr 10 2024, 12:34 PM
atul added a comment.Apr 17 2024, 12:04 PM

This diff is safe to land as is as it broadens what arguments createPersonalThreads can accept and TraditionalRelationshipRequests will continue to work as expected.

atul updated this revision to Diff 39194.Apr 17 2024, 12:08 PM

rebase and land

This revision was landed with ongoing or failed builds.Apr 17 2024, 12:10 PM
Closed by commit rCOMMef12de0da55f: [keyserver] Update `createPersonalThreads` to support both `… (authored by atul). · Explain Why
This revision was automatically updated to reflect the committed changes.
atul added a commit: rCOMMef12de0da55f: [keyserver] Update `createPersonalThreads` to support both `….
Harbormaster completed remote builds in B28273: Diff 39194.Apr 17 2024, 12:32 PM

Revision Contents
Changeset List

PathSize
keyserver/
src/
updaters/
11 lines

Diff 39194

View Options

keyserver/src/updaters/relationship-updaters.js

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
#ifndef EMSCRIPTEN #ifndef EMSCRIPTEN
NativeSQLiteConnectionManager SQLiteQueryExecutor::connectionManager; NativeSQLiteConnectionManager SQLiteQueryExecutor::connectionManager;
std::unordered_set<std::string> SQLiteQueryExecutor::backedUpTablesBlocklist = { std::unordered_set<std::string> SQLiteQueryExecutor::backedUpTablesBlocklist = {
"olm_persist_account", "olm_persist_account",
"olm_persist_sessions", "olm_persist_sessions",
"metadata", "metadata",
"outbound_p2p_messages", "outbound_p2p_messages",
"received_messages_to_device", "inbound_p2p_messages",
"integrity_store", "integrity_store",
"persist_storage", "persist_storage",
"keyservers", "keyservers",
}; };
#else #else
SQLiteConnectionManager SQLiteQueryExecutor::connectionManager; SQLiteConnectionManager SQLiteQueryExecutor::connectionManager;
#endif #endif
▲ Show 20 Lines • Show All 725 Lines • ▼ Show 20 Lines std::string query =
" original_message_id UNINDEXED," " original_message_id UNINDEXED,"
" message_id UNINDEXED," " message_id UNINDEXED,"
" processed_content," " processed_content,"
" tokenize = porter" " tokenize = porter"
");"; ");";
return create_table(db, query, "message_search"); return create_table(db, query, "message_search");
} }
bool recreate_inbound_p2p_messages_table(sqlite3 *db) {
std::string query =
"DROP TABLE IF EXISTS received_messages_to_device;"
"CREATE TABLE IF NOT EXISTS inbound_p2p_messages ("
" id INTEGER PRIMARY KEY,"
" message_id TEXT NOT NULL,"
" sender_device_id TEXT NOT NULL,"
" plaintext TEXT NOT NULL,"
" status TEXT NOT NULL,"
" sender_user_id TEXT NOT NULL"
");";
"CREATE INDEX IF NOT EXISTS outbound_p2p_messages_idx_id_timestamp"
" ON outbound_p2p_messages (device_id, timestamp);";
kamilAuthorUnsubmitted
Done
Inline Actions
");";
- "CREATE INDEX IF NOT EXISTS outbound_p2p_messages_idx_id_timestamp"
- " ON outbound_p2p_messages (device_id, timestamp);";
+
return create_table(db, query, "inbound_p2p_messages");
kamil:
return create_table(db, query, "inbound_p2p_messages");
}
bool create_schema(sqlite3 *db) { bool create_schema(sqlite3 *db) {
char *error; char *error;
int sidebarSourceTypeInt = static_cast<int>(MessageType::SIDEBAR_SOURCE); int sidebarSourceTypeInt = static_cast<int>(MessageType::SIDEBAR_SOURCE);
std::string sidebarSourceType = std::to_string(sidebarSourceTypeInt); std::string sidebarSourceType = std::to_string(sidebarSourceTypeInt);
auto query = auto query =
"CREATE TABLE IF NOT EXISTS drafts (" "CREATE TABLE IF NOT EXISTS drafts ("
" key TEXT UNIQUE PRIMARY KEY NOT NULL," " key TEXT UNIQUE PRIMARY KEY NOT NULL,"
" text TEXT NOT NULL" " text TEXT NOT NULL"
▲ Show 20 Lines • Show All 131 Lines • ▼ Show 20 Lines auto query =
" aux_user_info TEXT NOT NULL" " aux_user_info TEXT NOT NULL"
");" ");"
"CREATE TABLE IF NOT EXISTS thread_activity (" "CREATE TABLE IF NOT EXISTS thread_activity ("
" id TEXT UNIQUE PRIMARY KEY NOT NULL," " id TEXT UNIQUE PRIMARY KEY NOT NULL,"
" thread_activity_store_entry TEXT NOT NULL" " thread_activity_store_entry TEXT NOT NULL"
");" ");"
"CREATE TABLE IF NOT EXISTS received_messages_to_device (" "CREATE TABLE IF NOT EXISTS inbound_p2p_messages ("
" id INTEGER PRIMARY KEY," " id INTEGER PRIMARY KEY,"
" message_id TEXT NOT NULL," " message_id TEXT NOT NULL,"
" sender_device_id TEXT NOT NULL," " sender_device_id TEXT NOT NULL,"
" plaintext TEXT NOT NULL," " plaintext TEXT NOT NULL,"
" status TEXT NOT NULL" " status TEXT NOT NULL,"
" sender_user_id TEXT NOT NULL"
");" ");"
"CREATE TABLE IF NOT EXISTS entries (" "CREATE TABLE IF NOT EXISTS entries ("
" id TEXT UNIQUE PRIMARY KEY NOT NULL," " id TEXT UNIQUE PRIMARY KEY NOT NULL,"
" entry TEXT NOT NULL" " entry TEXT NOT NULL"
");" ");"
"CREATE TABLE IF NOT EXISTS message_store_local (" "CREATE TABLE IF NOT EXISTS message_store_local ("
▲ Show 20 Lines • Show All 264 Lines • ▼ Show 20 Linesstd::vector<std::pair<unsigned int, SQLiteMigration>> migrations{
{43, {create_thread_activity_table, true}}, {43, {create_thread_activity_table, true}},
{44, {create_received_messages_to_device, true}}, {44, {create_received_messages_to_device, true}},
{45, {recreate_outbound_p2p_messages_table, true}}, {45, {recreate_outbound_p2p_messages_table, true}},
{46, {create_entries_table, true}}, {46, {create_entries_table, true}},
{47, {create_message_store_local_table, true}}, {47, {create_message_store_local_table, true}},
{48, {create_messages_idx_target_message_type_time, true}}, {48, {create_messages_idx_target_message_type_time, true}},
{49, {add_supports_auto_retry_column_to_p2p_messages_table, true}}, {49, {add_supports_auto_retry_column_to_p2p_messages_table, true}},
{50, {create_message_search_table, true}}, {50, {create_message_search_table, true}},
{51, {update_messages_idx_target_message_type_time, true}}}}; {51, {update_messages_idx_target_message_type_time, true}},
{52, {recreate_inbound_p2p_messages_table, true}}}};
enum class MigrationResult { SUCCESS, FAILURE, NOT_APPLIED }; enum class MigrationResult { SUCCESS, FAILURE, NOT_APPLIED };
MigrationResult applyMigrationWithTransaction( MigrationResult applyMigrationWithTransaction(
sqlite3 *db, sqlite3 *db,
const MigrateFunction &migrate, const MigrateFunction &migrate,
int index) { int index) {
sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr); sqlite3_exec(db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
▲ Show 20 Lines • Show All 1,385 Lines • ▼ Show 20 Linesstd::vector<std::string> SQLiteQueryExecutor::resetOutboundP2PMessagesForDevice(
sqlite3_step(preparedUpdateCiphertextSQL); sqlite3_step(preparedUpdateCiphertextSQL);
return messageIDs; return messageIDs;
} }
void SQLiteQueryExecutor::addInboundP2PMessage( void SQLiteQueryExecutor::addInboundP2PMessage(
InboundP2PMessage message) const { InboundP2PMessage message) const {
static std::string addMessage = static std::string addMessage =
"REPLACE INTO received_messages_to_device (" "REPLACE INTO inbound_p2p_messages ("
" message_id, sender_device_id, plaintext, status)" " message_id, sender_device_id, plaintext, status, sender_user_id)"
"VALUES (?, ?, ?, ?);"; "VALUES (?, ?, ?, ?, ?);";
replaceEntity<InboundP2PMessage>( replaceEntity<InboundP2PMessage>(
SQLiteQueryExecutor::getConnection(), addMessage, message); SQLiteQueryExecutor::getConnection(), addMessage, message);
} }
std::vector<InboundP2PMessage> std::vector<InboundP2PMessage>
SQLiteQueryExecutor::getAllInboundP2PMessage() const { SQLiteQueryExecutor::getAllInboundP2PMessage() const {
static std::string query = static std::string query =
"SELECT message_id, sender_device_id, plaintext, status " "SELECT message_id, sender_device_id, plaintext, status, sender_user_id "
"FROM received_messages_to_device;"; "FROM inbound_p2p_messages;";
return getAllEntities<InboundP2PMessage>( return getAllEntities<InboundP2PMessage>(
SQLiteQueryExecutor::getConnection(), query); SQLiteQueryExecutor::getConnection(), query);
} }
void SQLiteQueryExecutor::removeInboundP2PMessages( void SQLiteQueryExecutor::removeInboundP2PMessages(
const std::vector<std::string> &ids) const { const std::vector<std::string> &ids) const {
if (!ids.size()) { if (!ids.size()) {
return; return;
} }
std::stringstream removeMessagesSQLStream; std::stringstream removeMessagesSQLStream;
removeMessagesSQLStream << "DELETE FROM received_messages_to_device " removeMessagesSQLStream << "DELETE FROM inbound_p2p_messages "
"WHERE message_id IN " "WHERE message_id IN "
<< getSQLStatementArray(ids.size()) << ";"; << getSQLStatementArray(ids.size()) << ";";
removeEntitiesByKeys( removeEntitiesByKeys(
SQLiteQueryExecutor::getConnection(), removeMessagesSQLStream.str(), ids); SQLiteQueryExecutor::getConnection(), removeMessagesSQLStream.str(), ids);
} }
std::vector<MessageEntity> std::vector<MessageEntity>
▲ Show 20 Lines • Show All 511 Lines • Show Last 20 Lines