Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
3.7 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

import type {UserID} from '@app/api/BrandedTypes';
import {deleteOneOrMany, fetchMany, fetchOne, upsertOne} from '@app/api/database/CassandraQueryExecution';
import type {PushSubscriptionRow} from '@app/api/database/types/UserTypes';
import {PushSubscription} from '@app/api/models/PushSubscription';
import {PushSubscriptions} from '@app/api/Tables';
import {awaitAll} from '@app/api/utils/ConcurrencyUtils';
import {MAX_PUSH_SUBSCRIPTIONS_PER_USER} from '@fluxer/constants/src/LimitConstants';

const FETCH_PUSH_SUBSCRIPTIONS_CQL = PushSubscriptions.selectCql({
	where: PushSubscriptions.where.eq('user_id'),
});
const FETCH_PUSH_SUBSCRIPTION_THREAD_CHANNELS_CQL = PushSubscriptions.selectCql({
	columns: ['thread_channels'],
	where: [PushSubscriptions.where.eq('user_id'), PushSubscriptions.where.eq('subscription_id')],
	limit: 1,
});
const FETCH_BULK_PUSH_SUBSCRIPTIONS_CQL = PushSubscriptions.selectCql({
	where: PushSubscriptions.where.in('user_id', 'user_ids'),
});

export class PushSubscriptionRepository {
	async listPushSubscriptions(userId: UserID): Promise<Array<PushSubscription>> {
		const rows = await fetchMany<PushSubscriptionRow>(FETCH_PUSH_SUBSCRIPTIONS_CQL, {user_id: userId});
		return rows.map((row) => new PushSubscription(row));
	}

	async createPushSubscription(data: PushSubscriptionRow): Promise<PushSubscription> {
		const row =
			data.thread_channels === undefined && (await this.hasThreadChannels(data))
				? {...data, thread_channels: null}
				: data;
		await upsertOne(PushSubscriptions.upsertAll(row));
		return new PushSubscription(row);
	}

	private async hasThreadChannels(data: PushSubscriptionRow): Promise<boolean> {
		const existing = await fetchOne<Pick<PushSubscriptionRow, 'thread_channels'>>(
			FETCH_PUSH_SUBSCRIPTION_THREAD_CHANNELS_CQL,
			{user_id: data.user_id, subscription_id: data.subscription_id},
		);
		return existing?.thread_channels === true;
	}

	async deletePushSubscription(userId: UserID, subscriptionId: string): Promise<void> {
		await deleteOneOrMany(PushSubscriptions.deleteByPk({user_id: userId, subscription_id: subscriptionId}));
	}

	async deletePushSubscriptionsForAuthSessions(
		userId: UserID,
		authSessionIdHashes: Array<string>,
		options: {deleteUnboundSubscriptions: boolean},
	): Promise<void> {
		if (authSessionIdHashes.length === 0 && !options.deleteUnboundSubscriptions) return;
		const subscriptions = await this.listPushSubscriptions(userId);
		const authSessionIdHashSet = new Set(authSessionIdHashes);
		const subscriptionsToDelete = subscriptions.filter((subscription) => {
			if (subscription.authSessionIdHash === null) {
				return options.deleteUnboundSubscriptions;
			}
			return authSessionIdHashSet.has(subscription.authSessionIdHash);
		});
		if (subscriptionsToDelete.length === 0) return;
		await awaitAll(
			subscriptionsToDelete.map(async (subscription) =>
				this.deletePushSubscription(userId, subscription.subscriptionId),
			),
			'Failed to delete push subscriptions for auth sessions',
		);
	}

	async getBulkPushSubscriptions(userIds: Array<UserID>): Promise<Map<UserID, Array<PushSubscription>>> {
		if (userIds.length === 0) return new Map();
		const rows = await fetchMany<PushSubscriptionRow>(FETCH_BULK_PUSH_SUBSCRIPTIONS_CQL, {user_ids: userIds});
		const map = new Map<UserID, Array<PushSubscription>>();
		for (const row of rows) {
			const existing = map.get(row.user_id) ?? [];
			if (existing.length >= MAX_PUSH_SUBSCRIPTIONS_PER_USER) continue;
			existing.push(new PushSubscription(row));
			map.set(row.user_id, existing);
		}
		return map;
	}

	async deleteAllPushSubscriptions(userId: UserID): Promise<void> {
		await deleteOneOrMany(
			PushSubscriptions.delete({where: PushSubscriptions.where.eq('user_id')}).bind({user_id: userId}),
		);
	}
}