Page MenuHomePhabricator
Differential D6817 Diff 23059 keyserver/src/push/send.js

Changeset View

Standalone View

View Options

keyserver/src/push/send.js

Show All 33 Lines
import { getAPNsNotificationTopic } from './providers.js'; import { getAPNsNotificationTopic } from './providers.js';
import { import {
apnPush, apnPush,
fcmPush, fcmPush,
getUnreadCounts, getUnreadCounts,
apnMaxNotificationPayloadByteSize, apnMaxNotificationPayloadByteSize,
fcmMaxNotificationPayloadByteSize, fcmMaxNotificationPayloadByteSize,
webPush,
type WebNotification,
} from './utils.js'; } from './utils.js';
import createIDs from '../creators/id-creator.js'; import createIDs from '../creators/id-creator.js';
import { createUpdates } from '../creators/update-creator.js'; import { createUpdates } from '../creators/update-creator.js';
import { dbQuery, SQL, mergeOrConditions } from '../database/database.js'; import { dbQuery, SQL, mergeOrConditions } from '../database/database.js';
import type { CollapsableNotifInfo } from '../fetchers/message-fetchers.js'; import type { CollapsableNotifInfo } from '../fetchers/message-fetchers.js';
import { fetchCollapsableNotifs } from '../fetchers/message-fetchers.js'; import { fetchCollapsableNotifs } from '../fetchers/message-fetchers.js';
import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js'; import { fetchServerThreadInfos } from '../fetchers/thread-fetchers.js';
import { fetchUserInfos } from '../fetchers/user-fetchers.js'; import { fetchUserInfos } from '../fetchers/user-fetchers.js';
import type { Viewer } from '../session/viewer.js'; import type { Viewer } from '../session/viewer.js';
import { getENSNames } from '../utils/ens-cache.js'; import { getENSNames } from '../utils/ens-cache.js';
type Device = { type Device = {
+platform: Platform, +platform: Platform,
+deviceToken: string, +deviceToken: string,
+codeVersion: ?number, +codeVersion: ?number,
}; };
type PushUserInfo = { type PushUserInfo = {
+devices: Device[], +devices: Device[],
+messageInfos: RawMessageInfo[], +messageInfos: RawMessageInfo[],
}; };
type Delivery = IOSDelivery | AndroidDelivery | { collapsedInto: string }; type Delivery = PushDelivery | { collapsedInto: string };
type NotificationRow = { type NotificationRow = {
+dbID: string, +dbID: string,
+userID: string, +userID: string,
+threadID?: ?string, +threadID?: ?string,
+messageID?: ?string, +messageID?: ?string,
+collapseKey?: ?string, +collapseKey?: ?string,
+deliveries: Delivery[], +deliveries: Delivery[],
}; };
▲ Show 20 Lines • Show All 137 Lines • ▼ Show 20 Lines for (const notifInfo of usersToCollapsableNotifInfo[userID]) {
...notificationInfo, ...notificationInfo,
codeVersion, codeVersion,
}, },
); );
})(); })();
deliveryPromises.push(deliveryPromise); deliveryPromises.push(deliveryPromise);
} }
} }
const webVersionsToTokens = byPlatform.get('web');
if (webVersionsToTokens) {
for (const [codeVersion, deviceTokens] of webVersionsToTokens) {
const deliveryPromise = (async () => {
const notification = await prepareWebNotification(
allMessageInfos,
threadInfo,
unreadCounts[userID],
);
return await sendWebNotification(notification, [...deviceTokens], {
...notificationInfo,
codeVersion,
});
})();
deliveryPromises.push(deliveryPromise);
}
}
for (const newMessageInfo of remainingNewMessageInfos) { for (const newMessageInfo of remainingNewMessageInfos) {
const newDBID = dbIDs.shift(); const newDBID = dbIDs.shift();
invariant(newDBID, 'should have sufficient DB IDs'); invariant(newDBID, 'should have sufficient DB IDs');
const messageID = newMessageInfo.id; const messageID = newMessageInfo.id;
invariant(messageID, 'RawMessageInfo.id should be set on server'); invariant(messageID, 'RawMessageInfo.id should be set on server');
notifications.set(newDBID, { notifications.set(newDBID, {
dbID: newDBID, dbID: newDBID,
Show All 18 Linesasync function sendPushNotifs(pushInfo: PushInfo) {
]); ]);
await saveNotifResults(deliveryResults, notifications, true); await saveNotifResults(deliveryResults, notifications, true);
} }
// The results in deliveryResults will be combined with the rows // The results in deliveryResults will be combined with the rows
// in rowsToSave and then written to the notifications table // in rowsToSave and then written to the notifications table
async function saveNotifResults( async function saveNotifResults(
deliveryResults: $ReadOnlyArray<IOSResult | AndroidResult>, deliveryResults: $ReadOnlyArray<PushResult>,
inputRowsToSave: Map<string, NotificationRow>, inputRowsToSave: Map<string, NotificationRow>,
rescindable: boolean, rescindable: boolean,
) { ) {
const rowsToSave = new Map(inputRowsToSave); const rowsToSave = new Map(inputRowsToSave);
const allInvalidTokens = []; const allInvalidTokens = [];
for (const deliveryResult of deliveryResults) { for (const deliveryResult of deliveryResults) {
const { info, delivery, invalidTokens } = deliveryResult; const { info, delivery, invalidTokens } = deliveryResult;
▲ Show 20 Lines • Show All 332 Lines • ▼ Show 20 Lines): Promise<Object> {
) { ) {
console.warn( console.warn(
`Android notification ${notifID} exceeds size limit, even with messageInfos omitted`, `Android notification ${notifID} exceeds size limit, even with messageInfos omitted`,
); );
} }
return notification; return notification;
} }
async function prepareWebNotification(
allMessageInfos: MessageInfo[],
threadInfo: ThreadInfo,
unreadCount: number,
): Promise<WebNotification> {
const id = uuidv4();
const { merged, ...rest } = await notifTextsForMessageInfo(
allMessageInfos,
threadInfo,
getENSNames,
);
const notification = {
...rest,
unreadCount,
id,
threadID: threadInfo.id,
};
return notification;
}
type NotificationInfo = type NotificationInfo =
| { | {
+source: 'new_message', +source: 'new_message',
+dbID: string, +dbID: string,
+userID: string, +userID: string,
+threadID: string, +threadID: string,
+messageID: string, +messageID: string,
+collapseKey: ?string, +collapseKey: ?string,
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines const result: IOSResult = {
delivery, delivery,
}; };
if (response.invalidTokens) { if (response.invalidTokens) {
result.invalidTokens = response.invalidTokens; result.invalidTokens = response.invalidTokens;
} }
return result; return result;
} }
type PushResult = AndroidResult | IOSResult | WebResult;
type PushDelivery = AndroidDelivery | IOSDelivery | WebDelivery;
type AndroidDelivery = { type AndroidDelivery = {
source: $PropertyType<NotificationInfo, 'source'>, source: $PropertyType<NotificationInfo, 'source'>,
deviceType: 'android', deviceType: 'android',
androidIDs: $ReadOnlyArray<string>, androidIDs: $ReadOnlyArray<string>,
deviceTokens: $ReadOnlyArray<string>, deviceTokens: $ReadOnlyArray<string>,
codeVersion: number, codeVersion: number,
errors?: $ReadOnlyArray<Object>, errors?: $ReadOnlyArray<Object>,
}; };
Show All 33 Lines const result: AndroidResult = {
delivery, delivery,
}; };
if (response.invalidTokens) { if (response.invalidTokens) {
result.invalidTokens = response.invalidTokens; result.invalidTokens = response.invalidTokens;
} }
return result; return result;
} }
type WebDelivery = {
+source: $PropertyType<NotificationInfo, 'source'>,
+deviceType: 'web',
+deviceTokens: $ReadOnlyArray<string>,
+codeVersion?: number,
+errors?: $ReadOnlyArray<Object>,
ashoatUnsubmitted
Not Done
Inline Actions

Can we avoid Object?

ashoat: Can we avoid `Object`?
};
type WebResult = {
+info: NotificationInfo,
+delivery: WebDelivery,
+invalidTokens?: $ReadOnlyArray<string>,
};
async function sendWebNotification(
notification: WebNotification,
deviceTokens: $ReadOnlyArray<string>,
notificationInfo: NotificationInfo,
): Promise<WebResult> {
const { source, codeVersion } = notificationInfo;
const response = await webPush({
notification,
deviceTokens,
});
const delivery: WebDelivery = {
source,
deviceType: 'web',
deviceTokens,
codeVersion,
errors: response.errors,
};
const result: WebResult = {
info: notificationInfo,
delivery,
invalidTokens: response.invalidTokens,
};
return result;
}
type InvalidToken = { type InvalidToken = {
+userID: string, +userID: string,
+tokens: $ReadOnlyArray<string>, +tokens: $ReadOnlyArray<string>,
}; };
async function removeInvalidTokens( async function removeInvalidTokens(
invalidTokens: $ReadOnlyArray<InvalidToken>, invalidTokens: $ReadOnlyArray<InvalidToken>,
): Promise<void> { ): Promise<void> {
const sqlTuples = invalidTokens.map( const sqlTuples = invalidTokens.map(
▲ Show 20 Lines • Show All 131 Lines • Show Last 20 Lines