@mpgd/cli 0.62.0 → 0.63.0

package/dist/store-products-command.js

@@ -0,0 +1,182 @@
+import { existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { openAscIapSession } from './app-store-iap-asc.js';
+import { planNativeDeployment } from './deploy-planning.js';
+import { readStoreCredential } from './native-deploy-run.js';
+import { readStoreProductPlanFile, readStoreProductSources, StoreProductPlanStaleError, writeStoreProductPlan, } from './store-products.js';
+import { applyAppStoreProductPlan, planAppStoreProducts, } from './store-products-app-store.js';
+import { applyPlayProductPlan, planPlayProducts, } from './store-products-play.js';
+const defaultPorts = {
+    googlePlay: loadPlayProductCatalog,
+    appStore: openAscIapSession,
+};
+export async function planStoreProducts(options, environment = process.env, ports = {}) {
+    return withStoreSession(options, environment, ports, async (session) => ({
+        schemaVersion: 1,
+        kind: 'mpgd-store-products-plan',
+        gameRoot: path.resolve(options.game),
+        profile: options.profile,
+        catalogFile: session.sources.catalogFile,
+        listingsFile: session.sources.listingsFile,
+        plan: await planWithSession(session, options),
+    }));
+}
+export function saveStoreProductPlan(file, plan) {
+    return writeStoreProductPlan(file, plan);
+}
+export async function applyStoreProducts(options, environment = process.env, ports = {}) {
+    if (!options.approved) {
+        throw new Error('Writing store products requires --approve.');
+    }
+    const saved = readSavedPlan(options.planFile);
+    const gameRoot = options.game === undefined ? saved.gameRoot : path.resolve(options.game);
+    const relocate = (file) => {
+        if (options.game === undefined) {
+            return file;
+        }
+        const relative = path.relative(saved.gameRoot, file);
+        if (relative.startsWith('..') || path.isAbsolute(relative)) {
+            throw new Error(`The saved plan reads ${file}, outside its game directory; --game cannot move it. Plan again.`);
+        }
+        return path.resolve(gameRoot, relative);
+    };
+    const planOptions = {
+        game: gameRoot,
+        profile: saved.profile,
+        store: saved.plan.store,
+        catalogFile: relocate(saved.catalogFile),
+        listingsFile: relocate(saved.listingsFile),
+        catalogTarget: saved.plan.catalogTarget,
+        keepLivePrices: saved.plan.keepLivePrices,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    };
+    return withStoreSession(planOptions, environment, ports, async (session) => {
+        const current = await planWithSession(session, planOptions);
+        if (session.store === 'google-play' && current.store === 'google-play'
+            && saved.plan.store === 'google-play') {
+            if (current.packageName !== saved.plan.packageName) {
+                throw new StoreProductPlanStaleError(`The deployment profile now names ${current.packageName}, not ${saved.plan.packageName}.`);
+            }
+            return applyPlayProductPlan({
+                saved: saved.plan,
+                current,
+                port: session.port,
+                approved: true,
+                ...(options.confirmPriceChange === true ? { confirmPriceChange: true } : {}),
+                ...(options.signal === undefined ? {} : { signal: options.signal }),
+            });
+        }
+        if (session.store === 'app-store' && current.store === 'app-store' && saved.plan.store === 'app-store') {
+            if (current.appId !== saved.plan.appId || current.bundleId !== saved.plan.bundleId) {
+                throw new StoreProductPlanStaleError(`The deployment profile now names app ${current.appId} (${current.bundleId}), not ${saved.plan.appId} (${saved.plan.bundleId}).`);
+            }
+            return applyAppStoreProductPlan({
+                saved: saved.plan,
+                current,
+                port: session.port,
+                approved: true,
+                ...(options.confirmPriceChange === true ? { confirmPriceChange: true } : {}),
+            });
+        }
+        throw new Error('Saved store product plan is malformed.');
+    });
+}
+async function withStoreSession(options, environment, overrides, action) {
+    if (options.store !== 'google-play' && options.store !== 'app-store') {
+        throw new Error('--store must be google-play or app-store.');
+    }
+    const ports = { ...defaultPorts, ...overrides };
+    const gameRoot = path.resolve(options.game);
+    const target = options.store === 'google-play' ? 'android' : 'ios';
+    const deployment = planNativeDeployment({
+        game: gameRoot,
+        profile: options.profile,
+        targets: [target],
+    });
+    const planned = deployment.targets.find((entry) => entry.target === target);
+    if (planned === undefined) {
+        throw new Error(`Deployment profile ${options.profile} has no ${target} target.`);
+    }
+    const sources = readStoreProductSources({
+        gameRoot,
+        ...(options.catalogFile === undefined ? {} : { catalogFile: options.catalogFile }),
+        ...(options.listingsFile === undefined ? {} : { listingsFile: options.listingsFile }),
+    });
+    const credential = readStoreCredential(deployment, target, environment);
+    if (credential.target === 'android') {
+        const port = await ports.googlePlay(credential.serviceAccountFile);
+        return action({ store: 'google-play', packageName: planned.appId, port, sources });
+    }
+    const session = await ports.appStore({
+        ascBinary: credential.ascBinary,
+        apiKeyId: credential.apiKeyId,
+        apiIssuerId: credential.apiIssuerId,
+        apiPrivateKeyBase64: credential.apiPrivateKeyBase64,
+    }, options.signal);
+    try {
+        return await action({
+            store: 'app-store',
+            appId: credential.appStoreAppId,
+            bundleId: planned.appId,
+            port: session.port,
+            sources,
+        });
+    }
+    finally {
+        session.close();
+    }
+}
+async function planWithSession(session, options) {
+    const common = {
+        catalog: session.sources.catalog,
+        listings: session.sources.listings,
+        ...(options.catalogTarget === undefined ? {} : { catalogTarget: options.catalogTarget }),
+        ...(options.keepLivePrices === true ? { keepLivePrices: true } : {}),
+    };
+    if (session.store === 'google-play') {
+        return planPlayProducts({
+            packageName: session.packageName,
+            ...common,
+            ...(options.signal === undefined ? {} : { signal: options.signal }),
+        }, session.port);
+    }
+    return planAppStoreProducts({
+        appId: session.appId,
+        bundleId: session.bundleId,
+        listingsDirectory: path.dirname(session.sources.listingsFile),
+        ...common,
+    }, session.port);
+}
+function readSavedPlan(file) {
+    const raw = readStoreProductPlanFile(file);
+    const plan = raw.plan;
+    const storeFields = typeof plan === 'object' && plan !== null && ((plan.store === 'google-play' && typeof plan.packageName === 'string')
+        || (plan.store === 'app-store' && typeof plan.appId === 'string' && typeof plan.bundleId === 'string'));
+    if (raw.schemaVersion !== 1 || raw.kind !== 'mpgd-store-products-plan'
+        || typeof raw.gameRoot !== 'string' || !path.isAbsolute(raw.gameRoot)
+        || typeof raw.profile !== 'string' || typeof raw.catalogFile !== 'string'
+        || typeof raw.listingsFile !== 'string' || typeof plan !== 'object' || plan === null
+        || plan.schemaVersion !== 1 || !storeFields
+        || typeof plan.catalogTarget !== 'string'
+        || typeof plan.keepLivePrices !== 'boolean' || !Array.isArray(plan.products)
+        || !plan.products.every(isSavedProduct)) {
+        throw new Error('Saved store product plan is malformed.');
+    }
+    return raw;
+}
+function isSavedProduct(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const product = value;
+    return typeof product.productId === 'string' && typeof product.action === 'string'
+        && (product.remoteSha256 === null || typeof product.remoteSha256 === 'string')
+        && typeof product.desiredSha256 === 'string';
+}
+async function loadPlayProductCatalog(serviceAccountFile) {
+    if (!existsSync(serviceAccountFile) || !statSync(serviceAccountFile).isFile()) {
+        throw new Error('Google Play service account file is missing.');
+    }
+    const { createServiceAccountProductCatalog } = await import(new URL('./play-sdk-adapter.js', import.meta.url).href);
+    return createServiceAccountProductCatalog(serviceAccountFile);
+}

package/dist/store-products-play.d.ts

@@ -0,0 +1,112 @@
+import { type ProductCatalog, type StoreListingCatalog } from '@mpgd/catalog';
+import type { PlayOneTimeProduct, PlayProductCatalogPort } from './play-product-port.js';
+import { type StoreProductAction } from './store-products.js';
+/**
+* Google Play one-time product sync: compare the game's catalog and store
+* listing file with `monetization.onetimeproducts` and plan the writes.
+*
+* - Products: https://developers.google.com/android-publisher/api-ref/rest/v3/monetization.onetimeproducts
+* - Create or update (`patch` with `allowMissing`): .../monetization.onetimeproducts/patch
+* - Activation: .../monetization.onetimeproducts.purchaseOptions/batchUpdateStates
+* - Price conversion: .../monetization/convertRegionPrices
+*
+* The plan never writes. Products only on Play are reported, never deleted;
+* listing languages, purchase options and regions the file does not name
+* are kept as they are.
+*/
+export type PlayProductChange = 'listings' | 'prices' | 'purchase-option' | 'multi-quantity' | 'tax-category' | 'activate';
+export interface PlayPriceChange {
+  /** ISO region code, or `new-regions` for Play's future-regions USD/EUR prices. */
+  readonly region: string;
+  readonly from?: string;
+  readonly to?: string;
+}
+export interface PlayProductWrite {
+  /** `onetimeproducts.patch`; absent when only an activation is planned. */
+  readonly patch?: {
+    readonly product: PlayOneTimeProduct;
+    readonly updateMask: string;
+    readonly allowMissing: boolean;
+    readonly regionsVersion: string;
+  };
+  /** Purchase option to activate after the patch (`DRAFT` or new). */
+  readonly activatePurchaseOptionId?: string;
+}
+export interface PlannedPlayProduct {
+  readonly logicalId: string;
+  readonly productId: string;
+  readonly action: StoreProductAction;
+  readonly changes: readonly PlayProductChange[];
+  readonly purchaseOptionId?: string;
+  /** The managed purchase option is `ACTIVE`: players can buy the product. */
+  readonly live: boolean;
+  /** A price of a live product changes; apply needs `--confirm-price-change`. */
+  readonly livePriceChange: boolean;
+  /** Each regional (or new-regions) price or availability that changes. */
+  readonly priceChanges: readonly PlayPriceChange[];
+  readonly notes: readonly string[];
+  /** Digest of the product as Play returned it; `null` when Play has none. */
+  readonly remoteSha256: string | null;
+  /** Digest of the planned write. */
+  readonly desiredSha256: string;
+  readonly write?: PlayProductWrite;
+}
+export interface PlayProductPlan {
+  readonly schemaVersion: 1;
+  readonly store: 'google-play';
+  readonly packageName: string;
+  readonly catalogTarget: string;
+  readonly keepLivePrices: boolean;
+  readonly products: readonly PlannedPlayProduct[];
+  /** Catalog products the sync leaves alone, with the reason. */
+  readonly skipped: readonly {
+    readonly logicalId: string;
+    readonly productId?: string;
+    readonly reason: string;
+  }[];
+  /** Product IDs on Play that no catalog product names. Never deleted. */
+  readonly remoteOnly: readonly string[];
+}
+export interface PlayProductPlanInput {
+  readonly packageName: string;
+  readonly catalog: ProductCatalog;
+  readonly listings: StoreListingCatalog;
+  /** Catalog `platformProductIds` key of Google Play; defaults to `android`. */
+  readonly catalogTarget?: string;
+  /** Leave the prices of live products as they are on Play. */
+  readonly keepLivePrices?: boolean;
+  readonly signal?: AbortSignal;
+}
+export declare function planPlayProducts(input: PlayProductPlanInput, port: PlayProductCatalogPort): Promise<PlayProductPlan>;
+export interface PlayProductApplyResult {
+  readonly packageName: string;
+  readonly products: readonly {
+    readonly productId: string;
+    readonly status: 'created' | 'updated' | 'activated' | 'unchanged';
+  }[];
+}
+export declare class PlayProductApplyError extends Error {
+  readonly productId: string;
+  readonly stage: 'patch' | 'activate';
+  /** The products already written (created, updated or activated). */
+  readonly done: PlayProductApplyResult['products'];
+  constructor(productId: string, stage: 'patch' | 'activate', 
+  /** The products already written (created, updated or activated). */
+  done: PlayProductApplyResult['products'], cause: unknown);
+}
+/**
+* Apply a reviewed plan. `current` is a fresh plan from the same inputs:
+* apply writes only when every product it would change still has the
+* remote state and the planned write the reviewer saw. A product that is
+* now unchanged (an earlier apply landed) is skipped, so a re-run is safe.
+*/
+export declare function applyPlayProductPlan(input: {
+  readonly saved: PlayProductPlan;
+  readonly current: PlayProductPlan;
+  readonly port: PlayProductCatalogPort;
+  readonly approved: boolean;
+  readonly confirmPriceChange?: boolean;
+  readonly signal?: AbortSignal;
+}): Promise<PlayProductApplyResult>;
+/** One line per product for the terminal. */
+export declare function formatPlayProductPlan(plan: PlayProductPlan): string;