Page MenuHomePhabricator
Differential D10776

[SQLite] implement C++ keyserver store ops
ClosedPublic
Actions

Authored by kamil on Jan 22 2024, 4:32 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 17, 3:38 PM
Unknown Object (File)
Thu, Apr 17, 12:57 PM
Unknown Object (File)
Thu, Apr 17, 6:30 AM
Unknown Object (File)
Wed, Apr 16, 9:41 PM
Unknown Object (File)
Wed, Apr 16, 9:11 PM
Unknown Object (File)
Wed, Apr 16, 8:15 AM
Unknown Object (File)
Fri, Apr 11, 1:19 AM
Unknown Object (File)
Mar 9 2025, 4:45 PM
View All Files
Subscribers
ashoat
tomek
will

Details

Reviewers
inka
will
Commits
rCOMM09c232731144: [SQLite] implement C++ keyserver store ops
Summary

Code for native ops

Depends on D10775

Test Plan

Call this code:

await commCoreModule.processKeyserverStoreOperations([
    {
      type: 'replace_keyserver',
      payload: {
        id: '1',
        keyserverInfo: 'fdfd',
      },
    },
    {
      type: 'replace_keyserver',
      payload: {
        id: '2',
        keyserverInfo: 'fdfd',
      },
    },
  ]);

  await commCoreModule.processKeyserverStoreOperations([
    {
      type: 'replace_keyserver',
      payload: {
        id: '2',
        keyserverInfo: 'fdfd45454545',
      },
    },
  ]);

  await commCoreModule.processKeyserverStoreOperations([
    {
      type: 'remove_keyserver',
      payload: {
        id: '1',
      },
    },
  ]);

  await commCoreModule.processKeyserverStoreOperations([
    {
      type: 'remove_all_keyservers',
    },
  ]);

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Event Timeline

kamil created this revision.Jan 22 2024, 4:32 AM
kamil held this revision as a draft.
Herald added subscribers: tomek, ashoat. · View Herald TranscriptJan 22 2024, 4:32 AM
Harbormaster completed remote builds in B26018: Diff 35952.Jan 22 2024, 4:57 AM
kamil added a child revision: D10780: [SQLite] implement C++ code to get keyservers.Jan 22 2024, 5:29 AM
kamil published this revision for review.Jan 22 2024, 6:39 AM
ashoat added a reviewer: will.Jan 22 2024, 9:38 PM
ashoat added a subscriber: will.

Might be good for @will to review this stack in preparation for his projects next month

will accepted this revision.Jan 24 2024, 9:25 AM

Looks good to me

This revision is now accepted and ready to land.Jan 24 2024, 9:25 AM
kamil updated this revision to Diff 36219.Jan 27 2024, 10:22 AM

update to allow removing array of keyservers

kamil added inline comments.Jan 27 2024, 10:24 AM
native/cpp/CommonCpp/DatabaseManagers/SQLiteQueryExecutor.cpp
1340 ↗(On Diff #36219)

this formatting is a rebase issue

Harbormaster completed remote builds in B26226: Diff 36219.Jan 27 2024, 10:41 AM
kamil updated this revision to Diff 36244.Jan 29 2024, 3:16 AM

rebase

Harbormaster completed remote builds in B26242: Diff 36244.Jan 29 2024, 3:35 AM
Closed by commit rCOMM09c232731144: [SQLite] implement C++ keyserver store ops (authored by kamil). · Explain WhyJan 29 2024, 3:49 AM
This revision was automatically updated to reflect the committed changes.
kamil added a commit: rCOMM09c232731144: [SQLite] implement C++ keyserver store ops.
kamil mentioned this in D11152: [sqlite] implement C++ community store ops.Feb 23 2024, 6:25 AM

Revision Contents
Changeset List

PathSize
native/
cpp/
CommonCpp/
NativeModules/
3 lines
5 lines
9 lines
48 lines
PersistentStorageUtilities/
DataStores/
30 lines
67 lines
_generated/
ios/
Comm.xcodeproj/
8 lines
schema/
4 lines

Diff 36255

View Options

native/cpp/CommonCpp/NativeModules/CMakeLists.txt

Show All 40 Lines
import type { import type {
ResolvedNotifTexts, ResolvedNotifTexts,
NotificationTargetDevice, NotificationTargetDevice,
TargetedNotificationWithPlatform, TargetedNotificationWithPlatform,
SenderDeviceDescriptor, SenderDeviceDescriptor,
EncryptedNotifUtilsAPI, EncryptedNotifUtilsAPI,
} from '../types/notif-types.js'; } from '../types/notif-types.js';
import type { ThreadSubscription } from '../types/subscription-types.js'; import type { ThreadSubscription } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { ThickRawThreadInfos } from '../types/thread-types.js';
import type { UserInfos } from '../types/user-types.js'; import type { UserInfos } from '../types/user-types.js';
import { type GetENSNames } from '../utils/ens-helpers.js'; import { type GetENSNames } from '../utils/ens-helpers.js';
import { type GetFCNames } from '../utils/farcaster-helpers.js'; import { type GetFCNames } from '../utils/farcaster-helpers.js';
import { promiseAll } from '../utils/promises.js'; import { promiseAll } from '../utils/promises.js';
export type Device = { export type Device = {
+platformDetails: PlatformDetails, +platformDetails: PlatformDetails,
+deliveryID: string, +deliveryID: string,
Show All 23 Lines): PlatformDetails {
return { return {
...rest, ...rest,
platform: identityDeviceTypeToPlatform[deviceType], platform: identityDeviceTypeToPlatform[deviceType],
}; };
} }
async function getPushUserInfo( async function getPushUserInfo(
messageInfos: { +[id: string]: RawMessageInfo }, messageInfos: { +[id: string]: RawMessageInfo },
rawThreadInfos: RawThreadInfos, thickRawThreadInfos: ThickRawThreadInfos,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
messageDatas: $ReadOnlyArray<MessageData>, messageDatas: $ReadOnlyArray<MessageData>,
): Promise<{ ): Promise<{
+pushInfos: ?PushInfo, +pushInfos: ?PushInfo,
+rescindInfos: ?PushInfo, +rescindInfos: ?PushInfo,
}> { }> {
if (messageDatas.length === 0) { if (messageDatas.length === 0) {
return { pushInfos: null, rescindInfos: null }; return { pushInfos: null, rescindInfos: null };
Show All 29 Lines [userID: string]: {
devices: $ReadOnlyArray<Device>, devices: $ReadOnlyArray<Device>,
threadsWithSubscriptions: { threadsWithSubscriptions: {
[threadID: string]: ThreadSubscriptionWithRole, [threadID: string]: ThreadSubscriptionWithRole,
}, },
}, },
} = {}; } = {};
for (const threadID of threadsToMessageIndices.keys()) { for (const threadID of threadsToMessageIndices.keys()) {
const threadInfo = rawThreadInfos[threadID]; const threadInfo = thickRawThreadInfos[threadID];
for (const memberInfo of threadInfo.members) { for (const memberInfo of threadInfo.members) {
if ( if (
!isMemberActive(memberInfo) || !isMemberActive(memberInfo) ||
!hasPermission(memberInfo.permissions, 'visible') || !hasPermission(memberInfo.permissions, 'visible')
!memberInfo.subscription
) { ) {
continue; continue;
} }
if (pushUserThreadInfos[memberInfo.id]) { if (pushUserThreadInfos[memberInfo.id]) {
pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] = pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
{ ...memberInfo.subscription, role: memberInfo.role }; { ...memberInfo.subscription, role: memberInfo.role };
continue; continue;
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
export type PerUserTargetedNotifications = { export type PerUserTargetedNotifications = {
+[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>, +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
}; };
type BuildNotifsFromPushInfoInputData = { type BuildNotifsFromPushInfoInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+pushInfo: PushInfo, +pushInfo: PushInfo,
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function buildNotifsFromPushInfo( async function buildNotifsFromPushInfo(
inputData: BuildNotifsFromPushInfoInputData, inputData: BuildNotifsFromPushInfoInputData,
): Promise<PerUserTargetedNotifications> { ): Promise<PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo, pushInfo,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const threadIDs = new Set<string>(); const threadIDs = new Set<string>();
for (const userID in pushInfo) { for (const userID in pushInfo) {
for (const rawMessageInfo of pushInfo[userID].messageInfos) { for (const rawMessageInfo of pushInfo[userID].messageInfos) {
Show All 13 Lines const perUserBuildNotifsResultPromises: {
[userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>, [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
} = {}; } = {};
for (const userID in pushInfo) { for (const userID in pushInfo) {
const threadInfos = Object.fromEntries( const threadInfos = Object.fromEntries(
[...threadIDs].map(threadID => [ [...threadIDs].map(threadID => [
threadID, threadID,
threadInfoFromRawThreadInfo( threadInfoFromRawThreadInfo(
rawThreadInfos[threadID], thickRawThreadInfos[threadID],
userID, userID,
userInfos, userInfos,
), ),
]), ]),
); );
const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices); const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
const singleNotificationPromises = []; const singleNotificationPromises = [];
Show All 27 Lines): Promise<PerUserTargetedNotifications> {
return promiseAll(perUserBuildNotifsResultPromises); return promiseAll(perUserBuildNotifsResultPromises);
} }
type PreparePushNotifsInputData = { type PreparePushNotifsInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+messageInfos: { +[id: string]: RawMessageInfo }, +messageInfos: { +[id: string]: RawMessageInfo },
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+auxUserInfos: AuxUserInfos, +auxUserInfos: AuxUserInfos,
+messageDatas: $ReadOnlyArray<MessageData>, +messageDatas: $ReadOnlyArray<MessageData>,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function preparePushNotifs( async function preparePushNotifs(
inputData: PreparePushNotifsInputData, inputData: PreparePushNotifsInputData,
): Promise<?PerUserTargetedNotifications> { ): Promise<?PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
messageDatas, messageDatas,
messageInfos, messageInfos,
auxUserInfos, auxUserInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const { pushInfos } = await getPushUserInfo( const { pushInfos } = await getPushUserInfo(
messageInfos, messageInfos,
rawThreadInfos, thickRawThreadInfos,
auxUserInfos, auxUserInfos,
messageDatas, messageDatas,
); );
if (!pushInfos) { if (!pushInfos) {
return null; return null;
} }
return await buildNotifsFromPushInfo({ return await buildNotifsFromPushInfo({
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo: pushInfos, pushInfo: pushInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
}); });
} }
export { preparePushNotifs, generateNotifUserInfoPromise }; export { preparePushNotifs, generateNotifUserInfoPromise };
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.h

Show All 40 Lines
import type { import type {
ResolvedNotifTexts, ResolvedNotifTexts,
NotificationTargetDevice, NotificationTargetDevice,
TargetedNotificationWithPlatform, TargetedNotificationWithPlatform,
SenderDeviceDescriptor, SenderDeviceDescriptor,
EncryptedNotifUtilsAPI, EncryptedNotifUtilsAPI,
} from '../types/notif-types.js'; } from '../types/notif-types.js';
import type { ThreadSubscription } from '../types/subscription-types.js'; import type { ThreadSubscription } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { ThickRawThreadInfos } from '../types/thread-types.js';
import type { UserInfos } from '../types/user-types.js'; import type { UserInfos } from '../types/user-types.js';
import { type GetENSNames } from '../utils/ens-helpers.js'; import { type GetENSNames } from '../utils/ens-helpers.js';
import { type GetFCNames } from '../utils/farcaster-helpers.js'; import { type GetFCNames } from '../utils/farcaster-helpers.js';
import { promiseAll } from '../utils/promises.js'; import { promiseAll } from '../utils/promises.js';
export type Device = { export type Device = {
+platformDetails: PlatformDetails, +platformDetails: PlatformDetails,
+deliveryID: string, +deliveryID: string,
Show All 23 Lines): PlatformDetails {
return { return {
...rest, ...rest,
platform: identityDeviceTypeToPlatform[deviceType], platform: identityDeviceTypeToPlatform[deviceType],
}; };
} }
async function getPushUserInfo( async function getPushUserInfo(
messageInfos: { +[id: string]: RawMessageInfo }, messageInfos: { +[id: string]: RawMessageInfo },
rawThreadInfos: RawThreadInfos, thickRawThreadInfos: ThickRawThreadInfos,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
messageDatas: $ReadOnlyArray<MessageData>, messageDatas: $ReadOnlyArray<MessageData>,
): Promise<{ ): Promise<{
+pushInfos: ?PushInfo, +pushInfos: ?PushInfo,
+rescindInfos: ?PushInfo, +rescindInfos: ?PushInfo,
}> { }> {
if (messageDatas.length === 0) { if (messageDatas.length === 0) {
return { pushInfos: null, rescindInfos: null }; return { pushInfos: null, rescindInfos: null };
Show All 29 Lines [userID: string]: {
devices: $ReadOnlyArray<Device>, devices: $ReadOnlyArray<Device>,
threadsWithSubscriptions: { threadsWithSubscriptions: {
[threadID: string]: ThreadSubscriptionWithRole, [threadID: string]: ThreadSubscriptionWithRole,
}, },
}, },
} = {}; } = {};
for (const threadID of threadsToMessageIndices.keys()) { for (const threadID of threadsToMessageIndices.keys()) {
const threadInfo = rawThreadInfos[threadID]; const threadInfo = thickRawThreadInfos[threadID];
for (const memberInfo of threadInfo.members) { for (const memberInfo of threadInfo.members) {
if ( if (
!isMemberActive(memberInfo) || !isMemberActive(memberInfo) ||
!hasPermission(memberInfo.permissions, 'visible') || !hasPermission(memberInfo.permissions, 'visible')
!memberInfo.subscription
) { ) {
continue; continue;
} }
if (pushUserThreadInfos[memberInfo.id]) { if (pushUserThreadInfos[memberInfo.id]) {
pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] = pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
{ ...memberInfo.subscription, role: memberInfo.role }; { ...memberInfo.subscription, role: memberInfo.role };
continue; continue;
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
export type PerUserTargetedNotifications = { export type PerUserTargetedNotifications = {
+[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>, +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
}; };
type BuildNotifsFromPushInfoInputData = { type BuildNotifsFromPushInfoInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+pushInfo: PushInfo, +pushInfo: PushInfo,
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function buildNotifsFromPushInfo( async function buildNotifsFromPushInfo(
inputData: BuildNotifsFromPushInfoInputData, inputData: BuildNotifsFromPushInfoInputData,
): Promise<PerUserTargetedNotifications> { ): Promise<PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo, pushInfo,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const threadIDs = new Set<string>(); const threadIDs = new Set<string>();
for (const userID in pushInfo) { for (const userID in pushInfo) {
for (const rawMessageInfo of pushInfo[userID].messageInfos) { for (const rawMessageInfo of pushInfo[userID].messageInfos) {
Show All 13 Lines const perUserBuildNotifsResultPromises: {
[userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>, [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
} = {}; } = {};
for (const userID in pushInfo) { for (const userID in pushInfo) {
const threadInfos = Object.fromEntries( const threadInfos = Object.fromEntries(
[...threadIDs].map(threadID => [ [...threadIDs].map(threadID => [
threadID, threadID,
threadInfoFromRawThreadInfo( threadInfoFromRawThreadInfo(
rawThreadInfos[threadID], thickRawThreadInfos[threadID],
userID, userID,
userInfos, userInfos,
), ),
]), ]),
); );
const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices); const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
const singleNotificationPromises = []; const singleNotificationPromises = [];
Show All 27 Lines): Promise<PerUserTargetedNotifications> {
return promiseAll(perUserBuildNotifsResultPromises); return promiseAll(perUserBuildNotifsResultPromises);
} }
type PreparePushNotifsInputData = { type PreparePushNotifsInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+messageInfos: { +[id: string]: RawMessageInfo }, +messageInfos: { +[id: string]: RawMessageInfo },
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+auxUserInfos: AuxUserInfos, +auxUserInfos: AuxUserInfos,
+messageDatas: $ReadOnlyArray<MessageData>, +messageDatas: $ReadOnlyArray<MessageData>,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function preparePushNotifs( async function preparePushNotifs(
inputData: PreparePushNotifsInputData, inputData: PreparePushNotifsInputData,
): Promise<?PerUserTargetedNotifications> { ): Promise<?PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
messageDatas, messageDatas,
messageInfos, messageInfos,
auxUserInfos, auxUserInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const { pushInfos } = await getPushUserInfo( const { pushInfos } = await getPushUserInfo(
messageInfos, messageInfos,
rawThreadInfos, thickRawThreadInfos,
auxUserInfos, auxUserInfos,
messageDatas, messageDatas,
); );
if (!pushInfos) { if (!pushInfos) {
return null; return null;
} }
return await buildNotifsFromPushInfo({ return await buildNotifsFromPushInfo({
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo: pushInfos, pushInfo: pushInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
}); });
} }
export { preparePushNotifs, generateNotifUserInfoPromise }; export { preparePushNotifs, generateNotifUserInfoPromise };
View Options

native/cpp/CommonCpp/NativeModules/CommCoreModule.cpp

Show All 40 Lines
import type { import type {
ResolvedNotifTexts, ResolvedNotifTexts,
NotificationTargetDevice, NotificationTargetDevice,
TargetedNotificationWithPlatform, TargetedNotificationWithPlatform,
SenderDeviceDescriptor, SenderDeviceDescriptor,
EncryptedNotifUtilsAPI, EncryptedNotifUtilsAPI,
} from '../types/notif-types.js'; } from '../types/notif-types.js';
import type { ThreadSubscription } from '../types/subscription-types.js'; import type { ThreadSubscription } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { ThickRawThreadInfos } from '../types/thread-types.js';
import type { UserInfos } from '../types/user-types.js'; import type { UserInfos } from '../types/user-types.js';
import { type GetENSNames } from '../utils/ens-helpers.js'; import { type GetENSNames } from '../utils/ens-helpers.js';
import { type GetFCNames } from '../utils/farcaster-helpers.js'; import { type GetFCNames } from '../utils/farcaster-helpers.js';
import { promiseAll } from '../utils/promises.js'; import { promiseAll } from '../utils/promises.js';
export type Device = { export type Device = {
+platformDetails: PlatformDetails, +platformDetails: PlatformDetails,
+deliveryID: string, +deliveryID: string,
Show All 23 Lines): PlatformDetails {
return { return {
...rest, ...rest,
platform: identityDeviceTypeToPlatform[deviceType], platform: identityDeviceTypeToPlatform[deviceType],
}; };
} }
async function getPushUserInfo( async function getPushUserInfo(
messageInfos: { +[id: string]: RawMessageInfo }, messageInfos: { +[id: string]: RawMessageInfo },
rawThreadInfos: RawThreadInfos, thickRawThreadInfos: ThickRawThreadInfos,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
messageDatas: $ReadOnlyArray<MessageData>, messageDatas: $ReadOnlyArray<MessageData>,
): Promise<{ ): Promise<{
+pushInfos: ?PushInfo, +pushInfos: ?PushInfo,
+rescindInfos: ?PushInfo, +rescindInfos: ?PushInfo,
}> { }> {
if (messageDatas.length === 0) { if (messageDatas.length === 0) {
return { pushInfos: null, rescindInfos: null }; return { pushInfos: null, rescindInfos: null };
Show All 29 Lines [userID: string]: {
devices: $ReadOnlyArray<Device>, devices: $ReadOnlyArray<Device>,
threadsWithSubscriptions: { threadsWithSubscriptions: {
[threadID: string]: ThreadSubscriptionWithRole, [threadID: string]: ThreadSubscriptionWithRole,
}, },
}, },
} = {}; } = {};
for (const threadID of threadsToMessageIndices.keys()) { for (const threadID of threadsToMessageIndices.keys()) {
const threadInfo = rawThreadInfos[threadID]; const threadInfo = thickRawThreadInfos[threadID];
for (const memberInfo of threadInfo.members) { for (const memberInfo of threadInfo.members) {
if ( if (
!isMemberActive(memberInfo) || !isMemberActive(memberInfo) ||
!hasPermission(memberInfo.permissions, 'visible') || !hasPermission(memberInfo.permissions, 'visible')
!memberInfo.subscription
) { ) {
continue; continue;
} }
if (pushUserThreadInfos[memberInfo.id]) { if (pushUserThreadInfos[memberInfo.id]) {
pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] = pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
{ ...memberInfo.subscription, role: memberInfo.role }; { ...memberInfo.subscription, role: memberInfo.role };
continue; continue;
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
export type PerUserTargetedNotifications = { export type PerUserTargetedNotifications = {
+[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>, +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
}; };
type BuildNotifsFromPushInfoInputData = { type BuildNotifsFromPushInfoInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+pushInfo: PushInfo, +pushInfo: PushInfo,
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function buildNotifsFromPushInfo( async function buildNotifsFromPushInfo(
inputData: BuildNotifsFromPushInfoInputData, inputData: BuildNotifsFromPushInfoInputData,
): Promise<PerUserTargetedNotifications> { ): Promise<PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo, pushInfo,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const threadIDs = new Set<string>(); const threadIDs = new Set<string>();
for (const userID in pushInfo) { for (const userID in pushInfo) {
for (const rawMessageInfo of pushInfo[userID].messageInfos) { for (const rawMessageInfo of pushInfo[userID].messageInfos) {
Show All 13 Lines const perUserBuildNotifsResultPromises: {
[userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>, [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
} = {}; } = {};
for (const userID in pushInfo) { for (const userID in pushInfo) {
const threadInfos = Object.fromEntries( const threadInfos = Object.fromEntries(
[...threadIDs].map(threadID => [ [...threadIDs].map(threadID => [
threadID, threadID,
threadInfoFromRawThreadInfo( threadInfoFromRawThreadInfo(
rawThreadInfos[threadID], thickRawThreadInfos[threadID],
userID, userID,
userInfos, userInfos,
), ),
]), ]),
); );
const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices); const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
const singleNotificationPromises = []; const singleNotificationPromises = [];
Show All 27 Lines): Promise<PerUserTargetedNotifications> {
return promiseAll(perUserBuildNotifsResultPromises); return promiseAll(perUserBuildNotifsResultPromises);
} }
type PreparePushNotifsInputData = { type PreparePushNotifsInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+messageInfos: { +[id: string]: RawMessageInfo }, +messageInfos: { +[id: string]: RawMessageInfo },
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+auxUserInfos: AuxUserInfos, +auxUserInfos: AuxUserInfos,
+messageDatas: $ReadOnlyArray<MessageData>, +messageDatas: $ReadOnlyArray<MessageData>,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function preparePushNotifs( async function preparePushNotifs(
inputData: PreparePushNotifsInputData, inputData: PreparePushNotifsInputData,
): Promise<?PerUserTargetedNotifications> { ): Promise<?PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
messageDatas, messageDatas,
messageInfos, messageInfos,
auxUserInfos, auxUserInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const { pushInfos } = await getPushUserInfo( const { pushInfos } = await getPushUserInfo(
messageInfos, messageInfos,
rawThreadInfos, thickRawThreadInfos,
auxUserInfos, auxUserInfos,
messageDatas, messageDatas,
); );
if (!pushInfos) { if (!pushInfos) {
return null; return null;
} }
return await buildNotifsFromPushInfo({ return await buildNotifsFromPushInfo({
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo: pushInfos, pushInfo: pushInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
}); });
} }
export { preparePushNotifs, generateNotifUserInfoPromise }; export { preparePushNotifs, generateNotifUserInfoPromise };
View Options

native/cpp/CommonCpp/NativeModules/KeyserverStoreOperations.h

Show All 40 Lines
import type { import type {
ResolvedNotifTexts, ResolvedNotifTexts,
NotificationTargetDevice, NotificationTargetDevice,
TargetedNotificationWithPlatform, TargetedNotificationWithPlatform,
SenderDeviceDescriptor, SenderDeviceDescriptor,
EncryptedNotifUtilsAPI, EncryptedNotifUtilsAPI,
} from '../types/notif-types.js'; } from '../types/notif-types.js';
import type { ThreadSubscription } from '../types/subscription-types.js'; import type { ThreadSubscription } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { ThickRawThreadInfos } from '../types/thread-types.js';
import type { UserInfos } from '../types/user-types.js'; import type { UserInfos } from '../types/user-types.js';
import { type GetENSNames } from '../utils/ens-helpers.js'; import { type GetENSNames } from '../utils/ens-helpers.js';
import { type GetFCNames } from '../utils/farcaster-helpers.js'; import { type GetFCNames } from '../utils/farcaster-helpers.js';
import { promiseAll } from '../utils/promises.js'; import { promiseAll } from '../utils/promises.js';
export type Device = { export type Device = {
+platformDetails: PlatformDetails, +platformDetails: PlatformDetails,
+deliveryID: string, +deliveryID: string,
Show All 23 Lines): PlatformDetails {
return { return {
...rest, ...rest,
platform: identityDeviceTypeToPlatform[deviceType], platform: identityDeviceTypeToPlatform[deviceType],
}; };
} }
async function getPushUserInfo( async function getPushUserInfo(
messageInfos: { +[id: string]: RawMessageInfo }, messageInfos: { +[id: string]: RawMessageInfo },
rawThreadInfos: RawThreadInfos, thickRawThreadInfos: ThickRawThreadInfos,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
messageDatas: $ReadOnlyArray<MessageData>, messageDatas: $ReadOnlyArray<MessageData>,
): Promise<{ ): Promise<{
+pushInfos: ?PushInfo, +pushInfos: ?PushInfo,
+rescindInfos: ?PushInfo, +rescindInfos: ?PushInfo,
}> { }> {
if (messageDatas.length === 0) { if (messageDatas.length === 0) {
return { pushInfos: null, rescindInfos: null }; return { pushInfos: null, rescindInfos: null };
Show All 29 Lines [userID: string]: {
devices: $ReadOnlyArray<Device>, devices: $ReadOnlyArray<Device>,
threadsWithSubscriptions: { threadsWithSubscriptions: {
[threadID: string]: ThreadSubscriptionWithRole, [threadID: string]: ThreadSubscriptionWithRole,
}, },
}, },
} = {}; } = {};
for (const threadID of threadsToMessageIndices.keys()) { for (const threadID of threadsToMessageIndices.keys()) {
const threadInfo = rawThreadInfos[threadID]; const threadInfo = thickRawThreadInfos[threadID];
for (const memberInfo of threadInfo.members) { for (const memberInfo of threadInfo.members) {
if ( if (
!isMemberActive(memberInfo) || !isMemberActive(memberInfo) ||
!hasPermission(memberInfo.permissions, 'visible') || !hasPermission(memberInfo.permissions, 'visible')
!memberInfo.subscription
) { ) {
continue; continue;
} }
if (pushUserThreadInfos[memberInfo.id]) { if (pushUserThreadInfos[memberInfo.id]) {
pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] = pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
{ ...memberInfo.subscription, role: memberInfo.role }; { ...memberInfo.subscription, role: memberInfo.role };
continue; continue;
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
export type PerUserTargetedNotifications = { export type PerUserTargetedNotifications = {
+[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>, +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
}; };
type BuildNotifsFromPushInfoInputData = { type BuildNotifsFromPushInfoInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+pushInfo: PushInfo, +pushInfo: PushInfo,
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function buildNotifsFromPushInfo( async function buildNotifsFromPushInfo(
inputData: BuildNotifsFromPushInfoInputData, inputData: BuildNotifsFromPushInfoInputData,
): Promise<PerUserTargetedNotifications> { ): Promise<PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo, pushInfo,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const threadIDs = new Set<string>(); const threadIDs = new Set<string>();
for (const userID in pushInfo) { for (const userID in pushInfo) {
for (const rawMessageInfo of pushInfo[userID].messageInfos) { for (const rawMessageInfo of pushInfo[userID].messageInfos) {
Show All 13 Lines const perUserBuildNotifsResultPromises: {
[userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>, [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
} = {}; } = {};
for (const userID in pushInfo) { for (const userID in pushInfo) {
const threadInfos = Object.fromEntries( const threadInfos = Object.fromEntries(
[...threadIDs].map(threadID => [ [...threadIDs].map(threadID => [
threadID, threadID,
threadInfoFromRawThreadInfo( threadInfoFromRawThreadInfo(
rawThreadInfos[threadID], thickRawThreadInfos[threadID],
userID, userID,
userInfos, userInfos,
), ),
]), ]),
); );
const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices); const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
const singleNotificationPromises = []; const singleNotificationPromises = [];
Show All 27 Lines): Promise<PerUserTargetedNotifications> {
return promiseAll(perUserBuildNotifsResultPromises); return promiseAll(perUserBuildNotifsResultPromises);
} }
type PreparePushNotifsInputData = { type PreparePushNotifsInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+messageInfos: { +[id: string]: RawMessageInfo }, +messageInfos: { +[id: string]: RawMessageInfo },
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+auxUserInfos: AuxUserInfos, +auxUserInfos: AuxUserInfos,
+messageDatas: $ReadOnlyArray<MessageData>, +messageDatas: $ReadOnlyArray<MessageData>,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function preparePushNotifs( async function preparePushNotifs(
inputData: PreparePushNotifsInputData, inputData: PreparePushNotifsInputData,
): Promise<?PerUserTargetedNotifications> { ): Promise<?PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
messageDatas, messageDatas,
messageInfos, messageInfos,
auxUserInfos, auxUserInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const { pushInfos } = await getPushUserInfo( const { pushInfos } = await getPushUserInfo(
messageInfos, messageInfos,
rawThreadInfos, thickRawThreadInfos,
auxUserInfos, auxUserInfos,
messageDatas, messageDatas,
); );
if (!pushInfos) { if (!pushInfos) {
return null; return null;
} }
return await buildNotifsFromPushInfo({ return await buildNotifsFromPushInfo({
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo: pushInfos, pushInfo: pushInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
}); });
} }
export { preparePushNotifs, generateNotifUserInfoPromise }; export { preparePushNotifs, generateNotifUserInfoPromise };
View Options

native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.h

Show All 40 Lines
import type { import type {
ResolvedNotifTexts, ResolvedNotifTexts,
NotificationTargetDevice, NotificationTargetDevice,
TargetedNotificationWithPlatform, TargetedNotificationWithPlatform,
SenderDeviceDescriptor, SenderDeviceDescriptor,
EncryptedNotifUtilsAPI, EncryptedNotifUtilsAPI,
} from '../types/notif-types.js'; } from '../types/notif-types.js';
import type { ThreadSubscription } from '../types/subscription-types.js'; import type { ThreadSubscription } from '../types/subscription-types.js';
import type { RawThreadInfos } from '../types/thread-types.js'; import type { ThickRawThreadInfos } from '../types/thread-types.js';
import type { UserInfos } from '../types/user-types.js'; import type { UserInfos } from '../types/user-types.js';
import { type GetENSNames } from '../utils/ens-helpers.js'; import { type GetENSNames } from '../utils/ens-helpers.js';
import { type GetFCNames } from '../utils/farcaster-helpers.js'; import { type GetFCNames } from '../utils/farcaster-helpers.js';
import { promiseAll } from '../utils/promises.js'; import { promiseAll } from '../utils/promises.js';
export type Device = { export type Device = {
+platformDetails: PlatformDetails, +platformDetails: PlatformDetails,
+deliveryID: string, +deliveryID: string,
Show All 23 Lines): PlatformDetails {
return { return {
...rest, ...rest,
platform: identityDeviceTypeToPlatform[deviceType], platform: identityDeviceTypeToPlatform[deviceType],
}; };
} }
async function getPushUserInfo( async function getPushUserInfo(
messageInfos: { +[id: string]: RawMessageInfo }, messageInfos: { +[id: string]: RawMessageInfo },
rawThreadInfos: RawThreadInfos, thickRawThreadInfos: ThickRawThreadInfos,
auxUserInfos: AuxUserInfos, auxUserInfos: AuxUserInfos,
messageDatas: $ReadOnlyArray<MessageData>, messageDatas: $ReadOnlyArray<MessageData>,
): Promise<{ ): Promise<{
+pushInfos: ?PushInfo, +pushInfos: ?PushInfo,
+rescindInfos: ?PushInfo, +rescindInfos: ?PushInfo,
}> { }> {
if (messageDatas.length === 0) { if (messageDatas.length === 0) {
return { pushInfos: null, rescindInfos: null }; return { pushInfos: null, rescindInfos: null };
Show All 29 Lines [userID: string]: {
devices: $ReadOnlyArray<Device>, devices: $ReadOnlyArray<Device>,
threadsWithSubscriptions: { threadsWithSubscriptions: {
[threadID: string]: ThreadSubscriptionWithRole, [threadID: string]: ThreadSubscriptionWithRole,
}, },
}, },
} = {}; } = {};
for (const threadID of threadsToMessageIndices.keys()) { for (const threadID of threadsToMessageIndices.keys()) {
const threadInfo = rawThreadInfos[threadID]; const threadInfo = thickRawThreadInfos[threadID];
for (const memberInfo of threadInfo.members) { for (const memberInfo of threadInfo.members) {
if ( if (
!isMemberActive(memberInfo) || !isMemberActive(memberInfo) ||
!hasPermission(memberInfo.permissions, 'visible') || !hasPermission(memberInfo.permissions, 'visible')
!memberInfo.subscription
) { ) {
continue; continue;
} }
if (pushUserThreadInfos[memberInfo.id]) { if (pushUserThreadInfos[memberInfo.id]) {
pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] = pushUserThreadInfos[memberInfo.id].threadsWithSubscriptions[threadID] =
{ ...memberInfo.subscription, role: memberInfo.role }; { ...memberInfo.subscription, role: memberInfo.role };
continue; continue;
▲ Show 20 Lines • Show All 415 Lines • ▼ Show 20 Lines
export type PerUserTargetedNotifications = { export type PerUserTargetedNotifications = {
+[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>, +[userID: string]: $ReadOnlyArray<TargetedNotificationWithPlatform>,
}; };
type BuildNotifsFromPushInfoInputData = { type BuildNotifsFromPushInfoInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+pushInfo: PushInfo, +pushInfo: PushInfo,
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function buildNotifsFromPushInfo( async function buildNotifsFromPushInfo(
inputData: BuildNotifsFromPushInfoInputData, inputData: BuildNotifsFromPushInfoInputData,
): Promise<PerUserTargetedNotifications> { ): Promise<PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo, pushInfo,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const threadIDs = new Set<string>(); const threadIDs = new Set<string>();
for (const userID in pushInfo) { for (const userID in pushInfo) {
for (const rawMessageInfo of pushInfo[userID].messageInfos) { for (const rawMessageInfo of pushInfo[userID].messageInfos) {
Show All 13 Lines const perUserBuildNotifsResultPromises: {
[userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>, [userID: string]: Promise<$ReadOnlyArray<TargetedNotificationWithPlatform>>,
} = {}; } = {};
for (const userID in pushInfo) { for (const userID in pushInfo) {
const threadInfos = Object.fromEntries( const threadInfos = Object.fromEntries(
[...threadIDs].map(threadID => [ [...threadIDs].map(threadID => [
threadID, threadID,
threadInfoFromRawThreadInfo( threadInfoFromRawThreadInfo(
rawThreadInfos[threadID], thickRawThreadInfos[threadID],
userID, userID,
userInfos, userInfos,
), ),
]), ]),
); );
const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices); const devicesByPlatform = getDevicesByPlatform(pushInfo[userID].devices);
const singleNotificationPromises = []; const singleNotificationPromises = [];
Show All 27 Lines): Promise<PerUserTargetedNotifications> {
return promiseAll(perUserBuildNotifsResultPromises); return promiseAll(perUserBuildNotifsResultPromises);
} }
type PreparePushNotifsInputData = { type PreparePushNotifsInputData = {
+encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI, +encryptedNotifUtilsAPI: EncryptedNotifUtilsAPI,
+senderDeviceDescriptor: SenderDeviceDescriptor, +senderDeviceDescriptor: SenderDeviceDescriptor,
+messageInfos: { +[id: string]: RawMessageInfo }, +messageInfos: { +[id: string]: RawMessageInfo },
+rawThreadInfos: RawThreadInfos, +thickRawThreadInfos: ThickRawThreadInfos,
+auxUserInfos: AuxUserInfos, +auxUserInfos: AuxUserInfos,
+messageDatas: $ReadOnlyArray<MessageData>, +messageDatas: $ReadOnlyArray<MessageData>,
+userInfos: UserInfos, +userInfos: UserInfos,
+getENSNames: ?GetENSNames, +getENSNames: ?GetENSNames,
+getFCNames: ?GetFCNames, +getFCNames: ?GetFCNames,
}; };
async function preparePushNotifs( async function preparePushNotifs(
inputData: PreparePushNotifsInputData, inputData: PreparePushNotifsInputData,
): Promise<?PerUserTargetedNotifications> { ): Promise<?PerUserTargetedNotifications> {
const { const {
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
messageDatas, messageDatas,
messageInfos, messageInfos,
auxUserInfos, auxUserInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
} = inputData; } = inputData;
const { pushInfos } = await getPushUserInfo( const { pushInfos } = await getPushUserInfo(
messageInfos, messageInfos,
rawThreadInfos, thickRawThreadInfos,
auxUserInfos, auxUserInfos,
messageDatas, messageDatas,
); );
if (!pushInfos) { if (!pushInfos) {
return null; return null;
} }
return await buildNotifsFromPushInfo({ return await buildNotifsFromPushInfo({
encryptedNotifUtilsAPI, encryptedNotifUtilsAPI,
senderDeviceDescriptor, senderDeviceDescriptor,
pushInfo: pushInfos, pushInfo: pushInfos,
rawThreadInfos, thickRawThreadInfos,
userInfos, userInfos,
getENSNames, getENSNames,
getFCNames, getFCNames,
}); });
} }
export { preparePushNotifs, generateNotifUserInfoPromise }; export { preparePushNotifs, generateNotifUserInfoPromise };
View Options

native/cpp/CommonCpp/NativeModules/PersistentStorageUtilities/DataStores/KeyserverStore.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI-generated.cpp

Loading...
View Options

native/cpp/CommonCpp/_generated/commJSI.h

Loading...
View Options

native/ios/Comm.xcodeproj/project.pbxproj

Loading...
View Options

native/schema/CommCoreModuleSchema.js

Loading...