Skip to content

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

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

import {BatchBuilder, deleteOneOrMany, fetchMany, fetchOne, upsertOne} from '@app/api/database/CassandraQueryExecution';
import {Db, type PatchObject} from '@app/api/database/CassandraTypes';
import {executeVersionedUpdate} from '@app/api/database/CassandraVersionedUpdate';
import type {
	DonorByStripeCustomerIdRow,
	DonorByStripeSubscriptionIdRow,
	DonorMagicLinkTokenByEmailRow,
	DonorMagicLinkTokenRow,
	DonorRow,
} from '@app/api/database/types/DonationTypes';
import {
	DonorMagicLinkTokens,
	DonorMagicLinkTokensByEmail,
	Donors,
	DonorsByStripeCustomerId,
	DonorsByStripeSubscriptionId,
} from '@app/api/donation/DonationTables';
import {Donor} from '@app/api/donation/models/Donor';
import {DonorMagicLinkToken} from '@app/api/donation/models/DonorMagicLinkToken';

const FETCH_DONOR_BY_EMAIL_QUERY = Donors.selectCql({
	where: Donors.where.eq('email'),
	limit: 1,
});
const FETCH_DONOR_BY_STRIPE_CUSTOMER_ID_QUERY = DonorsByStripeCustomerId.selectCql({
	columns: ['email'],
	where: DonorsByStripeCustomerId.where.eq('stripe_customer_id'),
	limit: 1,
});
const FETCH_DONOR_BY_STRIPE_SUBSCRIPTION_ID_QUERY = DonorsByStripeSubscriptionId.selectCql({
	columns: ['email'],
	where: DonorsByStripeSubscriptionId.where.eq('stripe_subscription_id'),
	limit: 1,
});
const FETCH_MAGIC_LINK_TOKEN_QUERY = DonorMagicLinkTokens.selectCql({
	where: DonorMagicLinkTokens.where.eq('token_'),
	limit: 1,
});
const FETCH_MAGIC_LINK_TOKENS_BY_EMAIL_QUERY = DonorMagicLinkTokensByEmail.selectCql({
	columns: ['donor_email', 'token_'],
	where: DonorMagicLinkTokensByEmail.where.eq('donor_email'),
});

export class DonationRepository {
	async findDonorByEmail(email: string): Promise<Donor | null> {
		const row = await fetchOne<DonorRow>(FETCH_DONOR_BY_EMAIL_QUERY, {email});
		return row ? new Donor(row) : null;
	}

	async findDonorByStripeCustomerId(customerId: string): Promise<Donor | null> {
		const mapping = await fetchOne<DonorByStripeCustomerIdRow>(FETCH_DONOR_BY_STRIPE_CUSTOMER_ID_QUERY, {
			stripe_customer_id: customerId,
		});
		if (!mapping) return null;
		return this.findDonorByEmail(mapping.email);
	}

	async findDonorByStripeSubscriptionId(subscriptionId: string): Promise<Donor | null> {
		const mapping = await fetchOne<DonorByStripeSubscriptionIdRow>(FETCH_DONOR_BY_STRIPE_SUBSCRIPTION_ID_QUERY, {
			stripe_subscription_id: subscriptionId,
		});
		if (!mapping) return null;
		return this.findDonorByEmail(mapping.email);
	}

	async createDonor(data: {
		email: string;
		stripeCustomerId: string | null;
		businessName?: string | null;
		taxId?: string | null;
		taxIdType?: string | null;
		stripeSubscriptionId: string | null;
		subscriptionAmountCents: number | null;
		subscriptionCurrency: string | null;
		subscriptionInterval: string | null;
		subscriptionCurrentPeriodEnd: Date | null;
		subscriptionCancelAt?: Date | null;
		subscriptionStatus?: string | null;
	}): Promise<Donor> {
		const now = new Date();
		const donorRow: DonorRow = {
			email: data.email,
			stripe_customer_id: data.stripeCustomerId,
			business_name: data.businessName ?? null,
			tax_id: data.taxId ?? null,
			tax_id_type: data.taxIdType ?? null,
			stripe_subscription_id: data.stripeSubscriptionId,
			subscription_amount_cents: data.subscriptionAmountCents,
			subscription_currency: data.subscriptionCurrency,
			subscription_interval: data.subscriptionInterval,
			subscription_current_period_end: data.subscriptionCurrentPeriodEnd,
			subscription_cancel_at: data.subscriptionCancelAt ?? null,
			subscription_status: data.subscriptionStatus ?? null,
			created_at: now,
			updated_at: now,
			version: 1,
		};
		const batch = new BatchBuilder();
		batch.addPrepared(Donors.upsertAll(donorRow));
		if (donorRow.stripe_customer_id) {
			batch.addPrepared(
				DonorsByStripeCustomerId.upsertAll({
					stripe_customer_id: donorRow.stripe_customer_id,
					email: donorRow.email,
				}),
			);
		}
		if (donorRow.stripe_subscription_id) {
			batch.addPrepared(
				DonorsByStripeSubscriptionId.upsertAll({
					stripe_subscription_id: donorRow.stripe_subscription_id,
					email: donorRow.email,
				}),
			);
		}
		await batch.execute();
		return new Donor(donorRow);
	}

	async updateDonorSubscription(
		email: string,
		data: {
			stripeCustomerId: string | null;
			businessName?: string | null;
			taxId?: string | null;
			taxIdType?: string | null;
			stripeSubscriptionId: string | null;
			subscriptionAmountCents: number | null;
			subscriptionCurrency: string | null;
			subscriptionInterval: string | null;
			subscriptionCurrentPeriodEnd: Date | null;
			subscriptionCancelAt?: Date | null;
			subscriptionStatus?: string | null;
		},
	): Promise<Donor | null> {
		await executeVersionedUpdate(
			() => fetchOne<DonorRow>(FETCH_DONOR_BY_EMAIL_QUERY, {email}),
			() => {
				const patch: PatchObject = {
					stripe_customer_id: Db.set(data.stripeCustomerId),
					stripe_subscription_id: Db.set(data.stripeSubscriptionId),
					subscription_amount_cents: Db.set(data.subscriptionAmountCents),
					subscription_currency: Db.set(data.subscriptionCurrency),
					subscription_interval: Db.set(data.subscriptionInterval),
					subscription_current_period_end: Db.set(data.subscriptionCurrentPeriodEnd),
					subscription_cancel_at: Db.set(data.subscriptionCancelAt ?? null),
					subscription_status: Db.set(data.subscriptionStatus ?? null),
					updated_at: Db.set(new Date()),
				};
				if (data.businessName !== undefined) {
					patch.business_name = Db.set(data.businessName);
				}
				if (data.taxId !== undefined) {
					patch.tax_id = Db.set(data.taxId);
				}
				if (data.taxIdType !== undefined) {
					patch.tax_id_type = Db.set(data.taxIdType);
				}
				return {
					pk: {email},
					patch,
				};
			},
			Donors,
		);
		const batch = new BatchBuilder();
		if (data.stripeCustomerId) {
			batch.addPrepared(
				DonorsByStripeCustomerId.upsertAll({
					stripe_customer_id: data.stripeCustomerId,
					email,
				}),
			);
		}
		if (data.stripeSubscriptionId) {
			batch.addPrepared(
				DonorsByStripeSubscriptionId.upsertAll({
					stripe_subscription_id: data.stripeSubscriptionId,
					email,
				}),
			);
		}
		await batch.execute();
		return this.findDonorByEmail(email);
	}

	async updateDonorCustomerDetails(
		email: string,
		data: {
			stripeCustomerId: string | null;
			businessName?: string | null;
			taxId?: string | null;
			taxIdType?: string | null;
		},
	): Promise<Donor | null> {
		await executeVersionedUpdate(
			() => fetchOne<DonorRow>(FETCH_DONOR_BY_EMAIL_QUERY, {email}),
			() => {
				const patch: PatchObject = {
					stripe_customer_id: Db.set(data.stripeCustomerId),
					updated_at: Db.set(new Date()),
				};
				if (data.businessName !== undefined) {
					patch.business_name = Db.set(data.businessName);
				}
				if (data.taxId !== undefined) {
					patch.tax_id = Db.set(data.taxId);
				}
				if (data.taxIdType !== undefined) {
					patch.tax_id_type = Db.set(data.taxIdType);
				}
				return {
					pk: {email},
					patch,
				};
			},
			Donors,
		);
		if (data.stripeCustomerId) {
			await upsertOne(
				DonorsByStripeCustomerId.upsertAll({
					stripe_customer_id: data.stripeCustomerId,
					email,
				}),
			);
		}
		return this.findDonorByEmail(email);
	}

	async linkDonorStripeCustomer(email: string, stripeCustomerId: string): Promise<void> {
		await upsertOne(
			DonorsByStripeCustomerId.upsertAll({
				stripe_customer_id: stripeCustomerId,
				email,
			}),
		);
	}

	async clearDonorStripeCustomer(stripeCustomerId: string): Promise<void> {
		const donor = await this.findDonorByStripeCustomerId(stripeCustomerId);
		if (!donor) {
			return;
		}
		if (donor.stripeCustomerId === stripeCustomerId) {
			await executeVersionedUpdate(
				() => fetchOne<DonorRow>(FETCH_DONOR_BY_EMAIL_QUERY, {email: donor.email}),
				() => ({
					pk: {email: donor.email},
					patch: {
						stripe_customer_id: Db.clear(),
						updated_at: Db.set(new Date()),
					},
				}),
				Donors,
			);
		}
		await deleteOneOrMany(
			DonorsByStripeCustomerId.deleteByPk({
				stripe_customer_id: stripeCustomerId,
				email: donor.email,
			}),
		);
	}

	async cancelDonorSubscription(email: string): Promise<void> {
		const current = await this.findDonorByEmail(email);
		if (!current) {
			return;
		}
		const oldSubscriptionId = current.stripeSubscriptionId;
		await executeVersionedUpdate(
			() => fetchOne<DonorRow>(FETCH_DONOR_BY_EMAIL_QUERY, {email}),
			() => ({
				pk: {email},
				patch: {
					stripe_subscription_id: Db.clear(),
					subscription_amount_cents: Db.clear(),
					subscription_currency: Db.clear(),
					subscription_interval: Db.clear(),
					subscription_current_period_end: Db.clear(),
					subscription_cancel_at: Db.clear(),
					subscription_status: Db.clear(),
					updated_at: Db.set(new Date()),
				},
			}),
			Donors,
		);
		if (oldSubscriptionId) {
			await deleteOneOrMany(
				DonorsByStripeSubscriptionId.deleteByPk({
					stripe_subscription_id: oldSubscriptionId,
					email,
				}),
			);
		}
	}

	async deleteDonorSubscriptionMapping(stripeSubscriptionId: string, email: string): Promise<void> {
		await deleteOneOrMany(
			DonorsByStripeSubscriptionId.deleteByPk({
				stripe_subscription_id: stripeSubscriptionId,
				email,
			}),
		);
	}

	async createMagicLinkToken(token: DonorMagicLinkToken): Promise<void> {
		const row = token.toRow();
		const batch = new BatchBuilder();
		batch.addPrepared(DonorMagicLinkTokens.upsertAll(row));
		batch.addPrepared(
			DonorMagicLinkTokensByEmail.upsertAll({
				donor_email: row.donor_email,
				token_: row.token_,
			}),
		);
		await batch.execute();
	}

	async findMagicLinkToken(token: string): Promise<DonorMagicLinkToken | null> {
		const row = await fetchOne<DonorMagicLinkTokenRow>(FETCH_MAGIC_LINK_TOKEN_QUERY, {token_: token});
		return row ? new DonorMagicLinkToken(row) : null;
	}

	async markMagicLinkTokenUsed(token: string, usedAt: Date): Promise<void> {
		await fetchOne(
			DonorMagicLinkTokens.patchByPk(
				{token_: token},
				{
					used_at: Db.set(usedAt),
				},
			),
		);
	}

	async invalidateTokensForEmail(email: string): Promise<void> {
		const tokenRefs = await fetchMany<DonorMagicLinkTokenByEmailRow>(FETCH_MAGIC_LINK_TOKENS_BY_EMAIL_QUERY, {
			donor_email: email,
		});
		if (tokenRefs.length === 0) return;
		const batch = new BatchBuilder();
		for (const ref of tokenRefs) {
			batch.addPrepared(DonorMagicLinkTokens.deleteByPk({token_: ref.token_}));
			batch.addPrepared(
				DonorMagicLinkTokensByEmail.deleteByPk({
					donor_email: ref.donor_email,
					token_: ref.token_,
				}),
			);
		}
		await batch.execute();
	}
}