Page MenuHomePhabricator
Differential D9904

[SQLite] add methods to operate on users table
ClosedPublic
Actions

Authored by kamil on Nov 15 2023, 12:28 PM.
Tags
None
Referenced Files
Unknown Object (File)
Mon, Apr 7, 5:04 AM
Unknown Object (File)
Sat, Mar 22, 12:25 AM
Unknown Object (File)
Mon, Mar 17, 8:07 PM
Unknown Object (File)
Mon, Mar 17, 8:06 PM
Unknown Object (File)
Mon, Mar 17, 8:00 PM
Unknown Object (File)
Feb 13 2025, 9:13 PM
Unknown Object (File)
Feb 13 2025, 9:12 PM
Unknown Object (File)
Feb 13 2025, 9:05 PM
View All 69 Files
Subscribers
ashoat

Details

Reviewers
tomek
Commits
rCOMM5c36d95c18ad: [SQLite] add methods to operate on users table
Summary
  1. Representation of data row.
  2. Methods to modify table.
  3. Emscripten bindings

Depends on D9903

Test Plan

Tests in D9909

Diff Detail

Repository
rCOMM Comm
Branch
land-user-store
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

kamil created this revision.Nov 15 2023, 12:28 PM
kamil held this revision as a draft.
Herald added a subscriber: ashoat. · View Herald TranscriptNov 15 2023, 12:28 PM
Harbormaster completed remote builds in B24182: Diff 33300.Nov 15 2023, 3:52 PM
kamil updated this revision to Diff 33324.Nov 16 2023, 6:13 AM

refactor

kamil added a child revision: D9909: [SQLite] add functions to convert user data and tests to user store methods.Nov 16 2023, 6:16 AM
Harbormaster completed remote builds in B24199: Diff 33324.Nov 16 2023, 6:44 AM
kamil published this revision for review.Nov 16 2023, 7:06 AM
kamil added inline comments.
lib/ops/user-store-ops.js
30 ↗(On Diff #33324)

as described in D9903, implementing key-value table

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h
66–69 ↗(On Diff #33324)

JS spec is here: D9796

kamil edited the summary of this revision. (Show Details)Nov 16 2023, 7:06 AM
kamil edited the test plan for this revision. (Show Details)
tomek accepted this revision.Nov 17 2023, 7:12 AM
tomek added inline comments.
lib/ops/user-store-ops.js
30 ↗(On Diff #33324)

Can we modify this type in a diff that introduces it?

web/cpp/SQLiteQueryExecutorBindings.cpp
19 ↗(On Diff #33324)

Why is it WebUserInfo instead of just UserInfo

This revision is now accepted and ready to land.Nov 17 2023, 7:12 AM
kamil updated this revision to Diff 33403.Nov 20 2023, 3:34 AM

WebUserInfo -> UserInfo

lib/ops/user-store-ops.js
30 ↗(On Diff #33324)

this diff is already landed: D9796

web/cpp/SQLiteQueryExecutorBindings.cpp
19 ↗(On Diff #33324)

leftover from testing, thanks for catching

Harbormaster completed remote builds in B24265: Diff 33403.Nov 20 2023, 3:53 AM
Closed by commit rCOMM5c36d95c18ad: [SQLite] add methods to operate on users table (authored by kamil). · Explain WhyNov 20 2023, 5:48 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMM5c36d95c18ad: [SQLite] add methods to operate on users table.

Revision Contents
Changeset List

PathSize
lib/
ops/
4 lines
native/
cpp/
CommonCpp/
DatabaseManagers/
5 lines
5 lines
25 lines
entities/
12 lines
web/
cpp/
9 lines
database/
_generated/
types/
6 lines

Diff 33403

View Options

lib/ops/user-store-ops.js

Show First 20 Lines • Show All 951 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
promise->resolve(std::move(jsiRandomString)); promise->resolve(std::move(jsiRandomString));
} }
}); });
}; };
this->cryptoThread->scheduleTask(job); this->cryptoThread->scheduleTask(job);
}); });
} }
jsi::Value CommCoreModule::setCommServicesAuthMetadata(
jsi::Runtime &rt,
jsi::String userID,
jsi::String deviceID,
jsi::String accessToken) {
auto userIDStr{userID.utf8(rt)};
auto deviceIDStr{deviceID.utf8(rt)};
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, userIDStr, deviceIDStr, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job =
[this, promise, userIDStr, deviceIDStr, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(this->secureStore.userID, userIDStr);
this->secureStore.set(this->secureStore.deviceID, deviceIDStr);
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::getCommServicesAuthMetadata(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, &innerRt, promise]() {
std::string error;
std::string userID;
std::string deviceID;
std::string accessToken;
try {
folly::Optional<std::string> userIDOpt =
this->secureStore.get(this->secureStore.userID);
if (userIDOpt.hasValue()) {
userID = userIDOpt.value();
}
folly::Optional<std::string> deviceIDOpt =
this->secureStore.get(this->secureStore.deviceID);
if (deviceIDOpt.hasValue()) {
deviceID = deviceIDOpt.value();
}
folly::Optional<std::string> accessTokenOpt = this->secureStore.get(
this->secureStore.commServicesAccessToken);
if (accessTokenOpt.hasValue()) {
accessToken = accessTokenOpt.value();
}
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync(
[&innerRt, error, userID, deviceID, accessToken, promise]() {
if (error.size()) {
promise->reject(error);
} else {
auto authMetadata = jsi::Object(innerRt);
if (!userID.empty()) {
authMetadata.setProperty(
innerRt,
"userID",
jsi::String::createFromUtf8(innerRt, userID));
}
if (!deviceID.empty()) {
authMetadata.setProperty(
innerRt,
"deviceID",
jsi::String::createFromUtf8(innerRt, deviceID));
}
if (!accessToken.empty()) {
authMetadata.setProperty(
innerRt,
"accessToken",
jsi::String::createFromUtf8(innerRt, accessToken));
}
promise->resolve(std::move(authMetadata));
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::setCommServicesAccessToken(
jsi::Runtime &rt,
jsi::String accessToken) {
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, "");
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h

Show First 20 Lines • Show All 951 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
promise->resolve(std::move(jsiRandomString)); promise->resolve(std::move(jsiRandomString));
} }
}); });
}; };
this->cryptoThread->scheduleTask(job); this->cryptoThread->scheduleTask(job);
}); });
} }
jsi::Value CommCoreModule::setCommServicesAuthMetadata(
jsi::Runtime &rt,
jsi::String userID,
jsi::String deviceID,
jsi::String accessToken) {
auto userIDStr{userID.utf8(rt)};
auto deviceIDStr{deviceID.utf8(rt)};
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, userIDStr, deviceIDStr, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job =
[this, promise, userIDStr, deviceIDStr, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(this->secureStore.userID, userIDStr);
this->secureStore.set(this->secureStore.deviceID, deviceIDStr);
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::getCommServicesAuthMetadata(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, &innerRt, promise]() {
std::string error;
std::string userID;
std::string deviceID;
std::string accessToken;
try {
folly::Optional<std::string> userIDOpt =
this->secureStore.get(this->secureStore.userID);
if (userIDOpt.hasValue()) {
userID = userIDOpt.value();
}
folly::Optional<std::string> deviceIDOpt =
this->secureStore.get(this->secureStore.deviceID);
if (deviceIDOpt.hasValue()) {
deviceID = deviceIDOpt.value();
}
folly::Optional<std::string> accessTokenOpt = this->secureStore.get(
this->secureStore.commServicesAccessToken);
if (accessTokenOpt.hasValue()) {
accessToken = accessTokenOpt.value();
}
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync(
[&innerRt, error, userID, deviceID, accessToken, promise]() {
if (error.size()) {
promise->reject(error);
} else {
auto authMetadata = jsi::Object(innerRt);
if (!userID.empty()) {
authMetadata.setProperty(
innerRt,
"userID",
jsi::String::createFromUtf8(innerRt, userID));
}
if (!deviceID.empty()) {
authMetadata.setProperty(
innerRt,
"deviceID",
jsi::String::createFromUtf8(innerRt, deviceID));
}
if (!accessToken.empty()) {
authMetadata.setProperty(
innerRt,
"accessToken",
jsi::String::createFromUtf8(innerRt, accessToken));
}
promise->resolve(std::move(authMetadata));
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::setCommServicesAccessToken(
jsi::Runtime &rt,
jsi::String accessToken) {
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, "");
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h

Show First 20 Lines • Show All 951 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
promise->resolve(std::move(jsiRandomString)); promise->resolve(std::move(jsiRandomString));
} }
}); });
}; };
this->cryptoThread->scheduleTask(job); this->cryptoThread->scheduleTask(job);
}); });
} }
jsi::Value CommCoreModule::setCommServicesAuthMetadata(
jsi::Runtime &rt,
jsi::String userID,
jsi::String deviceID,
jsi::String accessToken) {
auto userIDStr{userID.utf8(rt)};
auto deviceIDStr{deviceID.utf8(rt)};
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, userIDStr, deviceIDStr, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job =
[this, promise, userIDStr, deviceIDStr, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(this->secureStore.userID, userIDStr);
this->secureStore.set(this->secureStore.deviceID, deviceIDStr);
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::getCommServicesAuthMetadata(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, &innerRt, promise]() {
std::string error;
std::string userID;
std::string deviceID;
std::string accessToken;
try {
folly::Optional<std::string> userIDOpt =
this->secureStore.get(this->secureStore.userID);
if (userIDOpt.hasValue()) {
userID = userIDOpt.value();
}
folly::Optional<std::string> deviceIDOpt =
this->secureStore.get(this->secureStore.deviceID);
if (deviceIDOpt.hasValue()) {
deviceID = deviceIDOpt.value();
}
folly::Optional<std::string> accessTokenOpt = this->secureStore.get(
this->secureStore.commServicesAccessToken);
if (accessTokenOpt.hasValue()) {
accessToken = accessTokenOpt.value();
}
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync(
[&innerRt, error, userID, deviceID, accessToken, promise]() {
if (error.size()) {
promise->reject(error);
} else {
auto authMetadata = jsi::Object(innerRt);
if (!userID.empty()) {
authMetadata.setProperty(
innerRt,
"userID",
jsi::String::createFromUtf8(innerRt, userID));
}
if (!deviceID.empty()) {
authMetadata.setProperty(
innerRt,
"deviceID",
jsi::String::createFromUtf8(innerRt, deviceID));
}
if (!accessToken.empty()) {
authMetadata.setProperty(
innerRt,
"accessToken",
jsi::String::createFromUtf8(innerRt, accessToken));
}
promise->resolve(std::move(authMetadata));
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::setCommServicesAccessToken(
jsi::Runtime &rt,
jsi::String accessToken) {
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, "");
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp

Show First 20 Lines • Show All 951 Lines • ▼ Show 20 Lines return createPromiseAsJSIValue(
promise->resolve(std::move(jsiRandomString)); promise->resolve(std::move(jsiRandomString));
} }
}); });
}; };
this->cryptoThread->scheduleTask(job); this->cryptoThread->scheduleTask(job);
}); });
} }
jsi::Value CommCoreModule::setCommServicesAuthMetadata(
jsi::Runtime &rt,
jsi::String userID,
jsi::String deviceID,
jsi::String accessToken) {
auto userIDStr{userID.utf8(rt)};
auto deviceIDStr{deviceID.utf8(rt)};
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, userIDStr, deviceIDStr, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job =
[this, promise, userIDStr, deviceIDStr, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(this->secureStore.userID, userIDStr);
this->secureStore.set(this->secureStore.deviceID, deviceIDStr);
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::getCommServicesAuthMetadata(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, &innerRt, promise]() {
std::string error;
std::string userID;
std::string deviceID;
std::string accessToken;
try {
folly::Optional<std::string> userIDOpt =
this->secureStore.get(this->secureStore.userID);
if (userIDOpt.hasValue()) {
userID = userIDOpt.value();
}
folly::Optional<std::string> deviceIDOpt =
this->secureStore.get(this->secureStore.deviceID);
if (deviceIDOpt.hasValue()) {
deviceID = deviceIDOpt.value();
}
folly::Optional<std::string> accessTokenOpt = this->secureStore.get(
this->secureStore.commServicesAccessToken);
if (accessTokenOpt.hasValue()) {
accessToken = accessTokenOpt.value();
}
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync(
[&innerRt, error, userID, deviceID, accessToken, promise]() {
if (error.size()) {
promise->reject(error);
} else {
auto authMetadata = jsi::Object(innerRt);
if (!userID.empty()) {
authMetadata.setProperty(
innerRt,
"userID",
jsi::String::createFromUtf8(innerRt, userID));
}
if (!deviceID.empty()) {
authMetadata.setProperty(
innerRt,
"deviceID",
jsi::String::createFromUtf8(innerRt, deviceID));
}
if (!accessToken.empty()) {
authMetadata.setProperty(
innerRt,
"accessToken",
jsi::String::createFromUtf8(innerRt, accessToken));
}
promise->resolve(std::move(authMetadata));
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::setCommServicesAccessToken(
jsi::Runtime &rt,
jsi::String accessToken) {
auto accessTokenStr{accessToken.utf8(rt)};
return createPromiseAsJSIValue(
rt,
[this, accessTokenStr](
jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise, accessTokenStr]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, accessTokenStr);
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
jsi::Value CommCoreModule::clearCommServicesAccessToken(jsi::Runtime &rt) {
return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
taskType job = [this, promise]() {
std::string error;
try {
this->secureStore.set(
this->secureStore.commServicesAccessToken, "");
} catch (const std::exception &e) {
error = e.what();
}
this->jsInvoker_->invokeAsync([error, promise]() {
if (error.size()) {
promise->reject(error);
} else {
promise->resolve(jsi::Value::undefined());
}
});
};
GlobalDBSingleton::instance.scheduleOrRunCancellable(
job, promise, this->jsInvoker_);
});
}
} // namespace comm } // namespace comm
View Options

native/cpp/CommonCpp/DatabaseManagers/entities/UserInfo.h

Loading...
View Options

web/cpp/SQLiteQueryExecutorBindings.cpp

Loading...
View Options

web/database/_generated/comm-query-executor.js

Loading...
View Options

web/database/_generated/comm_query_executor.wasm

Loading...
View Options

web/database/types/sqlite-query-executor.js

Loading...