Page MenuHomePhabricator
Differential D12225

[lib][p2p] Update device list upon receiving logout message
ClosedPublic
Actions

Authored by bartek on May 28 2024, 4:28 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 16, 2:09 PM
Unknown Object (File)
Wed, Apr 16, 11:37 AM
Unknown Object (File)
Wed, Apr 16, 7:55 AM
Unknown Object (File)
Wed, Apr 16, 2:43 AM
Unknown Object (File)
Mon, Apr 14, 10:52 PM
Unknown Object (File)
Sat, Apr 12, 4:22 AM
Unknown Object (File)
Sun, Mar 30, 5:43 PM
Unknown Object (File)
Mar 13 2025, 8:32 AM
View All 92 Files
Subscribers
ashoat
tomek

Details

Reviewers
kamil
Commits
rCOMMdb8a21dfe270: [lib][p2p] Update device list upon receiving logout message
Summary

Updated p2p message handler to remove device from device list upon receiving logout message

Depends on D12224

Test Plan

In addition to test plan from D12224:

  • Verified Identity Service logs to see that update_device_list is called
  • Verified that DDB contains updated device list without secondary device ID (being a sender of the message handled here)

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

bartek created this revision.May 28 2024, 4:28 AM
bartek held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptMay 28 2024, 4:28 AM
Harbormaster failed remote builds in B29261: Diff 40679!May 28 2024, 4:41 AM
bartek updated this revision to Diff 40755.May 29 2024, 9:50 AM

Clean up and rebase

bartek retitled this revision from [DRAFT] Update device list upon receiving logout message to [lib][p2p] Update device list upon receiving logout message.May 29 2024, 9:58 AM
bartek edited the test plan for this revision. (Show Details)
Harbormaster completed remote builds in B29290: Diff 40755.May 29 2024, 10:15 AM
bartek published this revision for review.May 29 2024, 10:16 AM
bartek added inline comments.
lib/handlers/peer-to-peer-message-handler.js
127 ↗(On Diff #40755)

This will be handled by ENG-7837. I don't want to copy-paste code from native/secondary-device-qr-code-scanner.js which is about to be changed as a result of tasks from the linked project

bartek added a child revision: D12267: [identity] Remove device data on device list update.Jun 2 2024, 11:50 PM
kamil accepted this revision.Jun 6 2024, 12:55 AM
This revision is now accepted and ready to land.Jun 6 2024, 12:55 AM
Closed by commit rCOMMdb8a21dfe270: [lib][p2p] Update device list upon receiving logout message (authored by bartek). · Explain WhyJun 6 2024, 1:50 AM
This revision was automatically updated to reflect the committed changes.
bartek added a commit: rCOMMdb8a21dfe270: [lib][p2p] Update device list upon receiving logout message.

Revision Contents
Changeset List

PathSize
lib/
handlers/
21 lines
shared/
56 lines
native/
profile/
2 lines
qr-code/
27 lines

Diff 40679

View Options

lib/handlers/peer-to-peer-message-handler.js

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
const minimallyEncodeRoleInfo = ( const minimallyEncodeRoleInfo = (
roleInfo: RoleInfo, roleInfo: RoleInfo,
): MinimallyEncodedRoleInfo => ({ ): MinimallyEncodedRoleInfo => ({
...roleInfo, ...roleInfo,
permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions), permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
}); });
const decodeMinimallyEncodedRoleInfo = (
minimallyEncodedRoleInfo: MinimallyEncodedRoleInfo,
): RoleInfo => ({
...minimallyEncodedRoleInfo,
permissions: decodeThreadRolePermissionsBitmaskArray(
minimallyEncodedRoleInfo.permissions,
),
});
export type MinimallyEncodedThreadCurrentUserInfo = { export type MinimallyEncodedThreadCurrentUserInfo = {
...ThreadCurrentUserInfo, ...ThreadCurrentUserInfo,
+permissions: string, +permissions: string,
}; };
const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/); const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/);
const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> = const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> =
tShape<MinimallyEncodedThreadCurrentUserInfo>({ tShape<MinimallyEncodedThreadCurrentUserInfo>({
...threadCurrentUserInfoValidator.meta.props, ...threadCurrentUserInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeThreadCurrentUserInfo = ( const minimallyEncodeThreadCurrentUserInfo = (
threadCurrentUserInfo: ThreadCurrentUserInfo, threadCurrentUserInfo: ThreadCurrentUserInfo,
): MinimallyEncodedThreadCurrentUserInfo => ({ ): MinimallyEncodedThreadCurrentUserInfo => ({
...threadCurrentUserInfo, ...threadCurrentUserInfo,
permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions), permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
}); });
const decodeMinimallyEncodedThreadCurrentUserInfo = (
minimallyEncodedThreadCurrentUserInfo: MinimallyEncodedThreadCurrentUserInfo,
): ThreadCurrentUserInfo => ({
...minimallyEncodedThreadCurrentUserInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedThreadCurrentUserInfo.permissions,
),
});
export type MinimallyEncodedMemberInfo = { export type MinimallyEncodedMemberInfo = {
...MemberInfo, ...MemberInfo,
+permissions: string, +permissions: string,
}; };
const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> = const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> =
tShape<MinimallyEncodedMemberInfo>({ tShape<MinimallyEncodedMemberInfo>({
...memberInfoValidator.meta.props, ...memberInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeMemberInfo = ( const minimallyEncodeMemberInfo = (
memberInfo: MemberInfo, memberInfo: MemberInfo,
): MinimallyEncodedMemberInfo => ({ ): MinimallyEncodedMemberInfo => ({
...memberInfo, ...memberInfo,
permissions: permissionsToBitmaskHex(memberInfo.permissions), permissions: permissionsToBitmaskHex(memberInfo.permissions),
}); });
const decodeMinimallyEncodedMemberInfo = (
minimallyEncodedMemberInfo: MinimallyEncodedMemberInfo,
): MemberInfo => ({
...minimallyEncodedMemberInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedMemberInfo.permissions,
),
});
export type MinimallyEncodedRawThreadInfo = { export type MinimallyEncodedRawThreadInfo = {
...RawThreadInfo, ...RawThreadInfo,
+members: $ReadOnlyArray<MinimallyEncodedMemberInfo>, +members: $ReadOnlyArray<MinimallyEncodedMemberInfo>,
+roles: { +[id: string]: MinimallyEncodedRoleInfo }, +roles: { +[id: string]: MinimallyEncodedRoleInfo },
+currentUser: MinimallyEncodedThreadCurrentUserInfo, +currentUser: MinimallyEncodedThreadCurrentUserInfo,
}; };
const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> = const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> =
Show All 11 Lines): MinimallyEncodedRawThreadInfo => {
return { return {
...rest, ...rest,
members: members.map(minimallyEncodeMemberInfo), members: members.map(minimallyEncodeMemberInfo),
roles: _mapValues(minimallyEncodeRoleInfo)(roles), roles: _mapValues(minimallyEncodeRoleInfo)(roles),
currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser), currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
}; };
}; };
const decodeMinimallyEncodedRawThreadInfo = (
minimallyEncodedRawThreadInfo: MinimallyEncodedRawThreadInfo,
): RawThreadInfo => {
const { members, roles, currentUser, ...rest } =
minimallyEncodedRawThreadInfo;
return {
...rest,
members: members.map(decodeMinimallyEncodedMemberInfo),
roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
};
};
export { export {
permissionsToBitmaskHex, permissionsToBitmaskHex,
threadPermissionsFromBitmaskHex, threadPermissionsFromBitmaskHex,
hasPermission, hasPermission,
rolePermissionToBitmaskHex, rolePermissionToBitmaskHex,
decodeRolePermissionBitmask, decodeRolePermissionBitmask,
threadRolePermissionsBlobToBitmaskArray, threadRolePermissionsBlobToBitmaskArray,
decodeThreadRolePermissionsBitmaskArray, decodeThreadRolePermissionsBitmaskArray,
minimallyEncodedRoleInfoValidator, minimallyEncodedRoleInfoValidator,
minimallyEncodedThreadCurrentUserInfoValidator, minimallyEncodedThreadCurrentUserInfoValidator,
minimallyEncodedMemberInfoValidator, minimallyEncodedMemberInfoValidator,
minimallyEncodedRawThreadInfoValidator, minimallyEncodedRawThreadInfoValidator,
minimallyEncodeRawThreadInfo, minimallyEncodeRawThreadInfo,
decodeMinimallyEncodedRawThreadInfo,
}; };
View Options

lib/shared/device-list-utils.js

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
const minimallyEncodeRoleInfo = ( const minimallyEncodeRoleInfo = (
roleInfo: RoleInfo, roleInfo: RoleInfo,
): MinimallyEncodedRoleInfo => ({ ): MinimallyEncodedRoleInfo => ({
...roleInfo, ...roleInfo,
permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions), permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
}); });
const decodeMinimallyEncodedRoleInfo = (
minimallyEncodedRoleInfo: MinimallyEncodedRoleInfo,
): RoleInfo => ({
...minimallyEncodedRoleInfo,
permissions: decodeThreadRolePermissionsBitmaskArray(
minimallyEncodedRoleInfo.permissions,
),
});
export type MinimallyEncodedThreadCurrentUserInfo = { export type MinimallyEncodedThreadCurrentUserInfo = {
...ThreadCurrentUserInfo, ...ThreadCurrentUserInfo,
+permissions: string, +permissions: string,
}; };
const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/); const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/);
const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> = const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> =
tShape<MinimallyEncodedThreadCurrentUserInfo>({ tShape<MinimallyEncodedThreadCurrentUserInfo>({
...threadCurrentUserInfoValidator.meta.props, ...threadCurrentUserInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeThreadCurrentUserInfo = ( const minimallyEncodeThreadCurrentUserInfo = (
threadCurrentUserInfo: ThreadCurrentUserInfo, threadCurrentUserInfo: ThreadCurrentUserInfo,
): MinimallyEncodedThreadCurrentUserInfo => ({ ): MinimallyEncodedThreadCurrentUserInfo => ({
...threadCurrentUserInfo, ...threadCurrentUserInfo,
permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions), permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
}); });
const decodeMinimallyEncodedThreadCurrentUserInfo = (
minimallyEncodedThreadCurrentUserInfo: MinimallyEncodedThreadCurrentUserInfo,
): ThreadCurrentUserInfo => ({
...minimallyEncodedThreadCurrentUserInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedThreadCurrentUserInfo.permissions,
),
});
export type MinimallyEncodedMemberInfo = { export type MinimallyEncodedMemberInfo = {
...MemberInfo, ...MemberInfo,
+permissions: string, +permissions: string,
}; };
const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> = const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> =
tShape<MinimallyEncodedMemberInfo>({ tShape<MinimallyEncodedMemberInfo>({
...memberInfoValidator.meta.props, ...memberInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeMemberInfo = ( const minimallyEncodeMemberInfo = (
memberInfo: MemberInfo, memberInfo: MemberInfo,
): MinimallyEncodedMemberInfo => ({ ): MinimallyEncodedMemberInfo => ({
...memberInfo, ...memberInfo,
permissions: permissionsToBitmaskHex(memberInfo.permissions), permissions: permissionsToBitmaskHex(memberInfo.permissions),
}); });
const decodeMinimallyEncodedMemberInfo = (
minimallyEncodedMemberInfo: MinimallyEncodedMemberInfo,
): MemberInfo => ({
...minimallyEncodedMemberInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedMemberInfo.permissions,
),
});
export type MinimallyEncodedRawThreadInfo = { export type MinimallyEncodedRawThreadInfo = {
...RawThreadInfo, ...RawThreadInfo,
+members: $ReadOnlyArray<MinimallyEncodedMemberInfo>, +members: $ReadOnlyArray<MinimallyEncodedMemberInfo>,
+roles: { +[id: string]: MinimallyEncodedRoleInfo }, +roles: { +[id: string]: MinimallyEncodedRoleInfo },
+currentUser: MinimallyEncodedThreadCurrentUserInfo, +currentUser: MinimallyEncodedThreadCurrentUserInfo,
}; };
const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> = const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> =
Show All 11 Lines): MinimallyEncodedRawThreadInfo => {
return { return {
...rest, ...rest,
members: members.map(minimallyEncodeMemberInfo), members: members.map(minimallyEncodeMemberInfo),
roles: _mapValues(minimallyEncodeRoleInfo)(roles), roles: _mapValues(minimallyEncodeRoleInfo)(roles),
currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser), currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
}; };
}; };
const decodeMinimallyEncodedRawThreadInfo = (
minimallyEncodedRawThreadInfo: MinimallyEncodedRawThreadInfo,
): RawThreadInfo => {
const { members, roles, currentUser, ...rest } =
minimallyEncodedRawThreadInfo;
return {
...rest,
members: members.map(decodeMinimallyEncodedMemberInfo),
roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
};
};
export { export {
permissionsToBitmaskHex, permissionsToBitmaskHex,
threadPermissionsFromBitmaskHex, threadPermissionsFromBitmaskHex,
hasPermission, hasPermission,
rolePermissionToBitmaskHex, rolePermissionToBitmaskHex,
decodeRolePermissionBitmask, decodeRolePermissionBitmask,
threadRolePermissionsBlobToBitmaskArray, threadRolePermissionsBlobToBitmaskArray,
decodeThreadRolePermissionsBitmaskArray, decodeThreadRolePermissionsBitmaskArray,
minimallyEncodedRoleInfoValidator, minimallyEncodedRoleInfoValidator,
minimallyEncodedThreadCurrentUserInfoValidator, minimallyEncodedThreadCurrentUserInfoValidator,
minimallyEncodedMemberInfoValidator, minimallyEncodedMemberInfoValidator,
minimallyEncodedRawThreadInfoValidator, minimallyEncodedRawThreadInfoValidator,
minimallyEncodeRawThreadInfo, minimallyEncodeRawThreadInfo,
decodeMinimallyEncodedRawThreadInfo,
}; };
View Options

native/profile/secondary-device-qr-code-scanner.react.js

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
const minimallyEncodeRoleInfo = ( const minimallyEncodeRoleInfo = (
roleInfo: RoleInfo, roleInfo: RoleInfo,
): MinimallyEncodedRoleInfo => ({ ): MinimallyEncodedRoleInfo => ({
...roleInfo, ...roleInfo,
permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions), permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
}); });
const decodeMinimallyEncodedRoleInfo = (
minimallyEncodedRoleInfo: MinimallyEncodedRoleInfo,
): RoleInfo => ({
...minimallyEncodedRoleInfo,
permissions: decodeThreadRolePermissionsBitmaskArray(
minimallyEncodedRoleInfo.permissions,
),
});
export type MinimallyEncodedThreadCurrentUserInfo = { export type MinimallyEncodedThreadCurrentUserInfo = {
...ThreadCurrentUserInfo, ...ThreadCurrentUserInfo,
+permissions: string, +permissions: string,
}; };
const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/); const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/);
const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> = const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> =
tShape<MinimallyEncodedThreadCurrentUserInfo>({ tShape<MinimallyEncodedThreadCurrentUserInfo>({
...threadCurrentUserInfoValidator.meta.props, ...threadCurrentUserInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeThreadCurrentUserInfo = ( const minimallyEncodeThreadCurrentUserInfo = (
threadCurrentUserInfo: ThreadCurrentUserInfo, threadCurrentUserInfo: ThreadCurrentUserInfo,
): MinimallyEncodedThreadCurrentUserInfo => ({ ): MinimallyEncodedThreadCurrentUserInfo => ({
...threadCurrentUserInfo, ...threadCurrentUserInfo,
permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions), permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
}); });
const decodeMinimallyEncodedThreadCurrentUserInfo = (
minimallyEncodedThreadCurrentUserInfo: MinimallyEncodedThreadCurrentUserInfo,
): ThreadCurrentUserInfo => ({
...minimallyEncodedThreadCurrentUserInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedThreadCurrentUserInfo.permissions,
),
});
export type MinimallyEncodedMemberInfo = { export type MinimallyEncodedMemberInfo = {
...MemberInfo, ...MemberInfo,
+permissions: string, +permissions: string,
}; };
const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> = const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> =
tShape<MinimallyEncodedMemberInfo>({ tShape<MinimallyEncodedMemberInfo>({
...memberInfoValidator.meta.props, ...memberInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeMemberInfo = ( const minimallyEncodeMemberInfo = (
memberInfo: MemberInfo, memberInfo: MemberInfo,
): MinimallyEncodedMemberInfo => ({ ): MinimallyEncodedMemberInfo => ({
...memberInfo, ...memberInfo,
permissions: permissionsToBitmaskHex(memberInfo.permissions), permissions: permissionsToBitmaskHex(memberInfo.permissions),
}); });
const decodeMinimallyEncodedMemberInfo = (
minimallyEncodedMemberInfo: MinimallyEncodedMemberInfo,
): MemberInfo => ({
...minimallyEncodedMemberInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedMemberInfo.permissions,
),
});
export type MinimallyEncodedRawThreadInfo = { export type MinimallyEncodedRawThreadInfo = {
...RawThreadInfo, ...RawThreadInfo,
+members: $ReadOnlyArray<MinimallyEncodedMemberInfo>, +members: $ReadOnlyArray<MinimallyEncodedMemberInfo>,
+roles: { +[id: string]: MinimallyEncodedRoleInfo }, +roles: { +[id: string]: MinimallyEncodedRoleInfo },
+currentUser: MinimallyEncodedThreadCurrentUserInfo, +currentUser: MinimallyEncodedThreadCurrentUserInfo,
}; };
const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> = const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> =
Show All 11 Lines): MinimallyEncodedRawThreadInfo => {
return { return {
...rest, ...rest,
members: members.map(minimallyEncodeMemberInfo), members: members.map(minimallyEncodeMemberInfo),
roles: _mapValues(minimallyEncodeRoleInfo)(roles), roles: _mapValues(minimallyEncodeRoleInfo)(roles),
currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser), currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
}; };
}; };
const decodeMinimallyEncodedRawThreadInfo = (
minimallyEncodedRawThreadInfo: MinimallyEncodedRawThreadInfo,
): RawThreadInfo => {
const { members, roles, currentUser, ...rest } =
minimallyEncodedRawThreadInfo;
return {
...rest,
members: members.map(decodeMinimallyEncodedMemberInfo),
roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
};
};
export { export {
permissionsToBitmaskHex, permissionsToBitmaskHex,
threadPermissionsFromBitmaskHex, threadPermissionsFromBitmaskHex,
hasPermission, hasPermission,
rolePermissionToBitmaskHex, rolePermissionToBitmaskHex,
decodeRolePermissionBitmask, decodeRolePermissionBitmask,
threadRolePermissionsBlobToBitmaskArray, threadRolePermissionsBlobToBitmaskArray,
decodeThreadRolePermissionsBitmaskArray, decodeThreadRolePermissionsBitmaskArray,
minimallyEncodedRoleInfoValidator, minimallyEncodedRoleInfoValidator,
minimallyEncodedThreadCurrentUserInfoValidator, minimallyEncodedThreadCurrentUserInfoValidator,
minimallyEncodedMemberInfoValidator, minimallyEncodedMemberInfoValidator,
minimallyEncodedRawThreadInfoValidator, minimallyEncodedRawThreadInfoValidator,
minimallyEncodeRawThreadInfo, minimallyEncodeRawThreadInfo,
decodeMinimallyEncodedRawThreadInfo,
}; };
View Options

native/qr-code/qr-code-utils.js

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Lines
const minimallyEncodeRoleInfo = ( const minimallyEncodeRoleInfo = (
roleInfo: RoleInfo, roleInfo: RoleInfo,
): MinimallyEncodedRoleInfo => ({ ): MinimallyEncodedRoleInfo => ({
...roleInfo, ...roleInfo,
permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions), permissions: threadRolePermissionsBlobToBitmaskArray(roleInfo.permissions),
}); });
const decodeMinimallyEncodedRoleInfo = (
minimallyEncodedRoleInfo: MinimallyEncodedRoleInfo,
): RoleInfo => ({
...minimallyEncodedRoleInfo,
permissions: decodeThreadRolePermissionsBitmaskArray(
minimallyEncodedRoleInfo.permissions,
),
});
export type MinimallyEncodedThreadCurrentUserInfo = { export type MinimallyEncodedThreadCurrentUserInfo = {
...ThreadCurrentUserInfo, ...ThreadCurrentUserInfo,
+permissions: string, +permissions: string,
}; };
const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/); const tHexEncodedPermissionsBitmask: TRegex = tRegex(/^[0-9a-fA-F]+$/);
const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> = const minimallyEncodedThreadCurrentUserInfoValidator: TInterface<MinimallyEncodedThreadCurrentUserInfo> =
tShape<MinimallyEncodedThreadCurrentUserInfo>({ tShape<MinimallyEncodedThreadCurrentUserInfo>({
...threadCurrentUserInfoValidator.meta.props, ...threadCurrentUserInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeThreadCurrentUserInfo = ( const minimallyEncodeThreadCurrentUserInfo = (
threadCurrentUserInfo: ThreadCurrentUserInfo, threadCurrentUserInfo: ThreadCurrentUserInfo,
): MinimallyEncodedThreadCurrentUserInfo => ({ ): MinimallyEncodedThreadCurrentUserInfo => ({
...threadCurrentUserInfo, ...threadCurrentUserInfo,
permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions), permissions: permissionsToBitmaskHex(threadCurrentUserInfo.permissions),
}); });
const decodeMinimallyEncodedThreadCurrentUserInfo = (
minimallyEncodedThreadCurrentUserInfo: MinimallyEncodedThreadCurrentUserInfo,
): ThreadCurrentUserInfo => ({
...minimallyEncodedThreadCurrentUserInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedThreadCurrentUserInfo.permissions,
),
});
export type MinimallyEncodedMemberInfo = { export type MinimallyEncodedMemberInfo = {
...MemberInfo, ...MemberInfo,
+permissions: string, +permissions: string,
}; };
const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> = const minimallyEncodedMemberInfoValidator: TInterface<MinimallyEncodedMemberInfo> =
tShape<MinimallyEncodedMemberInfo>({ tShape<MinimallyEncodedMemberInfo>({
...memberInfoValidator.meta.props, ...memberInfoValidator.meta.props,
permissions: tHexEncodedPermissionsBitmask, permissions: tHexEncodedPermissionsBitmask,
}); });
const minimallyEncodeMemberInfo = ( const minimallyEncodeMemberInfo = (
memberInfo: MemberInfo, memberInfo: MemberInfo,
): MinimallyEncodedMemberInfo => ({ ): MinimallyEncodedMemberInfo => ({
...memberInfo, ...memberInfo,
permissions: permissionsToBitmaskHex(memberInfo.permissions), permissions: permissionsToBitmaskHex(memberInfo.permissions),
}); });
const decodeMinimallyEncodedMemberInfo = (
minimallyEncodedMemberInfo: MinimallyEncodedMemberInfo,
): MemberInfo => ({
...minimallyEncodedMemberInfo,
permissions: threadPermissionsFromBitmaskHex(
minimallyEncodedMemberInfo.permissions,
),
});
export type MinimallyEncodedRawThreadInfo = { export type MinimallyEncodedRawThreadInfo = {
...RawThreadInfo, ...RawThreadInfo,
+members: $ReadOnlyArray<MinimallyEncodedMemberInfo>, +members: $ReadOnlyArray<MinimallyEncodedMemberInfo>,
+roles: { +[id: string]: MinimallyEncodedRoleInfo }, +roles: { +[id: string]: MinimallyEncodedRoleInfo },
+currentUser: MinimallyEncodedThreadCurrentUserInfo, +currentUser: MinimallyEncodedThreadCurrentUserInfo,
}; };
const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> = const minimallyEncodedRawThreadInfoValidator: TInterface<MinimallyEncodedRawThreadInfo> =
Show All 11 Lines): MinimallyEncodedRawThreadInfo => {
return { return {
...rest, ...rest,
members: members.map(minimallyEncodeMemberInfo), members: members.map(minimallyEncodeMemberInfo),
roles: _mapValues(minimallyEncodeRoleInfo)(roles), roles: _mapValues(minimallyEncodeRoleInfo)(roles),
currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser), currentUser: minimallyEncodeThreadCurrentUserInfo(currentUser),
}; };
}; };
const decodeMinimallyEncodedRawThreadInfo = (
minimallyEncodedRawThreadInfo: MinimallyEncodedRawThreadInfo,
): RawThreadInfo => {
const { members, roles, currentUser, ...rest } =
minimallyEncodedRawThreadInfo;
return {
...rest,
members: members.map(decodeMinimallyEncodedMemberInfo),
roles: _mapValues(decodeMinimallyEncodedRoleInfo)(roles),
currentUser: decodeMinimallyEncodedThreadCurrentUserInfo(currentUser),
};
};
export { export {
permissionsToBitmaskHex, permissionsToBitmaskHex,
threadPermissionsFromBitmaskHex, threadPermissionsFromBitmaskHex,
hasPermission, hasPermission,
rolePermissionToBitmaskHex, rolePermissionToBitmaskHex,
decodeRolePermissionBitmask, decodeRolePermissionBitmask,
threadRolePermissionsBlobToBitmaskArray, threadRolePermissionsBlobToBitmaskArray,
decodeThreadRolePermissionsBitmaskArray, decodeThreadRolePermissionsBitmaskArray,
minimallyEncodedRoleInfoValidator, minimallyEncodedRoleInfoValidator,
minimallyEncodedThreadCurrentUserInfoValidator, minimallyEncodedThreadCurrentUserInfoValidator,
minimallyEncodedMemberInfoValidator, minimallyEncodedMemberInfoValidator,
minimallyEncodedRawThreadInfoValidator, minimallyEncodedRawThreadInfoValidator,
minimallyEncodeRawThreadInfo, minimallyEncodeRawThreadInfo,
decodeMinimallyEncodedRawThreadInfo,
}; };