eas-cli 18.5.0 → 18.7.0

package/build/metadata/apple/tasks/app-clip.js

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppClipTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const fetch_1 = tslib_1.__importDefault(require("../../../fetch"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/**
+ * Task for managing App Clip metadata (default experience, localized
+ * subtitles + header images, App Store review invocation URLs).
+ *
+ * No-op when the app does not have an App Clip target.
+ */
+class AppClipTask extends task_1.AppleTask {
+    name = () => 'app clip';
+    async prepareAsync({ context }) {
+        context.appClip = null;
+        context.appClipDefaultExperience = null;
+        context.appClipTemplateExperience = null;
+        context.appClipLocalizations = new Map();
+        context.appClipHeaderImages = new Map();
+        context.appClipReviewDetail = null;
+        const appClips = await context.app.getAppClipsAsync();
+        if (appClips.length === 0) {
+            return;
+        }
+        // Apps may have multiple App Clip bundles registered. Pick the first
+        // clip that has any default experiences attached.
+        let chosenClip = null;
+        let allExperiences = [];
+        for (const clip of appClips) {
+            const experiences = await clip.getAppClipDefaultExperiencesAsync();
+            if (experiences.length > 0) {
+                chosenClip = clip;
+                allExperiences = experiences;
+                break;
+            }
+        }
+        chosenClip ??= appClips[0];
+        context.appClip = chosenClip;
+        if (allExperiences.length === 0) {
+            return;
+        }
+        // App Clip default experiences are versioned per app store version. Find
+        // the experience linked to the current editable version. Fall back to the
+        // first experience as a template (used as the source of truth on pull
+        // when the current version has no experience yet, and as a template when
+        // creating a new experience on push).
+        const currentVersionId = context.version?.id;
+        const currentVersionExperience = currentVersionId
+            ? (allExperiences.find(exp => exp.attributes.releaseWithAppStoreVersion?.id === currentVersionId) ?? null)
+            : null;
+        context.appClipDefaultExperience = currentVersionExperience;
+        // The template is only used when we need to CREATE a new default
+        // experience for the current version on push — pick any other existing
+        // experience (most recent first by sort order). When the current version
+        // already has an experience, no template is needed.
+        context.appClipTemplateExperience = currentVersionExperience
+            ? null
+            : (allExperiences[0] ?? null);
+        // Use the current version's experience for downstream data when present;
+        // otherwise fall back to the template so `metadata:pull` still produces a
+        // populated `store.config.json`.
+        const sourceExperience = currentVersionExperience ?? context.appClipTemplateExperience;
+        if (!sourceExperience) {
+            return;
+        }
+        const [localizations, reviewDetail] = await Promise.all([
+            sourceExperience.getAppClipDefaultExperienceLocalizationsAsync(),
+            sourceExperience.getAppClipAppStoreReviewDetailAsync(),
+        ]);
+        for (const localization of localizations) {
+            context.appClipLocalizations.set(localization.attributes.locale, localization);
+        }
+        context.appClipReviewDetail = reviewDetail;
+        // Header images may be missing from the included payload depending on
+        // ASC's whims; fetch any that weren't pre-populated.
+        await Promise.all(localizations.map(async (localization) => {
+            const included = localization.attributes.appClipHeaderImage;
+            if (included) {
+                context.appClipHeaderImages.set(localization.attributes.locale, included);
+                return;
+            }
+            const headerImage = await localization.getAppClipHeaderImageAsync();
+            if (headerImage) {
+                context.appClipHeaderImages.set(localization.attributes.locale, headerImage);
+            }
+        }));
+    }
+    async downloadAsync({ config, context }) {
+        // Pull data from the current version's experience when present, otherwise
+        // fall back to the template experience. The localizations and review
+        // detail in `context` were populated from whichever was used.
+        const experience = context.appClipDefaultExperience ?? context.appClipTemplateExperience;
+        if (!experience) {
+            return;
+        }
+        config.setAppClipDefaultExperience({
+            action: experience.attributes.action ?? undefined,
+            // ASC does not expose `releaseWithAppStoreVersion` directly on the
+            // attributes — it's a relationship. We treat presence of an included
+            // version as `true`. When unset we leave the field undefined so the
+            // serializer omits it.
+            releaseWithAppStoreVersion: experience.attributes.releaseWithAppStoreVersion != null ? true : undefined,
+        });
+        const reviewDetail = context.appClipReviewDetail;
+        if (reviewDetail?.attributes.invocationUrls?.length) {
+            config.setAppClipReviewDetail({
+                invocationUrls: reviewDetail.attributes.invocationUrls,
+            });
+        }
+        else {
+            config.setAppClipReviewDetail(null);
+        }
+        for (const [locale, localization] of context.appClipLocalizations) {
+            const headerImage = context.appClipHeaderImages.get(locale);
+            let headerImagePath;
+            if (headerImage) {
+                const downloaded = await downloadAppClipHeaderImageAsync(context.projectDir, locale, headerImage);
+                if (downloaded) {
+                    headerImagePath = downloaded;
+                }
+                else {
+                    // Image exists in ASC but isn't downloadable yet (still processing,
+                    // or Apple's CDN hasn't caught up). Preserve the expected local path
+                    // so subsequent pushes don't try to delete the in-progress upload.
+                    // Filename match in syncAppClipHeaderImageAsync will skip re-upload.
+                    const fileName = headerImage.attributes.fileName || 'header.png';
+                    headerImagePath = path_1.default.join('store', 'apple', 'app-clip', locale, fileName);
+                }
+            }
+            config.setAppClipLocalizedInfo(locale, {
+                subtitle: localization.attributes.subtitle ?? undefined,
+                headerImage: headerImagePath,
+            });
+        }
+    }
+    async uploadAsync({ config, context }) {
+        const desired = config.getAppClipDefaultExperience();
+        if (!desired) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped app clip, not configured}`);
+            return;
+        }
+        if (!context.appClip) {
+            log_1.default.warn((0, chalk_1.default) `{yellow Skipping app clip - no App Clip is registered for this app in App Store Connect}`);
+            return;
+        }
+        if (!context.version) {
+            log_1.default.warn((0, chalk_1.default) `{yellow Skipping app clip - no editable app store version available}`);
+            return;
+        }
+        // App Clip default experiences are versioned per app store version. If
+        // the current editable version doesn't have one yet, create a new one,
+        // optionally cloning the most recent prior experience as a template.
+        let experience = context.appClipDefaultExperience;
+        // We always link the default experience to the current editable version,
+        // regardless of whether the user opted into `releaseWithAppStoreVersion`
+        // — every default experience must belong to a version in ASC.
+        const releaseWithAppStoreVersionId = context.version.id;
+        if (!experience) {
+            const appClipId = context.appClip.id;
+            const templateId = context.appClipTemplateExperience?.id;
+            experience = await (0, log_2.logAsync)(() => apple_utils_1.AppClipDefaultExperience.createAsync(context.app.context, {
+                appClipId,
+                releaseWithAppStoreVersionId,
+                appClipDefaultExperienceTemplateId: templateId,
+                attributes: { action: desired.action ?? null },
+            }), {
+                pending: templateId
+                    ? `Creating App Clip default experience for ${chalk_1.default.bold(context.version.attributes.versionString)} (cloned from previous version)...`
+                    : `Creating App Clip default experience for ${chalk_1.default.bold(context.version.attributes.versionString)}...`,
+                success: `Created App Clip default experience for ${chalk_1.default.bold(context.version.attributes.versionString)}`,
+                failure: `Failed creating App Clip default experience for ${chalk_1.default.bold(context.version.attributes.versionString)}`,
+            });
+            context.appClipDefaultExperience = experience;
+            // Apple cloned the previous experience's localizations + review detail
+            // into the new experience. Re-fetch them so subsequent diff/sync logic
+            // operates on the new resource ids.
+            const [localizations, reviewDetail] = await Promise.all([
+                experience.getAppClipDefaultExperienceLocalizationsAsync(),
+                experience.getAppClipAppStoreReviewDetailAsync(),
+            ]);
+            context.appClipLocalizations = new Map();
+            context.appClipHeaderImages = new Map();
+            for (const localization of localizations) {
+                context.appClipLocalizations.set(localization.attributes.locale, localization);
+                const included = localization.attributes.appClipHeaderImage;
+                if (included) {
+                    context.appClipHeaderImages.set(localization.attributes.locale, included);
+                }
+                else {
+                    const headerImage = await localization.getAppClipHeaderImageAsync();
+                    if (headerImage) {
+                        context.appClipHeaderImages.set(localization.attributes.locale, headerImage);
+                    }
+                }
+            }
+            context.appClipReviewDetail = reviewDetail;
+        }
+        else {
+            const currentAction = experience.attributes.action ?? null;
+            const desiredAction = desired.action ?? null;
+            // Apple rejects PATCHes on `action` once the linked app store version is
+            // locked (in review / released). Skip the call when nothing actually
+            // changed to avoid spurious failures on round-trip pushes.
+            if (currentAction !== desiredAction) {
+                const existing = experience;
+                experience = await (0, log_2.logAsync)(() => existing.updateAsync({
+                    action: desiredAction,
+                    releaseWithAppStoreVersionId: desired.releaseWithAppStoreVersion
+                        ? (releaseWithAppStoreVersionId ?? null)
+                        : null,
+                }), {
+                    pending: 'Updating App Clip default experience...',
+                    success: 'Updated App Clip default experience',
+                    failure: 'Failed updating App Clip default experience',
+                });
+                context.appClipDefaultExperience = experience;
+            }
+            else {
+                log_1.default.log((0, chalk_1.default) `{dim - Skipped App Clip default experience, no changes}`);
+            }
+        }
+        // Sync App Store review detail (invocation URLs).
+        const desiredReview = desired.reviewDetail;
+        if (desiredReview && desiredReview.invocationUrls.length > 0) {
+            if (context.appClipReviewDetail) {
+                const currentUrls = context.appClipReviewDetail.attributes.invocationUrls ?? [];
+                const desiredUrls = desiredReview.invocationUrls;
+                const unchanged = currentUrls.length === desiredUrls.length &&
+                    currentUrls.every((url, i) => url === desiredUrls[i]);
+                if (!unchanged) {
+                    const existingReview = context.appClipReviewDetail;
+                    context.appClipReviewDetail = await (0, log_2.logAsync)(() => existingReview.updateAsync({
+                        invocationUrls: desiredUrls,
+                    }), {
+                        pending: 'Updating App Clip review invocation URLs...',
+                        success: 'Updated App Clip review invocation URLs',
+                        failure: 'Failed updating App Clip review invocation URLs',
+                    });
+                }
+            }
+            else {
+                context.appClipReviewDetail = await (0, log_2.logAsync)(() => apple_utils_1.AppClipAppStoreReviewDetail.createAsync(context.app.context, {
+                    appClipDefaultExperienceId: experience.id,
+                    attributes: { invocationUrls: desiredReview.invocationUrls },
+                }), {
+                    pending: 'Creating App Clip review invocation URLs...',
+                    success: 'Created App Clip review invocation URLs',
+                    failure: 'Failed creating App Clip review invocation URLs',
+                });
+            }
+        }
+        else if (context.appClipReviewDetail) {
+            await (0, log_2.logAsync)(() => context.appClipReviewDetail.deleteAsync(), {
+                pending: 'Removing App Clip review invocation URLs...',
+                success: 'Removed App Clip review invocation URLs',
+                failure: 'Failed removing App Clip review invocation URLs',
+            });
+            context.appClipReviewDetail = null;
+        }
+        // Sync localizations: create/update from config, delete locales that
+        // exist in ASC but were removed from the config.
+        const desiredLocales = config.getAppClipLocales();
+        const desiredLocaleSet = new Set(desiredLocales);
+        for (const locale of desiredLocales) {
+            const desiredInfo = config.getAppClipLocalizedInfo(locale);
+            if (!desiredInfo) {
+                continue;
+            }
+            let localization = context.appClipLocalizations.get(locale);
+            if (!localization) {
+                localization = await (0, log_2.logAsync)(() => experience.createAppClipDefaultExperienceLocalizationAsync({
+                    locale,
+                    subtitle: desiredInfo.subtitle ?? null,
+                }), {
+                    pending: `Creating App Clip localization for ${chalk_1.default.bold(locale)}...`,
+                    success: `Created App Clip localization for ${chalk_1.default.bold(locale)}`,
+                    failure: `Failed creating App Clip localization for ${chalk_1.default.bold(locale)}`,
+                });
+                context.appClipLocalizations.set(locale, localization);
+            }
+            else if (localization.attributes.subtitle !== (desiredInfo.subtitle ?? null)) {
+                localization = await (0, log_2.logAsync)(() => localization.updateAsync({ subtitle: desiredInfo.subtitle ?? null }), {
+                    pending: `Updating App Clip localization for ${chalk_1.default.bold(locale)}...`,
+                    success: `Updated App Clip localization for ${chalk_1.default.bold(locale)}`,
+                    failure: `Failed updating App Clip localization for ${chalk_1.default.bold(locale)}`,
+                });
+                context.appClipLocalizations.set(locale, localization);
+            }
+            // Sync header image.
+            await syncAppClipHeaderImageAsync({
+                projectDir: context.projectDir,
+                localization,
+                existing: context.appClipHeaderImages.get(locale),
+                desiredPath: desiredInfo.headerImage,
+                onUploaded: image => context.appClipHeaderImages.set(locale, image),
+                onDeleted: () => context.appClipHeaderImages.delete(locale),
+            });
+        }
+        // Delete localizations no longer in config.
+        for (const [locale, localization] of context.appClipLocalizations) {
+            if (!desiredLocaleSet.has(locale)) {
+                await (0, log_2.logAsync)(() => localization.deleteAsync(), {
+                    pending: `Deleting App Clip localization for ${chalk_1.default.bold(locale)}...`,
+                    success: `Deleted App Clip localization for ${chalk_1.default.bold(locale)}`,
+                    failure: `Failed deleting App Clip localization for ${chalk_1.default.bold(locale)}`,
+                });
+                context.appClipLocalizations.delete(locale);
+                context.appClipHeaderImages.delete(locale);
+            }
+        }
+    }
+}
+exports.AppClipTask = AppClipTask;
+/**
+ * Upload, replace, or delete the header image for a single App Clip
+ * localization based on the desired config path.
+ */
+async function syncAppClipHeaderImageAsync({ projectDir, localization, existing, desiredPath, onUploaded, onDeleted, }) {
+    const locale = localization.attributes.locale;
+    if (!desiredPath) {
+        if (existing) {
+            await (0, log_2.logAsync)(() => existing.deleteAsync(), {
+                pending: `Deleting App Clip header image for ${chalk_1.default.bold(locale)}...`,
+                success: `Deleted App Clip header image for ${chalk_1.default.bold(locale)}`,
+                failure: `Failed deleting App Clip header image for ${chalk_1.default.bold(locale)}`,
+            });
+            onDeleted();
+        }
+        return;
+    }
+    const absolutePath = path_1.default.resolve(projectDir, desiredPath);
+    if (!fs_1.default.existsSync(absolutePath)) {
+        log_1.default.warn((0, chalk_1.default) `{yellow App Clip header image not found: ${absolutePath}}`);
+        return;
+    }
+    const fileName = path_1.default.basename(absolutePath);
+    // Skip upload if the existing image already has the same filename and is
+    // either fully processed or still being processed (i.e. anything that
+    // isn't AWAITING_UPLOAD or FAILED). Apple does not expose the original
+    // source bytes (only re-rendered copies), so we can't reliably compare
+    // file size or checksum after a round-trip pull — filename is the only
+    // stable identity available.
+    if (existing &&
+        !existing.isAwaitingUpload() &&
+        !existing.isFailed() &&
+        existing.attributes.fileName === fileName) {
+        return;
+    }
+    if (existing) {
+        await (0, log_2.logAsync)(() => existing.deleteAsync(), {
+            pending: `Replacing App Clip header image for ${chalk_1.default.bold(locale)}...`,
+            success: `Removed previous App Clip header image for ${chalk_1.default.bold(locale)}`,
+            failure: `Failed removing previous App Clip header image for ${chalk_1.default.bold(locale)}`,
+        });
+        onDeleted();
+    }
+    const uploaded = await (0, log_2.logAsync)(() => apple_utils_1.AppClipHeaderImage.uploadAsync(localization.context, {
+        id: localization.id,
+        filePath: absolutePath,
+        waitForProcessing: true,
+    }), {
+        pending: `Uploading App Clip header image ${chalk_1.default.bold(fileName)} (${locale})...`,
+        success: `Uploaded App Clip header image ${chalk_1.default.bold(fileName)} (${locale})`,
+        failure: `Failed uploading App Clip header image ${chalk_1.default.bold(fileName)} (${locale})`,
+    });
+    onUploaded(uploaded);
+}
+/**
+ * Download an App Clip header image to the local filesystem.
+ * Returns the relative path to the downloaded file, or null on failure.
+ */
+async function downloadAppClipHeaderImageAsync(projectDir, locale, headerImage) {
+    const imageUrl = headerImage.getImageAssetUrl({ type: 'png' });
+    if (!imageUrl) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Could not get download URL for App Clip header image (${locale})}`);
+        return null;
+    }
+    const targetDir = path_1.default.join(projectDir, 'store', 'apple', 'app-clip', locale);
+    await fs_1.default.promises.mkdir(targetDir, { recursive: true });
+    const fileName = headerImage.attributes.fileName || 'header.png';
+    const outputPath = path_1.default.join(targetDir, fileName);
+    const relativePath = path_1.default.relative(projectDir, outputPath);
+    try {
+        const response = await (0, fetch_1.default)(imageUrl);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const buffer = await response.buffer();
+        await fs_1.default.promises.writeFile(outputPath, buffer);
+        log_1.default.log((0, chalk_1.default) `{dim Downloaded App Clip header image: ${relativePath}}`);
+        return relativePath;
+    }
+    catch (error) {
+        log_1.default.warn((0, chalk_1.default) `{yellow Failed to download App Clip header image (${locale}): ${error.message}}`);
+        return null;
+    }
+}

package/build/metadata/apple/tasks/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createAppleTasks = createAppleTasks;
 const age_rating_1 = require("./age-rating");
+const app_clip_1 = require("./app-clip");
 const app_info_1 = require("./app-info");
 const app_review_detail_1 = require("./app-review-detail");
 const app_version_1 = require("./app-version");
@@ -18,5 +19,6 @@ function createAppleTasks({ version } = {}) {
         new app_review_detail_1.AppReviewDetailTask(),
         new screenshots_1.ScreenshotsTask(),
         new previews_1.PreviewsTask(),
+        new app_clip_1.AppClipTask(),
     ];
 }

package/build/metadata/apple/tasks/previews.js

@@ -60,18 +60,22 @@ class PreviewsTask extends task_1.AppleTask {
                 // For now, we only handle the first preview per set (App Store allows up to 3)
                 // We can extend this later to support multiple previews
                 const preview = previewModels[0];
-                const relativePath = await downloadPreviewAsync(context.projectDir, localeCode, previewType, preview, 0);
-                if (relativePath) {
-                    // Include preview frame time code if available
-                    if (preview.attributes.previewFrameTimeCode) {
-                        previews[previewType] = {
-                            path: relativePath,
-                            previewFrameTimeCode: preview.attributes.previewFrameTimeCode,
-                        };
-                    }
-                    else {
-                        previews[previewType] = relativePath;
-                    }
+                const downloaded = await downloadPreviewAsync(context.projectDir, localeCode, previewType, preview, 0);
+                // When the download succeeds, write the real path. When it fails
+                // (e.g. the preview is in a broken AWAITING_UPLOAD state with no
+                // rendered videoUrl), preserve the entry in config so the user can
+                // either drop in a replacement file or remove the entry to delete
+                // the broken ASC record.
+                const fileName = preview.attributes.fileName || 'preview.mp4';
+                const relativePath = downloaded || path_1.default.join('store', 'apple', 'preview', localeCode, previewType, fileName);
+                if (preview.attributes.previewFrameTimeCode) {
+                    previews[previewType] = {
+                        path: relativePath,
+                        previewFrameTimeCode: preview.attributes.previewFrameTimeCode,
+                    };
+                }
+                else {
+                    previews[previewType] = relativePath;
                 }
             }
             if (Object.keys(previews).length > 0) {

package/build/metadata/apple/tasks/screenshots.js

@@ -48,14 +48,25 @@ class ScreenshotsTask extends task_1.AppleTask {
                 if (!screenshotModels || screenshotModels.length === 0) {
                     continue;
                 }
-                // Download screenshots and save to local filesystem
+                // Download screenshots and save to local filesystem. When a screenshot
+                // is in a broken state (AWAITING_UPLOAD with no rendered imageAsset)
+                // the download will fail, but we still preserve the entry pointing at
+                // its expected local path so users can either drop in a replacement
+                // file or remove the entry to delete the broken ASC record.
                 const paths = [];
                 for (let i = 0; i < screenshotModels.length; i++) {
                     const screenshot = screenshotModels[i];
-                    const relativePath = await downloadScreenshotAsync(context.projectDir, localeCode, displayType, screenshot, i);
-                    if (relativePath) {
-                        paths.push(relativePath);
+                    const downloaded = await downloadScreenshotAsync(context.projectDir, localeCode, displayType, screenshot, i);
+                    if (downloaded) {
+                        paths.push(downloaded);
+                        continue;
                     }
+                    // Fall back to a placeholder path so the entry isn't lost from
+                    // config. Push will detect that the existing screenshot isn't
+                    // complete and either re-upload (if a local file exists at this
+                    // path) or warn and skip (if it doesn't).
+                    const fileName = screenshot.attributes.fileName || `${String(i + 1).padStart(2, '0')}.png`;
+                    paths.push(path_1.default.join('store', 'apple', 'screenshot', localeCode, displayType, fileName));
                 }
                 if (paths.length > 0) {
                     screenshots[displayType] = paths;

package/build/metadata/apple/types.d.ts

@@ -1,4 +1,4 @@
-import type { AgeRatingDeclarationProps, PreviewType, ScreenshotDisplayType } from '@expo/apple-utils';
+import type { AgeRatingDeclarationProps, AppClipAction, PreviewType, ScreenshotDisplayType } from '@expo/apple-utils';
 export type AppleLocale = string;
 /** Screenshot display type enum values from App Store Connect API */
 export type AppleScreenshotDisplayType = `${ScreenshotDisplayType}`;
@@ -38,6 +38,33 @@ export interface AppleMetadata {
     /** @deprecated Use screenshots/previews in AppleInfo instead */
     preview?: Record<string, string[]>;
     review?: AppleReview;
+    /** App Clip metadata. Only applies to apps that ship an App Clip target. */
+    appClip?: AppleAppClip;
+}
+/** App Clip action enum values from App Store Connect API */
+export type AppleAppClipAction = `${AppClipAction}`;
+export interface AppleAppClip {
+    /** The default experience for this App Clip. There is exactly one per app. */
+    defaultExperience?: AppleAppClipDefaultExperience;
+}
+export interface AppleAppClipDefaultExperience {
+    /** Action button shown in the App Clip card. Defaults to OPEN if unset. */
+    action?: AppleAppClipAction;
+    /** Whether to release this default experience alongside the next App Store version. */
+    releaseWithAppStoreVersion?: boolean;
+    /** App Store review invocation URLs (used by App Review to launch the clip). */
+    reviewDetail?: AppleAppClipReviewDetail;
+    /** Per-locale subtitle and header image. */
+    info?: Record<AppleLocale, AppleAppClipLocalizedInfo>;
+}
+export interface AppleAppClipReviewDetail {
+    invocationUrls: string[];
+}
+export interface AppleAppClipLocalizedInfo {
+    /** Subtitle shown in the App Clip card. Apple limits this to 43 characters. */
+    subtitle?: string;
+    /** Relative path (from project root) to the App Clip header image PNG. */
+    headerImage?: string;
 }
 export type AppleAdvisory = Omit<Partial<AgeRatingDeclarationProps>, 'seventeenPlus' | 'gamblingAndContests'>;
 /** Apps can define up to two categories, or categories with up to two subcategories */

package/build/observe/fetchEvents.d.ts

@@ -0,0 +1,27 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppObserveEvent, AppObserveEventsOrderBy, AppObservePlatform, AppPlatform, PageInfo } from '../graphql/generated';
+export declare enum EventsOrderPreset {
+    Slowest = "SLOWEST",
+    Fastest = "FASTEST",
+    Newest = "NEWEST",
+    Oldest = "OLDEST"
+}
+export declare function resolveOrderBy(input: string): AppObserveEventsOrderBy;
+interface FetchObserveEventsOptions {
+    metricName: string;
+    orderBy: AppObserveEventsOrderBy;
+    limit: number;
+    after?: string;
+    startTime: string;
+    endTime: string;
+    platform?: AppObservePlatform;
+    appVersion?: string;
+    updateId?: string;
+}
+interface FetchObserveEventsResult {
+    events: AppObserveEvent[];
+    pageInfo: PageInfo;
+}
+export declare function fetchObserveEventsAsync(graphqlClient: ExpoGraphqlClient, appId: string, options: FetchObserveEventsOptions): Promise<FetchObserveEventsResult>;
+export declare function fetchTotalEventCountAsync(graphqlClient: ExpoGraphqlClient, appId: string, metricName: string, platforms: AppPlatform[], startTime: string, endTime: string): Promise<number>;
+export {};

package/build/observe/fetchEvents.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventsOrderPreset = void 0;
+exports.resolveOrderBy = resolveOrderBy;
+exports.fetchObserveEventsAsync = fetchObserveEventsAsync;
+exports.fetchTotalEventCountAsync = fetchTotalEventCountAsync;
+const generated_1 = require("../graphql/generated");
+const ObserveQuery_1 = require("../graphql/queries/ObserveQuery");
+var EventsOrderPreset;
+(function (EventsOrderPreset) {
+    EventsOrderPreset["Slowest"] = "SLOWEST";
+    EventsOrderPreset["Fastest"] = "FASTEST";
+    EventsOrderPreset["Newest"] = "NEWEST";
+    EventsOrderPreset["Oldest"] = "OLDEST";
+})(EventsOrderPreset || (exports.EventsOrderPreset = EventsOrderPreset = {}));
+function resolveOrderBy(input) {
+    const preset = input.toUpperCase();
+    switch (preset) {
+        case EventsOrderPreset.Slowest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.MetricValue,
+                direction: generated_1.AppObserveEventsOrderByDirection.Desc,
+            };
+        case EventsOrderPreset.Fastest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.MetricValue,
+                direction: generated_1.AppObserveEventsOrderByDirection.Asc,
+            };
+        case EventsOrderPreset.Newest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.Timestamp,
+                direction: generated_1.AppObserveEventsOrderByDirection.Desc,
+            };
+        case EventsOrderPreset.Oldest:
+            return {
+                field: generated_1.AppObserveEventsOrderByField.Timestamp,
+                direction: generated_1.AppObserveEventsOrderByDirection.Asc,
+            };
+    }
+}
+async function fetchObserveEventsAsync(graphqlClient, appId, options) {
+    const filter = {
+        metricName: options.metricName,
+        startTime: options.startTime,
+        endTime: options.endTime,
+        ...(options.platform && { platform: options.platform }),
+        ...(options.appVersion && { appVersion: options.appVersion }),
+        ...(options.updateId && { appUpdateId: options.updateId }),
+    };
+    return await ObserveQuery_1.ObserveQuery.eventsAsync(graphqlClient, {
+        appId,
+        filter,
+        first: options.limit,
+        ...(options.after && { after: options.after }),
+        orderBy: options.orderBy,
+    });
+}
+const appPlatformToObservePlatform = {
+    [generated_1.AppPlatform.Android]: generated_1.AppObservePlatform.Android,
+    [generated_1.AppPlatform.Ios]: generated_1.AppObservePlatform.Ios,
+};
+async function fetchTotalEventCountAsync(graphqlClient, appId, metricName, platforms, startTime, endTime) {
+    const queries = platforms.map(async (appPlatform) => {
+        try {
+            const versions = await ObserveQuery_1.ObserveQuery.appVersionsAsync(graphqlClient, {
+                appId,
+                platform: appPlatformToObservePlatform[appPlatform],
+                startTime,
+                endTime,
+                metricNames: [metricName],
+            });
+            return versions.reduce((sum, v) => {
+                const metric = v.metrics.find(m => m.metricName === metricName);
+                return sum + (metric?.eventCount ?? 0);
+            }, 0);
+        }
+        catch {
+            return 0;
+        }
+    });
+    const counts = await Promise.all(queries);
+    return counts.reduce((a, b) => a + b, 0);
+}

package/build/observe/fetchMetrics.d.ts

@@ -0,0 +1,11 @@
+import { ExpoGraphqlClient } from '../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppPlatform } from '../graphql/generated';
+import { BuildNumbersMap, ObserveMetricsMap, UpdateIdsMap } from './formatMetrics';
+export declare function validateDateFlag(value: string, flagName: string): void;
+export interface FetchObserveMetricsResult {
+    metricsMap: ObserveMetricsMap;
+    buildNumbersMap: BuildNumbersMap;
+    updateIdsMap: UpdateIdsMap;
+    totalEventCounts: Map<string, number>;
+}
+export declare function fetchObserveMetricsAsync(graphqlClient: ExpoGraphqlClient, appId: string, metricNames: string[], platforms: AppPlatform[], startTime: string, endTime: string): Promise<FetchObserveMetricsResult>;