storemeta 0.1.0

package/dist/cli/metadata-push.js

@@ -0,0 +1,95 @@
+import { dirname, resolve } from "node:path";
+import { StoremetaError } from "./errors.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createAppStoreConnectClient } from "../platforms/apple/client.js";
+import { createMissingAppleAppInfoLocalizations, createMissingAppleAppStoreVersionLocalizations, loadAppleMetadataDocuments, resolveAppleAppInfoResource, resolveEditableAppleAppStoreVersionResource, updateExistingAppleAppInfoLocalizations, updateExistingAppleAppStoreVersionLocalizations, } from "../platforms/apple/metadata/push.js";
+import { createGooglePlayClient } from "../platforms/google/client.js";
+import { withGoogleEditSession } from "../platforms/google/edits.js";
+import { loadGoogleMetadataDocuments, mapGoogleMetadataDocuments, uploadGoogleListings, } from "../platforms/google/metadata/push.js";
+import { createCommandContext } from "./context.js";
+function filterLocalizedDocumentsByLocale(documents, locale) {
+    if (locale === undefined) {
+        return documents;
+    }
+    const normalizedLocale = normalizeLocaleCode(locale);
+    return documents.filter((document) => normalizeLocaleCode(document.locale) === normalizedLocale);
+}
+function createSuccessSummary(results) {
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}
+export async function runMetadataPushCommand(options) {
+    const context = await createCommandContext(options);
+    const app = context.app;
+    const selectedPlatforms = resolveSelectedPlatforms(app, context.platform);
+    const metadataBaseDir = resolve(dirname(context.configPath), app.settings.metadata.baseDir);
+    const results = [];
+    for (const platform of selectedPlatforms) {
+        if (platform === "apple") {
+            const appleSettings = app.settings.apple;
+            if (appleSettings === undefined) {
+                throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define App Store Connect settings`);
+            }
+            const documents = filterLocalizedDocumentsByLocale(await loadAppleMetadataDocuments(metadataBaseDir), context.locale);
+            results.push(...documents.map((document) => ({
+                target: `apple/${document.locale}`,
+                success: true,
+                message: context.dryRun ? "Would sync Apple metadata" : "Synced Apple metadata",
+            })));
+            if (context.dryRun) {
+                for (const document of documents) {
+                    console.log(`DRY RUN apple metadata ${document.locale}`);
+                }
+                continue;
+            }
+            for (const document of documents) {
+                console.log(`Syncing apple metadata ${document.locale}`);
+            }
+            const client = createAppStoreConnectClient(appleSettings.credentials);
+            const appInfo = await resolveAppleAppInfoResource(client, appleSettings.appId);
+            const editableVersion = await resolveEditableAppleAppStoreVersionResource(client, appleSettings.appId);
+            await updateExistingAppleAppInfoLocalizations(client, appInfo.id, documents);
+            await createMissingAppleAppInfoLocalizations(client, appInfo.id, documents);
+            await updateExistingAppleAppStoreVersionLocalizations(client, editableVersion.id, documents);
+            await createMissingAppleAppStoreVersionLocalizations(client, editableVersion.id, documents);
+            for (const document of documents) {
+                console.log(`Synced apple metadata ${document.locale}`);
+            }
+            continue;
+        }
+        const googleSettings = app.settings.google;
+        if (googleSettings === undefined) {
+            throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define Google Play settings`);
+        }
+        const documents = filterLocalizedDocumentsByLocale(await loadGoogleMetadataDocuments(metadataBaseDir), context.locale);
+        const updates = mapGoogleMetadataDocuments(documents);
+        results.push(...updates.map((update) => ({
+            target: `google/${update.language}`,
+            success: true,
+            message: context.dryRun
+                ? "Would upload listing metadata"
+                : "Uploaded listing metadata",
+        })));
+        if (context.dryRun) {
+            for (const update of updates) {
+                console.log(`DRY RUN google metadata ${update.language}`);
+            }
+            continue;
+        }
+        const client = createGooglePlayClient(googleSettings.credentials);
+        await withGoogleEditSession(client, googleSettings.packageName, async (edit) => {
+            await uploadGoogleListings(client, googleSettings.packageName, edit.id, updates, {
+                onUploaded: (update) => {
+                    console.log(`Uploaded google metadata ${update.language}`);
+                },
+            });
+        });
+    }
+    return createSuccessSummary(results);
+}

package/dist/cli/render.js

@@ -0,0 +1,57 @@
+import { StoremetaError } from "./errors.js";
+function renderStatusLabel(success) {
+    return success ? "OK" : "ERR";
+}
+function renderCause(cause) {
+    if (cause instanceof Error) {
+        return `${cause.name}: ${cause.message}`;
+    }
+    if (typeof cause === "string") {
+        return cause;
+    }
+    return undefined;
+}
+function renderErrorLabel(error) {
+    switch (error.code) {
+        case "CONFIG_ERROR":
+            return "Config error";
+        case "AUTH_ERROR":
+            return "Auth error";
+        case "VALIDATION_ERROR":
+            return "Validation error";
+        case "API_ERROR":
+            return "API error";
+        case "FILESYSTEM_ERROR":
+            return "Filesystem error";
+    }
+}
+export function renderCommandSummary(summary) {
+    const lines = [
+        "Command Summary",
+        `Status: ${summary.status}`,
+        `Succeeded: ${summary.successCount}`,
+        `Failed: ${summary.failureCount}`,
+        `Skipped: ${summary.skippedCount}`,
+    ];
+    if (summary.results.length > 0) {
+        lines.push("Results:");
+        lines.push(...summary.results.map((result) => `- ${renderStatusLabel(result.success)} ${result.target}${result.message === undefined ? "" : ` - ${result.message}`}`));
+    }
+    return lines.join("\n");
+}
+export function renderCommandError(error, options) {
+    if (error instanceof StoremetaError) {
+        const lines = [`${renderErrorLabel(error)}: ${error.message}`];
+        if (options?.verbose) {
+            const cause = renderCause(error.cause);
+            if (cause !== undefined) {
+                lines.push(`Cause: ${cause}`);
+            }
+        }
+        return lines.join("\n");
+    }
+    if (error instanceof Error) {
+        return options?.verbose ? `${error.name}: ${error.message}` : error.message;
+    }
+    return "An unknown error occurred";
+}

package/dist/cli/result-types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/scaffold.js

@@ -0,0 +1,76 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createCommandContext } from "./context.js";
+const DEFAULT_APPLE_SCREENSHOT_TYPES = ["APP_IPHONE_65"];
+const DEFAULT_GOOGLE_SCREENSHOT_TYPES = ["phoneScreenshots"];
+async function writeFileIfMissing(filePath, contents) {
+    try {
+        await writeFile(filePath, contents, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        return true;
+    }
+    catch (cause) {
+        if (typeof cause === "object" &&
+            cause !== null &&
+            "code" in cause &&
+            cause.code === "EEXIST") {
+            return false;
+        }
+        throw cause;
+    }
+}
+function defaultLocalesForPlatform(context, platform) {
+    const configuredLocales = platform === "apple"
+        ? context.app.settings.apple?.locales?.default
+        : context.app.settings.google?.locales?.default;
+    return (configuredLocales ?? ["en-US"]).map(normalizeLocaleCode);
+}
+function screenshotTypesForPlatform(platform) {
+    return platform === "apple"
+        ? DEFAULT_APPLE_SCREENSHOT_TYPES
+        : DEFAULT_GOOGLE_SCREENSHOT_TYPES;
+}
+function renderMetadataSeed(locale) {
+    return `locale: ${locale}\n`;
+}
+export async function runScaffoldCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const projectRoot = dirname(context.configPath);
+    const metadataBaseDir = resolve(projectRoot, context.app.settings.metadata.baseDir);
+    const screenshotsBaseDir = resolve(projectRoot, context.app.settings.screenshots.baseDir);
+    const results = [];
+    for (const platform of platforms) {
+        const locales = defaultLocalesForPlatform(context, platform);
+        for (const locale of locales) {
+            const metadataPath = join(metadataBaseDir, platform, `${locale}.yml`);
+            await mkdir(dirname(metadataPath), { recursive: true });
+            const createdMetadata = await writeFileIfMissing(metadataPath, renderMetadataSeed(locale));
+            results.push({
+                target: `metadata/${platform}/${locale}.yml`,
+                success: true,
+                message: createdMetadata ? "Created metadata file" : "Metadata file exists",
+            });
+            for (const screenshotType of screenshotTypesForPlatform(platform)) {
+                const screenshotDir = join(screenshotsBaseDir, platform, locale, screenshotType);
+                await mkdir(screenshotDir, { recursive: true });
+                results.push({
+                    target: `screenshots/${platform}/${locale}/${screenshotType}`,
+                    success: true,
+                    message: "Ensured screenshot directory",
+                });
+            }
+        }
+    }
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}

package/dist/cli/screenshots-diff.js

@@ -0,0 +1,65 @@
+import { readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createCommandContext } from "./context.js";
+async function listLocalScreenshotLocales(platformDir) {
+    try {
+        const entries = await readdir(platformDir, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => normalizeLocaleCode(entry.name))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+}
+async function countScreenshotSets(platformDir, locale) {
+    try {
+        const entries = await readdir(join(platformDir, locale), { withFileTypes: true });
+        return entries.filter((entry) => entry.isDirectory()).length;
+    }
+    catch {
+        return 0;
+    }
+}
+function expectedLocalesForPlatform(context, platform) {
+    const locales = platform === "apple"
+        ? context.app.settings.apple?.locales?.default
+        : context.app.settings.google?.locales?.default;
+    return (locales ?? []).map(normalizeLocaleCode).sort((left, right) => left.localeCompare(right));
+}
+export async function runScreenshotsDiffCommand(options) {
+    const context = await createCommandContext(options);
+    const platforms = resolveSelectedPlatforms(context.app, context.platform);
+    const screenshotsBaseDir = resolve(dirname(context.configPath), context.app.settings.screenshots.baseDir);
+    const results = [];
+    for (const platform of platforms) {
+        const platformDir = resolve(screenshotsBaseDir, platform);
+        const expected = expectedLocalesForPlatform(context, platform);
+        const actual = await listLocalScreenshotLocales(platformDir);
+        const missing = expected.filter((locale) => !actual.includes(locale));
+        const setCounts = await Promise.all(actual.map(async (locale) => `${locale}:${await countScreenshotSets(platformDir, locale)}`));
+        results.push({
+            target: `screenshots.${platform}`,
+            success: missing.length === 0,
+            message: [
+                `local locales: ${actual.length === 0 ? "none" : actual.join(", ")}`,
+                setCounts.length === 0 ? undefined : `sets: ${setCounts.join(", ")}`,
+                expected.length === 0 ? "expected: not configured" : `expected: ${expected.join(", ")}`,
+                missing.length === 0 ? undefined : `missing: ${missing.join(", ")}`,
+            ]
+                .filter((part) => part !== undefined)
+                .join("; "),
+        });
+    }
+    const failureCount = results.filter((result) => !result.success).length;
+    return {
+        status: failureCount === 0 ? "success" : "partial",
+        successCount: results.length - failureCount,
+        failureCount,
+        skippedCount: 0,
+        results,
+    };
+}

package/dist/cli/screenshots-pull.js

@@ -0,0 +1,72 @@
+import { dirname, resolve } from "node:path";
+import { StoremetaError } from "./errors.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { normalizeLocaleCode } from "../locales/normalize.js";
+import { createAppStoreConnectClient } from "../platforms/apple/client.js";
+import { downloadAppleScreenshotSet, fetchAppleScreenshotLocalizations, fetchAppleScreenshotsForSets, fetchAppleScreenshotSetsForLocalizations, filterAppleScreenshotLocalizationsByLocale, } from "../platforms/apple/screenshots/pull.js";
+import { createGooglePlayClient } from "../platforms/google/client.js";
+import { withGoogleEditSession } from "../platforms/google/edits.js";
+import { downloadGoogleScreenshotSet, expandGoogleScreenshotPullLocales, listGoogleImagesForLocalesAndTypes, } from "../platforms/google/screenshots/pull.js";
+import { GOOGLE_SCREENSHOT_IMAGE_TYPES } from "../platforms/google/screenshots/types.js";
+import { createCommandContext } from "./context.js";
+function createSuccessSummary(results) {
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}
+export async function runScreenshotsPullCommand(options) {
+    const context = await createCommandContext(options);
+    const app = context.app;
+    const selectedPlatforms = resolveSelectedPlatforms(app, context.platform);
+    const screenshotsBaseDir = resolve(dirname(context.configPath), app.settings.screenshots.baseDir);
+    const results = [];
+    for (const platform of selectedPlatforms) {
+        if (platform === "apple") {
+            const appleSettings = app.settings.apple;
+            if (appleSettings === undefined) {
+                throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define App Store Connect settings`);
+            }
+            const client = createAppStoreConnectClient(appleSettings.credentials);
+            const localizations = filterAppleScreenshotLocalizationsByLocale(await fetchAppleScreenshotLocalizations(client, appleSettings.appId), context.locale);
+            const screenshotSetsByLocalization = await fetchAppleScreenshotSetsForLocalizations(client, localizations);
+            const screenshotSets = await fetchAppleScreenshotsForSets(client, screenshotSetsByLocalization);
+            for (const screenshotSet of screenshotSets) {
+                const downloadedSet = await downloadAppleScreenshotSet(screenshotsBaseDir, screenshotSet);
+                console.log(`Pulled apple screenshots ${downloadedSet.locale}/${downloadedSet.assetType} (${downloadedSet.files.length} files)`);
+                results.push({
+                    target: `apple/${downloadedSet.locale}/${downloadedSet.assetType}`,
+                    success: true,
+                    message: `Pulled ${downloadedSet.files.length} screenshots`,
+                });
+            }
+            continue;
+        }
+        const googleSettings = app.settings.google;
+        if (googleSettings === undefined) {
+            throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define Google Play settings`);
+        }
+        const locales = expandGoogleScreenshotPullLocales(context.locale === undefined
+            ? (googleSettings.locales?.default ?? []).map(normalizeLocaleCode)
+            : [context.locale], googleSettings.screenshots);
+        const client = createGooglePlayClient(googleSettings.credentials);
+        await withGoogleEditSession(client, googleSettings.packageName, async (edit) => {
+            const screenshotSets = await listGoogleImagesForLocalesAndTypes(client, googleSettings.packageName, edit.id, locales, GOOGLE_SCREENSHOT_IMAGE_TYPES);
+            for (const screenshotSet of screenshotSets) {
+                const downloadedSet = await downloadGoogleScreenshotSet(screenshotsBaseDir, screenshotSet);
+                console.log(`Pulled google screenshots ${downloadedSet.locale}/${downloadedSet.assetType} (${downloadedSet.files.length} files)`);
+                results.push({
+                    target: `google/${downloadedSet.locale}/${downloadedSet.assetType}`,
+                    success: true,
+                    message: `Pulled ${downloadedSet.files.length} screenshots`,
+                });
+            }
+        }, {
+            autoCommit: false,
+        });
+    }
+    return createSuccessSummary(results);
+}

package/dist/cli/screenshots-push.js

@@ -0,0 +1,96 @@
+import { dirname, resolve } from "node:path";
+import { StoremetaError } from "./errors.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { createAppStoreConnectClient } from "../platforms/apple/client.js";
+import { clearAppleScreenshotUploadTargets, commitAppleScreenshotUploads, loadAppleScreenshotSets, reserveAppleScreenshotUploads, resolveOrCreateAppleScreenshotLocalizations, resolveOrCreateAppleScreenshotUploadTargets, uploadReservedAppleScreenshots, } from "../platforms/apple/screenshots/push.js";
+import { createGooglePlayClient } from "../platforms/google/client.js";
+import { withGoogleEditSession } from "../platforms/google/edits.js";
+import { clearGoogleScreenshotTargets, loadGoogleScreenshotSets, mapGoogleScreenshotSetsToTargets, uploadGoogleScreenshotTargets, } from "../platforms/google/screenshots/push.js";
+import { createCommandContext } from "./context.js";
+function createSuccessSummary(results) {
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}
+export async function runScreenshotsPushCommand(options) {
+    const context = await createCommandContext(options);
+    const app = context.app;
+    const selectedPlatforms = resolveSelectedPlatforms(app, context.platform);
+    const screenshotsBaseDir = resolve(dirname(context.configPath), app.settings.screenshots.baseDir);
+    const selectedLocale = context.locale;
+    const results = [];
+    for (const platform of selectedPlatforms) {
+        if (platform === "apple") {
+            const appleSettings = app.settings.apple;
+            if (appleSettings === undefined) {
+                throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define App Store Connect settings`);
+            }
+            const screenshotSets = (await loadAppleScreenshotSets(screenshotsBaseDir)).filter((set) => selectedLocale === undefined || set.locale === selectedLocale);
+            results.push(...screenshotSets.map((set) => ({
+                target: `apple/${set.locale}/${set.assetType}`,
+                success: true,
+                message: context.dryRun
+                    ? `Would upload ${set.files.length} screenshots`
+                    : `Uploaded ${set.files.length} screenshots`,
+            })));
+            if (context.dryRun) {
+                for (const screenshotSet of screenshotSets) {
+                    console.log(`DRY RUN apple screenshots ${screenshotSet.locale}/${screenshotSet.assetType} (${screenshotSet.files.length} files)`);
+                }
+                continue;
+            }
+            const client = createAppStoreConnectClient(appleSettings.credentials);
+            const localizations = await resolveOrCreateAppleScreenshotLocalizations(client, appleSettings.appId, screenshotSets);
+            const uploadTargets = await resolveOrCreateAppleScreenshotUploadTargets(client, localizations, screenshotSets);
+            for (const uploadTarget of uploadTargets) {
+                if (options.replace) {
+                    console.log(`Replacing apple screenshots ${uploadTarget.locale}/${uploadTarget.assetType} by deleting existing remote screenshots`);
+                    await clearAppleScreenshotUploadTargets(client, [uploadTarget], {
+                        clearExisting: true,
+                    });
+                }
+                console.log(`Uploading apple screenshots ${uploadTarget.locale}/${uploadTarget.assetType} (${uploadTarget.files.length} files)`);
+                const reservations = await reserveAppleScreenshotUploads(client, [uploadTarget]);
+                await uploadReservedAppleScreenshots(reservations);
+                await commitAppleScreenshotUploads(client, reservations);
+                console.log(`Uploaded apple screenshots ${uploadTarget.locale}/${uploadTarget.assetType} (${uploadTarget.files.length} files)`);
+            }
+            continue;
+        }
+        const googleSettings = app.settings.google;
+        if (googleSettings === undefined) {
+            throw new StoremetaError("CONFIG_ERROR", `Configured app "${app.id}" does not define Google Play settings`);
+        }
+        const uploadTargets = mapGoogleScreenshotSetsToTargets(await loadGoogleScreenshotSets(screenshotsBaseDir), googleSettings).filter((target) => selectedLocale === undefined || target.targetLocale === selectedLocale);
+        results.push(...uploadTargets.map((target) => ({
+            target: `google/${target.targetLocale}/${target.imageType}`,
+            success: true,
+            message: context.dryRun
+                ? `Would upload ${target.files.length} screenshots`
+                : `Uploaded ${target.files.length} screenshots`,
+        })));
+        if (context.dryRun) {
+            for (const target of uploadTargets) {
+                console.log(`DRY RUN google screenshots ${target.targetLocale}/${target.imageType} (${target.files.length} files)`);
+            }
+            continue;
+        }
+        const client = createGooglePlayClient(googleSettings.credentials);
+        await withGoogleEditSession(client, googleSettings.packageName, async (edit) => {
+            if (options.replace) {
+                const clearResults = await clearGoogleScreenshotTargets(client, googleSettings.packageName, edit.id, uploadTargets, {
+                    clearExisting: true,
+                });
+                for (const clearResult of clearResults) {
+                    console.log(`Replacing google screenshots ${clearResult.targetLocale}/${clearResult.imageType} by deleting ${clearResult.deleted.length} existing screenshots`);
+                }
+            }
+            await uploadGoogleScreenshotTargets(client, googleSettings.packageName, edit.id, uploadTargets);
+        });
+    }
+    return createSuccessSummary(results);
+}

package/dist/cli/validate.js

@@ -0,0 +1,74 @@
+import { requireAppleCredentials } from "../auth/apple/load-credentials.js";
+import { requireGoogleCredentials } from "../auth/google/load-credentials.js";
+import { resolveSelectedPlatforms } from "../config/select-platforms.js";
+import { validateMetadataFiles } from "../validation/metadata/files.js";
+import { validateScreenshotFileExtensions } from "../validation/screenshots/extensions.js";
+import { validateScreenshotFolderStructure } from "../validation/screenshots/folders.js";
+import { validateScreenshotFileOrdering } from "../validation/screenshots/order.js";
+import { createCommandContext } from "./context.js";
+export async function runValidateCommand(options) {
+    const context = await createCommandContext(options);
+    const results = [
+        {
+            target: "config.root",
+            success: true,
+            message: "Root config schema is valid",
+        },
+    ];
+    const app = context.app;
+    const platforms = resolveSelectedPlatforms(app, context.platform);
+    results.push({
+        target: `app.${app.id}`,
+        success: true,
+        message: `Selected platforms: ${platforms.join(", ") || "none"}`,
+    });
+    for (const platform of platforms) {
+        if (platform === "apple" && app.settings.apple !== undefined) {
+            requireAppleCredentials(app.settings.apple.credentials);
+            results.push({
+                target: `credentials.${platform}`,
+                success: true,
+                message: "Credentials are present",
+            });
+        }
+        if (platform === "google" && app.settings.google !== undefined) {
+            requireGoogleCredentials(app.settings.google.credentials);
+            results.push({
+                target: `credentials.${platform}`,
+                success: true,
+                message: "Credentials are present",
+            });
+        }
+    }
+    await validateMetadataFiles(context.configPath, app, platforms);
+    results.push({
+        target: "metadata",
+        success: true,
+        message: "Metadata files passed validation",
+    });
+    await validateScreenshotFolderStructure(context.configPath, app, platforms);
+    results.push({
+        target: "screenshots.structure",
+        success: true,
+        message: "Screenshot folder structure is valid",
+    });
+    await validateScreenshotFileExtensions(context.configPath, app, platforms);
+    results.push({
+        target: "screenshots.extensions",
+        success: true,
+        message: "Screenshot file extensions are supported",
+    });
+    await validateScreenshotFileOrdering(context.configPath, app, platforms);
+    results.push({
+        target: "screenshots.order",
+        success: true,
+        message: "Screenshot filenames are numbered correctly",
+    });
+    return {
+        status: "success",
+        successCount: results.length,
+        failureCount: 0,
+        skippedCount: 0,
+        results,
+    };
+}