147 lines
9.6 KiB
TypeScript
147 lines
9.6 KiB
TypeScript
// Cross-store catalog parity, as pure parts: one product definition (products + subscriptions in the config) against
|
|
// what exists on the App Store and on Google Play. `storebound catalog diff` collects the store side (read-only) and
|
|
// prints these rows. Kinds compared: Apple CONSUMABLE / NON_CONSUMABLE / NON_RENEWING_SUBSCRIPTION / auto-renewable
|
|
// subscriptions; Play one-time products (every non-subscription kind) and subscriptions (base plan billing period).
|
|
import { type ShipConfig, playCodes, type ProductType, sellsOn, type Platform } from './config';
|
|
import { ALPHA3 } from './money';
|
|
import { allSubscriptions, offerId } from './subscriptions';
|
|
|
|
export type Kind = ProductType | 'subscription';
|
|
export type Store = 'apple' | 'play';
|
|
|
|
/** One product as a store has it. Prices: what applies today, one per region (ISO alpha-2), in the local currency. */
|
|
export interface StoreItem {
|
|
id: string;
|
|
/** Apple: the IAP type or subscription; Play: 'one_time' or 'subscription'. */
|
|
kind: Kind | 'one_time';
|
|
state?: string;
|
|
/** Subscriptions: ISO period (P1M ...); Apple level inside the group. */
|
|
period?: string;
|
|
level?: number;
|
|
locales: string[];
|
|
prices: { region: string; currency: string; price: number }[];
|
|
/** Offer ids (Play offer ids; Apple: "intro" when there is an introductory offer, promotional offer codes,
|
|
* "code:<name>" for offer code campaigns). */
|
|
offers?: string[];
|
|
/** Apple in-app purchases: the price schedule's base territory (region, currency) and its price today. */
|
|
base?: { region: string; currency: string; price: number };
|
|
/** The store's own USD price for regions without one of their own (Play newRegionsConfig / otherRegionsConfig). */
|
|
usd?: number;
|
|
/** Apple subscriptions: the group's reference name. */
|
|
group?: string;
|
|
}
|
|
|
|
export interface WantItem {
|
|
id: string;
|
|
kind: Kind;
|
|
stores: Store[];
|
|
period?: string;
|
|
level?: number;
|
|
usd: number;
|
|
overrides: { region: string; currency: string; price: number }[];
|
|
locales: Record<Store, string[]>;
|
|
offers: Record<Store, string[]>;
|
|
}
|
|
|
|
export interface CatalogRow { id: string; store: Store; level: 'error' | 'warn' | 'ok'; code: string; msg: string }
|
|
export interface ParityRow { id: string; region: string; currency: string; apple: number; play: number; diffPct: number }
|
|
|
|
const APPLE_PERIOD: Record<string, string> = { ONE_WEEK: 'P1W', ONE_MONTH: 'P1M', TWO_MONTHS: 'P2M', THREE_MONTHS: 'P3M', SIX_MONTHS: 'P6M', ONE_YEAR: 'P1Y' };
|
|
const APPLE_KIND: Record<string, Kind> = { CONSUMABLE: 'consumable', NON_CONSUMABLE: 'non_consumable', NON_RENEWING_SUBSCRIPTION: 'non_renewing' };
|
|
/** App Store Connect subscriptionPeriod / inAppPurchaseType -> catalog values. */
|
|
export const fromApplePeriod = (p: string | undefined): string | undefined => (p ? APPLE_PERIOD[p] ?? p : undefined);
|
|
export const fromAppleType = (t: string | undefined): Kind | 'one_time' => APPLE_KIND[t ?? ''] ?? 'one_time';
|
|
|
|
/** The config's catalog per store (products + subscriptions, `platforms` respected). */
|
|
export function wantedCatalog(config: ShipConfig): WantItem[] {
|
|
const langs = config.languages;
|
|
const appleLoc = (ids: string[]) => ids.map(id => langs.find(l => l.id === id)?.apple).filter((x): x is string => !!x);
|
|
const playLoc = (ids: string[]) => ids.flatMap(id => { const l = langs.find(x => x.id === id); return l ? playCodes(l) : []; });
|
|
const stores = (item: { platforms?: Platform[] }): Store[] => (['apple', 'play'] as const).filter(s => sellsOn(config, item, s));
|
|
const out: WantItem[] = [];
|
|
for (const p of config.products ?? []) {
|
|
const ids = Object.keys(p.listings);
|
|
out.push({ id: p.id, kind: p.type, stores: stores(p), usd: p.usd, overrides: (p.overrides ?? []).map(o => ({ region: o.region, currency: o.currency, price: o.price })),
|
|
locales: { apple: appleLoc(ids), play: playLoc(ids) }, offers: { apple: [], play: [] } });
|
|
}
|
|
for (const { sub } of allSubscriptions(config.subscriptions)) {
|
|
const ids = Object.keys(sub.listings);
|
|
out.push({ id: sub.id, kind: 'subscription', stores: stores(sub), period: sub.period, level: sub.level, usd: sub.usd,
|
|
overrides: (sub.overrides ?? []).map(o => ({ region: o.region, currency: o.currency, price: o.price })),
|
|
locales: { apple: appleLoc(ids), play: playLoc(ids) },
|
|
offers: {
|
|
apple: [...(sub.intro ? ['intro'] : []), ...(sub.offers ?? []).map(o => o.id), ...(sub.offerCodes ?? []).map(o => `code:${o.name}`)],
|
|
play: [...(sub.intro ? [offerId(sub)] : []), ...(sub.offers ?? []).map(o => o.id)],
|
|
} });
|
|
}
|
|
return out;
|
|
}
|
|
|
|
const cents = (n: number) => Math.round(n * 100);
|
|
const fmt = (n: number) => (Math.round(n * 100) / 100).toFixed(2);
|
|
|
|
/**
|
|
* Config vs both stores. `state.apple` / `state.play` null = that store was not read (no section / --store). Rows:
|
|
* missing (error), extra on the store (warn), kind / billing period (error), Apple level (warn), base price (US) and
|
|
* override regions (error), missing localizations and offers (warn). Parity: regions both stores price in the same
|
|
* currency, where the prices differ by more than `threshold` (default 10 %).
|
|
*/
|
|
export function catalogDiff(want: WantItem[], state: { apple: StoreItem[] | null; play: StoreItem[] | null }, o: { threshold?: number } = {}): { rows: CatalogRow[]; parity: ParityRow[] } {
|
|
const rows: CatalogRow[] = [];
|
|
const parity: ParityRow[] = [];
|
|
const add = (id: string, store: Store, level: CatalogRow['level'], code: string, msg: string) => rows.push({ id, store, level, code, msg });
|
|
const threshold = o.threshold ?? 0.1;
|
|
for (const store of ['apple', 'play'] as const) {
|
|
const items = state[store];
|
|
if (!items) continue;
|
|
const have = new Map(items.map(i => [i.id, i] as const));
|
|
for (const w of want.filter(x => x.stores.includes(store))) {
|
|
const h = have.get(w.id);
|
|
if (!h) { add(w.id, store, 'error', 'missing', `not on ${store === 'apple' ? 'App Store Connect' : 'Google Play'} (storebound ${store} ${w.kind === 'subscription' ? 'subscriptions' : store === 'apple' ? 'iap' : 'products'})`); continue; }
|
|
const kindOk = store === 'play' ? (w.kind === 'subscription') === (h.kind === 'subscription') : h.kind === w.kind;
|
|
if (!kindOk) { add(w.id, store, 'error', 'kind', `${h.kind} on the store, ${w.kind} in the config (a product type cannot change: use a new id)`); continue; }
|
|
if (w.period && h.period && w.period !== h.period) add(w.id, store, 'error', 'period', `bills every ${h.period} on the store, ${w.period} in the config`);
|
|
if (store === 'apple' && w.level !== undefined && h.level !== undefined && w.level !== h.level) add(w.id, store, 'warn', 'level', `group level ${h.level} on the store, ${w.level} in the config`);
|
|
const price = new Map(h.prices.map(p => [p.region, p] as const));
|
|
const us = price.get('US');
|
|
if (!h.prices.length) add(w.id, store, 'error', 'price', 'no prices on the store');
|
|
else if (!us) add(w.id, store, 'warn', 'price', 'no US price on the store');
|
|
else if (cents(us.price) !== cents(w.usd)) add(w.id, store, 'error', 'price', `US ${fmt(us.price)} USD on the store, ${fmt(w.usd)} in the config`);
|
|
for (const ov of w.overrides) {
|
|
const p = price.get(ov.region);
|
|
if (!p) add(w.id, store, 'error', 'price', `${ov.region}: no price on the store, ${ov.price} ${ov.currency} in the config`);
|
|
else if (p.currency !== ov.currency || cents(p.price) !== cents(ov.price)) add(w.id, store, 'error', 'price', `${ov.region}: ${fmt(p.price)} ${p.currency} on the store, ${fmt(ov.price)} ${ov.currency} in the config`);
|
|
}
|
|
const missingLoc = w.locales[store].filter(l => !h.locales.includes(l));
|
|
if (missingLoc.length) add(w.id, store, 'warn', 'locale', `no ${store === 'apple' ? 'localization' : 'listing'} for ${missingLoc.join(', ')}`);
|
|
const missingOffers = w.offers[store].filter(x => !(h.offers ?? []).includes(x));
|
|
if (missingOffers.length) add(w.id, store, 'warn', 'offer', `offers missing: ${missingOffers.join(', ')}`);
|
|
if (!rows.some(r => r.id === w.id && r.store === store)) add(w.id, store, 'ok', 'ok', `${w.kind}${w.period ? ` ${w.period}` : ''}, ${h.prices.length} region prices${h.state ? `, ${h.state}` : ''}`);
|
|
}
|
|
const known = new Set(want.map(w => w.id));
|
|
for (const h of items) if (!known.has(h.id)) add(h.id, store, 'warn', 'extra', `on the store but not in the config (${h.kind}${h.state ? `, ${h.state}` : ''})`);
|
|
}
|
|
if (state.apple && state.play) {
|
|
const a = new Map(state.apple.map(i => [i.id, i] as const));
|
|
const p = new Map(state.play.map(i => [i.id, i] as const));
|
|
for (const w of want) {
|
|
const ai = a.get(w.id), pi = p.get(w.id);
|
|
if (!ai || !pi) continue;
|
|
const pp = new Map(pi.prices.map(x => [x.region, x] as const));
|
|
for (const ap of ai.prices) {
|
|
const q = pp.get(ap.region);
|
|
if (!q || q.currency !== ap.currency || !(ap.price > 0) || !(q.price > 0)) continue;
|
|
const diff = Math.abs(ap.price - q.price) / Math.max(ap.price, q.price);
|
|
if (diff > threshold) parity.push({ id: w.id, region: ap.region, currency: ap.currency, apple: ap.price, play: q.price, diffPct: Math.round(diff * 1000) / 10 });
|
|
}
|
|
}
|
|
}
|
|
const rank = { error: 0, warn: 1, ok: 2 } as const;
|
|
rows.sort((x, y) => rank[x.level] - rank[y.level] || x.id.localeCompare(y.id) || x.store.localeCompare(y.store));
|
|
parity.sort((x, y) => y.diffPct - x.diffPct || x.id.localeCompare(y.id) || x.region.localeCompare(y.region));
|
|
return { rows, parity };
|
|
}
|
|
|
|
/** Apple territory (alpha-3) -> region (alpha-2). */
|
|
const A2 = Object.fromEntries(Object.entries(ALPHA3).map(([a2, a3]) => [a3, a2]));
|
|
export const regionOf = (territory: string): string => A2[territory] ?? territory;
|