// Google Play Developer API (androidpublisher v3) client: JSON + media calls with retry, and the edit lifecycle. import { playServiceAccount } from '../lib/credentials'; import { tokenSource } from '../lib/google-auth'; import { log } from '../lib/log'; export type PlayClient = Awaited>; export async function playClient(root: string, packageName: string) { const token = tokenSource(playServiceAccount(root)); const API = `https://androidpublisher.googleapis.com/androidpublisher/v3/applications/${packageName}`; const UPLOAD = `https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications/${packageName}`; /** JSON call (object body) or media upload (Uint8Array body + Content-Type). Throws with the API's text. */ async function call(method: string, url: string, body?: unknown, headers: Record = {}): Promise { const bin = body instanceof Uint8Array; for (let attempt = 0; ; attempt++) { const r = await fetch(url, { method, headers: { Authorization: 'Bearer ' + (await token()), ...(body === undefined || bin ? {} : { 'Content-Type': 'application/json' }), ...headers }, body: body === undefined ? undefined : bin ? (body as unknown as BodyInit) : JSON.stringify(body), }); const text = await r.text(); if (r.ok) return (text ? JSON.parse(text) : {}) as T; if ((r.status === 429 || r.status >= 500) && attempt < 4) { await Bun.sleep(2000 * (attempt + 1)); continue; } const short = url.replace(API, '').replace(UPLOAD, ''); // A wrong path casing answers with an HTML 404 page, not JSON: say so instead of dumping the HTML. const msg = /^\s* ${r.status} ${msg}`); } } async function editOnce(fn: (id: string) => Promise, o: { dry?: boolean; commitQuery?: string }): Promise { const e = await call<{ id: string }>('POST', `${API}/edits`, {}); log('play', `edit ${e.id} opened`); try { const out = await fn(e.id); if (o.dry) { await call('POST', `${API}/edits/${e.id}:validate`); log('play', 'dry run: edit validated, discarding'); await call('DELETE', `${API}/edits/${e.id}`); } else { await call('POST', `${API}/edits/${e.id}:commit${o.commitQuery ?? ''}`); log('play', `edit ${e.id} committed`); } return out; } catch (err) { await call('DELETE', `${API}/edits/${e.id}`).catch(() => {}); throw err; } } return { API, UPLOAD, packageName, call, /** * Opens an edit, runs fn, then commits (or validates and discards when dry). Any Console save or other edit commit * invalidates an open edit ("A change was made to the application outside of this Edit"); then the whole edit is * redone, up to `retries` times. Keep edits small (e.g. one per language for images) so a retry is cheap. */ async edit(fn: (id: string) => Promise, o: { dry?: boolean; commitQuery?: string; retries?: number } = {}): Promise { for (let left = o.retries ?? 3; ; left--) { try { return await editOnce(fn, o); } catch (err) { if (left <= 0 || !/outside of this Edit|Edit has been deleted|edit.*(expired|not found)/i.test(String(err))) throw err; log('play', `app changed outside the edit (Console?), redoing it (${left} retries left)`); } } }, }; }