Page MenuHomePhabricator
Differential D13897

[sqlite] Add getInboundP2PMessagesByID query
ClosedPublic
Actions

Authored by angelika on Nov 8 2024, 7:51 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 24, 12:16 PM
Unknown Object (File)
Thu, Apr 24, 5:18 AM
Unknown Object (File)
Wed, Apr 23, 9:03 AM
Unknown Object (File)
Mon, Mar 31, 10:29 PM
Unknown Object (File)
Mar 15 2025, 2:13 AM
Unknown Object (File)
Mar 15 2025, 2:13 AM
Unknown Object (File)
Mar 15 2025, 2:13 AM
Unknown Object (File)
Feb 12 2025, 7:50 PM
View All 33 Files
Subscribers
ashoat

Details

Reviewers
tomek
kamil
Commits
rCOMM224d94fb7a6e: [sqlite] Add getInboundP2PMessagesByID query
Summary

https://linear.app/comm/issue/ENG-9713/mitigate-risk-of-olm-already-decrypted-or-keys-skipped

Test Plan

Test plan in the last diff in stack.

Diff Detail

Repository
rCOMM Comm
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

angelika created this revision.Nov 8 2024, 7:51 AM
Herald added a subscriber: ashoat. · View Herald TranscriptNov 8 2024, 7:51 AM
angelika added a child revision: D13898: [web] Implement getInboundP2PMessagesByID query on worker.Nov 8 2024, 7:52 AM
Harbormaster completed remote builds in B32592: Diff 45721.Nov 8 2024, 8:14 AM
angelika requested review of this revision.Nov 8 2024, 8:14 AM
kamil accepted this revision.Nov 12 2024, 2:42 AM
kamil added inline comments.
native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
2752
2753–2754

nit: match indentation with other queries here

This revision is now accepted and ready to land.Nov 12 2024, 2:42 AM
angelika updated this revision to Diff 45735.Nov 12 2024, 4:50 AM

Formatting

kamil added inline comments.Nov 12 2024, 5:03 AM
native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
2753–2757 ↗(On Diff #45735)

it needs to be 2-spaces to match other queries

Harbormaster failed remote builds in B32601: Diff 45735!Nov 12 2024, 5:06 AM
angelika updated this revision to Diff 45740.Nov 12 2024, 5:44 AM

Run emscripten

Harbormaster completed remote builds in B32606: Diff 45740.Nov 12 2024, 6:10 AM
Closed by commit rCOMM224d94fb7a6e: [sqlite] Add getInboundP2PMessagesByID query (authored by angelika). · Explain WhyNov 13 2024, 4:17 AM
This revision was automatically updated to reflect the committed changes.
angelika added a commit: rCOMM224d94fb7a6e: [sqlite] Add getInboundP2PMessagesByID query.
ashoat added inline comments.Nov 13 2024, 5:49 AM
native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
2753–2757 ↗(On Diff #45735)

Kamil's feedback here was not addressed

angelika mentioned this in D13922: [sqlite] Add missing spaces in getInboundP2PMessagesByID query.Nov 13 2024, 6:15 AM
angelika mentioned this in rCOMMadd745dbaf17: [sqlite] Add missing spaces in getInboundP2PMessagesByID query.Nov 13 2024, 11:22 AM

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
DatabaseManagers/
2 lines
2 lines
19 lines
web/
cpp/
3 lines
shared-worker/
_generated/
queries/
6 lines
types/
3 lines

Diff 45721

View Options

native/cpp/CommonCpp/DatabaseManagers/DatabaseQueryExecutor.h

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/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.h

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/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp

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

web/cpp/SQLiteQueryExecutorBindings.cpp

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

web/shared-worker/_generated/comm_query_executor.wasm

Loading...
View Options

web/shared-worker/queries/inbound-p2p-message-queries.test.js

Loading...
View Options

web/shared-worker/types/sqlite-query-executor.js

Loading...