Skip to content

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

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

import type {GooglePlayAccessTokenProvider} from '@app/api/store_billing/google_play/GooglePlayAccessTokenProvider';
import {
	classifyGooglePlayStatus,
	GooglePlayApiError,
	parseRetryAfterMs,
} from '@app/api/store_billing/google_play/GooglePlayApiError';
import {isGooglePlayPackageConfigured} from '@app/api/store_billing/StoreBillingConfig';
import {ms} from 'itty-time';
import {z} from 'zod';

export const GOOGLE_PLAY_API_BASE_URL = 'https://androidpublisher.googleapis.com/androidpublisher/v3/applications';
const REQUEST_TIMEOUT_MS = ms('15 seconds');
const VOIDED_PURCHASE_TYPE_SUBSCRIPTIONS_AND_PRODUCTS = '1';

const ExternalAccountIdentifiersSchema = z.object({
	externalAccountId: z.string().optional(),
	obfuscatedExternalAccountId: z.string().optional(),
	obfuscatedExternalProfileId: z.string().optional(),
	obfuscatedAccountId: z.string().optional(),
	obfuscatedProfileId: z.string().optional(),
});

const SubscriptionLineItemSchema = z.object({
	productId: z.string(),
	expiryTime: z.string().optional(),
	latestSuccessfulOrderId: z.string().optional(),
	autoRenewingPlan: z
		.object({
			autoRenewEnabled: z.boolean().optional(),
		})
		.optional(),
	prepaidPlan: z
		.object({
			allowExtendAfterTime: z.string().optional(),
		})
		.optional(),
	offerDetails: z
		.object({
			basePlanId: z.string().optional(),
			offerId: z.string().optional(),
			offerTags: z.array(z.string()).optional(),
		})
		.optional(),
	deferredItemReplacement: z
		.object({
			productId: z.string().optional(),
		})
		.optional(),
});

const SubscriptionPurchaseV2Schema = z.object({
	kind: z.string().optional(),
	regionCode: z.string().optional(),
	lineItems: z.array(SubscriptionLineItemSchema).optional(),
	startTime: z.string().optional(),
	subscriptionState: z.string().optional(),
	latestOrderId: z.string().optional(),
	linkedPurchaseToken: z.string().optional(),
	pausedStateContext: z
		.object({
			autoResumeTime: z.string().optional(),
		})
		.optional(),
	canceledStateContext: z
		.object({
			userInitiatedCancellation: z.object({cancelTime: z.string().optional()}).optional(),
			systemInitiatedCancellation: z.object({}).optional(),
			developerInitiatedCancellation: z.object({}).optional(),
			replacementCancellation: z.object({}).optional(),
		})
		.optional(),
	testPurchase: z.object({}).optional(),
	acknowledgementState: z.string().optional(),
	externalAccountIdentifiers: ExternalAccountIdentifiersSchema.optional(),
	outOfAppPurchaseContext: z
		.object({
			expiredExternalAccountIdentifiers: ExternalAccountIdentifiersSchema.optional(),
			expiredPurchaseToken: z.string().optional(),
		})
		.optional(),
	etag: z.string().optional(),
});

export type SubscriptionPurchaseV2 = z.infer<typeof SubscriptionPurchaseV2Schema>;
export type SubscriptionPurchaseLineItem = z.infer<typeof SubscriptionLineItemSchema>;

const ProductLineItemSchema = z.object({
	productId: z.string(),
	productOfferDetails: z
		.object({
			offerId: z.string().optional(),
			purchaseOptionId: z.string().optional(),
			quantity: z.number().int().optional(),
			refundableQuantity: z.number().int().optional(),
			consumptionState: z.string().optional(),
		})
		.optional(),
});

const ProductPurchaseV2Schema = z.object({
	kind: z.string().optional(),
	productLineItem: z.array(ProductLineItemSchema).optional(),
	purchaseStateContext: z
		.object({
			purchaseState: z.string().optional(),
		})
		.optional(),
	testPurchaseContext: z
		.object({
			fopType: z.string().optional(),
		})
		.optional(),
	orderId: z.string().optional(),
	obfuscatedExternalAccountId: z.string().optional(),
	obfuscatedExternalProfileId: z.string().optional(),
	regionCode: z.string().optional(),
	purchaseCompletionTime: z.string().optional(),
	acknowledgementState: z.string().optional(),
});

export type ProductPurchaseV2 = z.infer<typeof ProductPurchaseV2Schema>;

const VoidedPurchaseSchema = z.object({
	kind: z.string().optional(),
	purchaseToken: z.string(),
	purchaseTimeMillis: z.string().optional(),
	voidedTimeMillis: z.string().optional(),
	orderId: z.string().optional(),
	voidedSource: z.number().int().optional(),
	voidedReason: z.number().int().optional(),
	voidedQuantity: z.number().int().optional(),
});

export type GooglePlayVoidedPurchase = z.infer<typeof VoidedPurchaseSchema>;

const VoidedPurchasesResponseSchema = z.object({
	voidedPurchases: z.array(VoidedPurchaseSchema).optional(),
	tokenPagination: z
		.object({
			nextPageToken: z.string().optional(),
		})
		.optional(),
});

const GoogleErrorBodySchema = z.object({
	error: z.object({
		code: z.number().optional(),
		message: z.string().optional(),
		status: z.string().optional(),
		errors: z.array(z.object({reason: z.string().optional()})).optional(),
	}),
});

export type GooglePlayCancellationType = 'USER_REQUESTED_STOP_RENEWALS' | 'DEVELOPER_REQUESTED_STOP_PAYMENTS';

export interface GooglePlayAcknowledgeOptions {
	obfuscatedAccountId?: string;
}

export interface ListGooglePlayVoidedPurchasesParams {
	startTime: Date;
	endTime?: Date;
	pageToken?: string;
	maxResults?: number;
}

export interface GooglePlayVoidedPurchasesPage {
	voidedPurchases: Array<GooglePlayVoidedPurchase>;
	nextPageToken: string | null;
}

interface GooglePlayDeveloperApiClientOptions {
	accessTokenProvider: GooglePlayAccessTokenProvider;
	baseUrl?: string;
	timeoutMs?: number;
	now?: () => number;
}

interface RequestParams {
	method: 'GET' | 'POST';
	packageName: string;
	path: string;
	query?: Record<string, string>;
	body?: unknown;
}

function segment(value: string): string {
	return encodeURIComponent(value);
}

export class GooglePlayDeveloperApiClient {
	private readonly accessTokenProvider: GooglePlayAccessTokenProvider;
	private readonly baseUrl: string;
	private readonly timeoutMs: number;
	private readonly now: () => number;

	constructor(options: GooglePlayDeveloperApiClientOptions) {
		this.accessTokenProvider = options.accessTokenProvider;
		this.baseUrl = (options.baseUrl ?? GOOGLE_PLAY_API_BASE_URL).replace(/\/+$/u, '');
		this.timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
		this.now = options.now ?? Date.now;
	}

	async getSubscription(packageName: string, purchaseToken: string): Promise<SubscriptionPurchaseV2> {
		const body = await this.request({
			method: 'GET',
			packageName,
			path: `/purchases/subscriptionsv2/tokens/${segment(purchaseToken)}`,
		});
		return this.parse(SubscriptionPurchaseV2Schema, body, 'subscriptionsv2.get');
	}

	async cancelSubscription(
		packageName: string,
		purchaseToken: string,
		cancellationType: GooglePlayCancellationType,
	): Promise<void> {
		await this.request({
			method: 'POST',
			packageName,
			path: `/purchases/subscriptionsv2/tokens/${segment(purchaseToken)}:cancel`,
			body: {cancellationContext: {cancellationType}},
		});
	}

	async revokeSubscription(packageName: string, purchaseToken: string): Promise<void> {
		await this.request({
			method: 'POST',
			packageName,
			path: `/purchases/subscriptionsv2/tokens/${segment(purchaseToken)}:revoke`,
			body: {revocationContext: {fullRefund: {}}},
		});
	}

	async acknowledgeSubscription(
		packageName: string,
		productId: string,
		purchaseToken: string,
		options: GooglePlayAcknowledgeOptions = {},
	): Promise<void> {
		await this.request({
			method: 'POST',
			packageName,
			path: `/purchases/subscriptions/${segment(productId)}/tokens/${segment(purchaseToken)}:acknowledge`,
			body: options.obfuscatedAccountId ? {externalAccountIds: {obfuscatedAccountId: options.obfuscatedAccountId}} : {},
		});
	}

	async getProduct(packageName: string, purchaseToken: string): Promise<ProductPurchaseV2> {
		const body = await this.request({
			method: 'GET',
			packageName,
			path: `/purchases/productsv2/tokens/${segment(purchaseToken)}`,
		});
		return this.parse(ProductPurchaseV2Schema, body, 'productsv2.get');
	}

	async consumeProduct(packageName: string, productId: string, purchaseToken: string): Promise<void> {
		await this.request({
			method: 'POST',
			packageName,
			path: `/purchases/products/${segment(productId)}/tokens/${segment(purchaseToken)}:consume`,
		});
	}

	async refundOrder(packageName: string, orderId: string): Promise<void> {
		await this.request({
			method: 'POST',
			packageName,
			path: `/orders/${segment(orderId)}:refund`,
			query: {revoke: 'true'},
		});
	}

	async listVoidedPurchases(
		packageName: string,
		params: ListGooglePlayVoidedPurchasesParams,
	): Promise<GooglePlayVoidedPurchasesPage> {
		const query: Record<string, string> = {
			type: VOIDED_PURCHASE_TYPE_SUBSCRIPTIONS_AND_PRODUCTS,
			startTime: String(params.startTime.getTime()),
		};
		if (params.endTime) {
			query['endTime'] = String(params.endTime.getTime());
		}
		if (params.pageToken) {
			query['token'] = params.pageToken;
		}
		if (params.maxResults !== undefined) {
			query['maxResults'] = String(params.maxResults);
		}
		const body = await this.request({method: 'GET', packageName, path: '/purchases/voidedpurchases', query});
		const parsed = this.parse(VoidedPurchasesResponseSchema, body, 'voidedpurchases.list');
		return {
			voidedPurchases: parsed.voidedPurchases ?? [],
			nextPageToken: parsed.tokenPagination?.nextPageToken ?? null,
		};
	}

	private parse<T>(schema: z.ZodType<T>, body: unknown, operation: string): T {
		const parsed = schema.safeParse(body);
		if (!parsed.success) {
			throw new GooglePlayApiError(
				`Google Play ${operation} response is malformed`,
				'retryable',
				200,
				'malformed_response',
			);
		}
		return parsed.data;
	}

	private async request(params: RequestParams): Promise<unknown> {
		if (!isGooglePlayPackageConfigured(params.packageName)) {
			throw new GooglePlayApiError('Google Play package is not configured', 'rejected', null, 'package_not_configured');
		}
		const accessToken = await this.accessTokenProvider.getAccessToken();
		const response = await this.send(params, accessToken);
		if (response.status === 401) {
			await response.text().catch(() => '');
			this.accessTokenProvider.invalidate(accessToken);
			const retryToken = await this.accessTokenProvider.getAccessToken();
			return await this.readResponse(params, await this.send(params, retryToken));
		}
		return await this.readResponse(params, response);
	}

	private async send(params: RequestParams, accessToken: string): Promise<Response> {
		const url = new URL(`${this.baseUrl}/${segment(params.packageName)}${params.path}`);
		for (const [key, value] of Object.entries(params.query ?? {})) {
			url.searchParams.set(key, value);
		}
		try {
			return await fetch(url, {
				method: params.method,
				headers: {
					Authorization: `Bearer ${accessToken}`,
					Accept: 'application/json',
					...(params.body === undefined ? {} : {'Content-Type': 'application/json'}),
				},
				body: params.body === undefined ? undefined : JSON.stringify(params.body),
				signal: AbortSignal.timeout(this.timeoutMs),
			});
		} catch (error) {
			throw new GooglePlayApiError(
				`Google Play ${params.method} request failed: ${error instanceof Error ? error.message : String(error)}`,
				'retryable',
				null,
				'network_error',
			);
		}
	}

	private async readResponse(params: RequestParams, response: Response): Promise<unknown> {
		const text = await response.text().catch(() => '');
		let body: unknown = null;
		if (text.length > 0) {
			try {
				body = JSON.parse(text);
			} catch {
				body = null;
			}
		}
		if (response.ok) {
			return body ?? {};
		}
		const parsedError = GoogleErrorBodySchema.safeParse(body);
		const reason = parsedError.success
			? (parsedError.data.error.errors?.find((entry) => entry.reason)?.reason ?? parsedError.data.error.status ?? null)
			: null;
		throw new GooglePlayApiError(
			`Google Play ${params.method} request failed with ${response.status}`,
			classifyGooglePlayStatus(response.status),
			response.status,
			reason,
			parseRetryAfterMs(response.headers.get('retry-after'), this.now()),
		);
	}
}