Paths

Table of Contentst

-
lib/shared/dm-ops/
-
shared/
-
dm-ops/
-
dm-op-utils.js
-
process-dm-ops.js

[lib] add option to mark `DMOperationSpecification` as `sendOnly`
ClosedPublic
Actions

Authored by kamil on Aug 27 2024, 12:23 PM.

Details

Reviewers

tomek
inka

Commits

rCOMM062159e457ce: [lib] add option to mark `DMOperationSpecification` as `sendOnly`

Summary

ENG-8568

There are ops like ADD_VIEWER_TO_THREAD_MEMBERS that are only meant to be sent to other peers, and should never be processed on client which is generating this operation.

Depends on D13181

Test Plan

Tested later in the stack

Diff Detail

Repository

rCOMM Comm

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

kamil created this revision.Aug 27 2024, 12:23 PM

kamil held this revision as a draft.

Herald added a subscriber: ashoat. · View Herald TranscriptAug 27 2024, 12:23 PM

Harbormaster completed remote builds in B31310: Diff 43717.Aug 27 2024, 12:41 PM

kamil published this revision for review.Aug 28 2024, 5:35 AM

tomek accepted this revision.Aug 28 2024, 5:41 AM

This revision is now accepted and ready to land.Aug 28 2024, 5:41 AM

Closed by commit rCOMM062159e457ce: [lib] add option to mark `DMOperationSpecification` as `sendOnly` (authored by kamil). · Explain WhyAug 28 2024, 6:28 AM

This revision was automatically updated to reflect the committed changes.

kamil added a commit: rCOMM062159e457ce: [lib] add option to mark `DMOperationSpecification` as `sendOnly`.

kamil added a child revision: D13197: [lib] implement adding thread members for DMs.Aug 28 2024, 8:37 AM

Revision Contents
Changeset List

Path

Size

lib/

shared/

dm-ops/

dm-op-utils.js

1 line

process-dm-ops.js

47 lines

Diff 43741

View Options

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

Show All 13 Lines
}		}

jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {		jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID);		identityGenerateNonce(currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
};		};
if (!error.empty()) {		if (!error.empty()) {
this->jsInvoker_->invokeAsync(		this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); });		[error, promise]() { promise->reject(error); });
}		}
Show All 25 Lines	jsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);		auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);		auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityRegisterUser(		identityRegisterUser(
usernameRust,		usernameRust,
passwordRust,		passwordRust,
keyPayloadRust,		keyPayloadRust,
keyPayloadSignatureRust,		keyPayloadSignatureRust,
contentPrekeyRust,		contentPrekeyRust,
contentPrekeySignatureRust,		contentPrekeySignatureRust,
notifPrekeyRust,		notifPrekeyRust,
Show All 36 Lines	jsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);		auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);		auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser(		identityLoginPasswordUser(
usernameRust,		usernameRust,
passwordRust,		passwordRust,
keyPayloadRust,		keyPayloadRust,
keyPayloadSignatureRust,		keyPayloadSignatureRust,
contentPrekeyRust,		contentPrekeyRust,
contentPrekeySignatureRust,		contentPrekeySignatureRust,
notifPrekeyRust,		notifPrekeyRust,
Show All 38 Lines	jsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);		auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt);		auto socialProofRust = jsiStringToRustString(socialProof, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityLoginWalletUser(		identityLoginWalletUser(
siweMessageRust,		siweMessageRust,
siweSignatureRust,		siweSignatureRust,
keyPayloadRust,		keyPayloadRust,
keyPayloadSignatureRust,		keyPayloadSignatureRust,
contentPrekeyRust,		contentPrekeyRust,
contentPrekeySignatureRust,		contentPrekeySignatureRust,
notifPrekeyRust,		notifPrekeyRust,
Show All 23 Lines	jsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt);		auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt);		auto passwordRust = jsiStringToRustString(password, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword(		identityUpdateUserPassword(
userIDRust,		userIDRust,
deviceIDRust,		deviceIDRust,
accessTokenRust,		accessTokenRust,
passwordRust,		passwordRust,
currentID);		currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
Show All 14 Lines	jsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt);		auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt);		auto accessTokenRust = jsiStringToRustString(accessToken, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityDeleteUser(		identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID);		userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
};		};
if (!error.empty()) {		if (!error.empty()) {
this->jsInvoker_->invokeAsync(		this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); });		[error, promise]() { promise->reject(error); });
Show All 12 Lines	jsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);		auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt);		auto userIDRust = jsiStringToRustString(userID, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser(		identityGetOutboundKeysForUser(
authUserIDRust,		authUserIDRust,
authDeviceIDRust,		authDeviceIDRust,
authAccessTokenRust,		authAccessTokenRust,
userIDRust,		userIDRust,
currentID);		currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
Show All 16 Lines	jsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);		auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt);		auto userIDRust = jsiStringToRustString(userID, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser(		identityGetInboundKeysForUser(
authUserIDRust,		authUserIDRust,
authDeviceIDRust,		authDeviceIDRust,
authAccessTokenRust,		authAccessTokenRust,
userIDRust,		userIDRust,
currentID);		currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
};		};
if (!error.empty()) {		if (!error.empty()) {
this->jsInvoker_->invokeAsync(		this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); });		[error, promise]() { promise->reject(error); });
}		}
});		});
}		}

jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {		jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID);		identityVersionSupported(currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
};		};
if (!error.empty()) {		if (!error.empty()) {
this->jsInvoker_->invokeAsync(		this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); });		[error, promise]() { promise->reject(error); });
}		}
Show All 15 Lines	jsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust =		auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt);		jsiStringArrayToRustVec(notifOneTimePreKeys, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys(		identityUploadOneTimeKeys(
authUserIDRust,		authUserIDRust,
authDeviceIDRust,		authDeviceIDRust,
authAccessTokenRust,		authAccessTokenRust,
contentOneTimePreKeysRust,		contentOneTimePreKeysRust,
notifOneTimePreKeysRust,		notifOneTimePreKeysRust,
currentID);		currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
Show All 17 Lines	jsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);		auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);		auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);

return createPromiseAsJSIValue(		return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {		rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error;		std::string error;
try {		try {
auto currentID = RustPromiseManager::instance.addPromise(		auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt);		{promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys(		identityGetKeyserverKeys(
authUserIDRust,		authUserIDRust,
authDeviceIDRust,		authDeviceIDRust,
authAccessTokenRust,		authAccessTokenRust,
keyserverIDRust,		keyserverIDRust,
currentID);		currentID);
} catch (const std::exception &e) {		} catch (const std::exception &e) {
error = e.what();		error = e.what();
Show All 9 Lines