@donotuse/eas-cli 18.5.0-rc.1

package/build/metadata/apple/tasks/app-review-detail.d.ts

@@ -0,0 +1,13 @@
+import { AppStoreReviewDetail } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export type AppReviewData = {
+    /** The current app info that should be edited */
+    reviewDetail: AppStoreReviewDetail;
+};
+/** Handle all contact, demo account, or instruction info that are required for the App Store review team. */
+export declare class AppReviewDetailTask extends AppleTask {
+    name: () => string;
+    prepareAsync({ context }: TaskPrepareOptions): Promise<void>;
+    downloadAsync({ config, context }: TaskDownloadOptions): Promise<void>;
+    uploadAsync({ config, context }: TaskUploadOptions): Promise<void>;
+}

package/build/metadata/apple/tasks/app-review-detail.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppReviewDetailTask = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const task_1 = require("../task");
+/** Handle all contact, demo account, or instruction info that are required for the App Store review team. */
+class AppReviewDetailTask extends task_1.AppleTask {
+    name = () => 'app review detail';
+    async prepareAsync({ context }) {
+        context.reviewDetail = (await context.version.getAppStoreReviewDetailAsync()) ?? undefined;
+    }
+    async downloadAsync({ config, context }) {
+        if (context.reviewDetail) {
+            config.setReviewDetails(context.reviewDetail.attributes);
+        }
+    }
+    async uploadAsync({ config, context }) {
+        const reviewDetail = config.getReviewDetails();
+        if (!reviewDetail) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped store review details, not configured}`);
+            return;
+        }
+        (0, assert_1.default)(context.version, `App version not initialized, can't upload store review details`);
+        const { versionString } = context.version.attributes;
+        if (!context.reviewDetail) {
+            // We can't set the demo required property when creating, omit it from the request
+            const { demoAccountRequired, ...reviewDetailsToCreate } = reviewDetail;
+            context.reviewDetail = await (0, log_2.logAsync)(() => context.version.createReviewDetailAsync(reviewDetailsToCreate), {
+                pending: `Creating store review details for ${chalk_1.default.bold(versionString)}...`,
+                success: `Created store review details for ${chalk_1.default.bold(versionString)}`,
+                failure: `Failed creating store review details for ${chalk_1.default.bold(versionString)}`,
+            });
+        }
+        context.reviewDetail = await (0, log_2.logAsync)(() => context.reviewDetail.updateAsync(reviewDetail), {
+            pending: `Updating store review details for ${chalk_1.default.bold(versionString)}...`,
+            success: `Updated store review details for ${chalk_1.default.bold(versionString)}`,
+            failure: `Failed updating store review details for ${chalk_1.default.bold(versionString)}`,
+        });
+    }
+}
+exports.AppReviewDetailTask = AppReviewDetailTask;

package/build/metadata/apple/tasks/app-version.d.ts

@@ -0,0 +1,30 @@
+import { AppStoreVersion, AppStoreVersionLocalization, AppStoreVersionPhasedRelease, Platform } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export type AppVersionOptions = {
+    /** If we should use the live version of the app (if available - defaults to false) */
+    editLive: boolean;
+    /** The platform to use (defaults to IOS) */
+    platform: Platform;
+    /** A version to create or select, if defined in the store configuration */
+    version: string | null;
+};
+export type AppVersionData = {
+    /** The current selected app store version to update */
+    version: AppStoreVersion;
+    /** If the current selected version is a live version, where not all properties are editable */
+    versionIsLive: boolean;
+    /** If the current selected version is the first version to be created */
+    versionIsFirst: boolean;
+    /** All version locales that should be, or are enabled */
+    versionLocales: AppStoreVersionLocalization[];
+    /** The (existing) phased release configuration, when set */
+    versionPhasedRelease: AppStoreVersionPhasedRelease | null;
+};
+export declare class AppVersionTask extends AppleTask {
+    private readonly options;
+    constructor(options?: Partial<AppVersionOptions>);
+    name: () => string;
+    prepareAsync({ context }: TaskPrepareOptions): Promise<void>;
+    downloadAsync({ config, context }: TaskDownloadOptions): Promise<void>;
+    uploadAsync({ config, context }: TaskUploadOptions): Promise<void>;
+}

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppVersionTask = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const log_1 = tslib_1.__importDefault(require("../../../log"));
+const log_2 = require("../../utils/log");
+const retry_1 = require("../../utils/retry");
+const task_1 = require("../task");
+class AppVersionTask extends task_1.AppleTask {
+    options;
+    constructor(options = {}) {
+        super();
+        this.options = {
+            platform: options.platform ?? apple_utils_1.Platform.IOS,
+            editLive: options.editLive ?? false,
+            version: options.version ?? null,
+        };
+    }
+    name = () => (this.options.editLive ? 'live app version' : 'editable app version');
+    async prepareAsync({ context }) {
+        const { version, versionIsFirst, versionIsLive } = await resolveVersionAsync(context.app, this.options);
+        if (!version) {
+            // No live or editable version available - this is OK for metadata:pull
+            // when the app hasn't been submitted yet
+            return;
+        }
+        context.version = version;
+        context.versionIsFirst = versionIsFirst;
+        context.versionIsLive = versionIsLive;
+        context.versionLocales = await version.getLocalizationsAsync();
+        context.versionPhasedRelease = await version.getPhasedReleaseAsync();
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.version) {
+            // No version available to download - skip silently
+            return;
+        }
+        config.setVersion(context.version.attributes);
+        config.setVersionReleaseType(context.version.attributes);
+        config.setVersionReleasePhased(context.versionPhasedRelease?.attributes);
+        for (const locale of context.versionLocales ?? []) {
+            config.setVersionLocale(locale.attributes);
+        }
+    }
+    async uploadAsync({ config, context }) {
+        const version = config.getVersion();
+        if (!context.version && version?.versionString) {
+            context.version = await (0, log_2.logAsync)(() => {
+                return context.app.createVersionAsync({
+                    versionString: version.versionString,
+                    platform: this.options.platform,
+                });
+            }, {
+                pending: `Creating new version ${chalk_1.default.bold(version.versionString)}...`,
+                success: `Created new version ${chalk_1.default.bold(version.versionString)}`,
+                failure: `Failed creating new version ${chalk_1.default.bold(version.versionString)}`,
+            });
+        }
+        (0, assert_1.default)(context.version, `App version not initialized, can't update version`);
+        const { versionString } = context.version.attributes;
+        const release = config.getVersionReleaseType();
+        if (!version && !release) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped version and release update, not configured}`);
+        }
+        else {
+            const description = [version && 'version', release && 'release']
+                .filter(Boolean)
+                .join(' and ');
+            context.version = await (0, log_2.logAsync)(() => context.version.updateAsync({ ...version, ...release }), {
+                pending: `Updating ${description} info for ${chalk_1.default.bold(versionString)}...`,
+                success: `Updated ${description} info for ${chalk_1.default.bold(versionString)}`,
+                failure: `Failed updating ${description} info for ${chalk_1.default.bold(versionString)}`,
+            });
+        }
+        const phasedRelease = config.getVersionReleasePhased();
+        if (!phasedRelease && shouldDeletePhasedRelease(context.versionPhasedRelease)) {
+            // if phased release was enabled, but now disabled, we need to remove it
+            await (0, log_2.logAsync)(() => context.versionPhasedRelease.deleteAsync(), {
+                pending: `Disabling phased release for ${chalk_1.default.bold(versionString)}...`,
+                success: `Disabled phased release for ${chalk_1.default.bold(versionString)}`,
+                failure: `Failed disabling phased release for ${chalk_1.default.bold(versionString)}`,
+            });
+            context.versionPhasedRelease = null;
+        }
+        else if (phasedRelease && !context.versionPhasedRelease) {
+            // if phased release was not yet set, but now enabled, we need to create it
+            context.versionPhasedRelease = await (0, log_2.logAsync)(() => context.version.createPhasedReleaseAsync({ state: phasedRelease.phasedReleaseState }), {
+                pending: `Enabling phased release for ${chalk_1.default.bold(versionString)}...`,
+                success: `Enabled phased release for ${chalk_1.default.bold(versionString)}`,
+                failure: `Failed enabling phased release for ${chalk_1.default.bold(versionString)}`,
+            });
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped localized version update, no locales configured}`);
+        }
+        else {
+            for (const locale of locales) {
+                const attributes = config.getVersionLocale(locale, context);
+                if (!attributes) {
+                    continue;
+                }
+                const oldModel = context.versionLocales.find(model => model.attributes.locale === locale);
+                await (0, log_2.logAsync)(async () => {
+                    return oldModel
+                        ? await oldModel.updateAsync(attributes)
+                        : await context.version.createLocalizationAsync({ ...attributes, locale });
+                }, {
+                    pending: `${oldModel ? 'Updating' : 'Creating'} localized version for ${chalk_1.default.bold(locale)}...`,
+                    success: `${oldModel ? 'Updated' : 'Created'} localized version for ${chalk_1.default.bold(locale)}`,
+                    failure: `Failed ${oldModel ? 'updating' : 'creating'} localized version for ${chalk_1.default.bold(locale)}`,
+                });
+            }
+            context.versionLocales = await context.version.getLocalizationsAsync();
+        }
+    }
+}
+exports.AppVersionTask = AppVersionTask;
+/**
+ * Resolve the AppStoreVersion instance, either from the store config, live, or editable version.
+ * This also checks if this is the first version, which disallow release notes.
+ */
+async function resolveVersionAsync(app, { editLive, platform, version: versionString }) {
+    let version = null;
+    let versionIsLive = false;
+    if (versionString) {
+        version = await findEditAppStoreVersionAsync(app, { platform, version: versionString });
+        if (!version) {
+            version = await createOrUpdateEditAppStoreVersionAsync(app, {
+                platform,
+                version: versionString,
+            });
+        }
+        versionIsLive = version?.attributes.appStoreState === apple_utils_1.AppStoreState.READY_FOR_SALE;
+    }
+    if (!version && editLive) {
+        version = await app.getLiveAppStoreVersionAsync({ platform });
+        versionIsLive = !!version;
+    }
+    if (!version) {
+        version = await (0, retry_1.retryIfNullAsync)(() => app.getEditAppStoreVersionAsync({ platform }));
+    }
+    // Fallback to live version if no editable version is found (for metadata:pull)
+    if (!version) {
+        version = await app.getLiveAppStoreVersionAsync({ platform });
+        versionIsLive = !!version;
+    }
+    const versions = await app.getAppStoreVersionsAsync({
+        query: { limit: 2, filter: { platform } },
+    });
+    return {
+        version,
+        versionIsLive,
+        versionIsFirst: versions.length === 1,
+    };
+}
+/**
+ * Determine if we can, and should, delete the phased release instance.
+ * This returns true if the instance exist, and has one of the states below:
+ *   - PhasedReleaseState.INACTIVE
+ *   - PhasedReleaseState.ACTIVE
+ *   - PhasedReleaseState.PAUSED
+ */
+function shouldDeletePhasedRelease(phasedRelease) {
+    if (!phasedRelease ||
+        phasedRelease.attributes.phasedReleaseState === apple_utils_1.PhasedReleaseState.COMPLETE) {
+        return false;
+    }
+    return true;
+}
+/*
+ * Search for editable app store versions that matches the `versionString` option.
+ * When nothing is found, it will return `null`, and a new version should be created.
+ */
+async function findEditAppStoreVersionAsync(app, options) {
+    if (options.version) {
+        const versions = await app.getAppStoreVersionsAsync({
+            query: {
+                limit: 200,
+                filter: {
+                    platform: options.platform,
+                    appStoreState: [
+                        apple_utils_1.AppStoreState.PREPARE_FOR_SUBMISSION,
+                        apple_utils_1.AppStoreState.DEVELOPER_REJECTED,
+                        apple_utils_1.AppStoreState.REJECTED,
+                        apple_utils_1.AppStoreState.METADATA_REJECTED,
+                        apple_utils_1.AppStoreState.WAITING_FOR_REVIEW,
+                        apple_utils_1.AppStoreState.INVALID_BINARY,
+                    ].join(','),
+                },
+            },
+        });
+        const version = versions.find(model => model.attributes.versionString === options.version);
+        if (version) {
+            return version;
+        }
+    }
+    return null;
+}
+/**
+ * Check if we can reuse an existing editable app version that has not been published yet.
+ * If not, it creates a new version based on the version string.
+ */
+async function createOrUpdateEditAppStoreVersionAsync(app, options) {
+    const version = await app.getEditAppStoreVersionAsync({ platform: options.platform });
+    if (version) {
+        return await version.updateAsync({ versionString: options.version });
+    }
+    return await app.createVersionAsync({
+        versionString: options.version,
+        platform: options.platform,
+    });
+}

package/build/metadata/apple/tasks/index.d.ts

@@ -0,0 +1,10 @@
+import { AppVersionOptions } from './app-version';
+import { AppleTask } from '../task';
+type AppleTaskOptions = {
+    version?: AppVersionOptions['version'];
+};
+/**
+ * List of all eligible tasks to sync local store configuration to the App store.
+ */
+export declare function createAppleTasks({ version }?: AppleTaskOptions): AppleTask[];
+export {};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppleTasks = createAppleTasks;
+const age_rating_1 = require("./age-rating");
+const app_info_1 = require("./app-info");
+const app_review_detail_1 = require("./app-review-detail");
+const app_version_1 = require("./app-version");
+/**
+ * List of all eligible tasks to sync local store configuration to the App store.
+ */
+function createAppleTasks({ version } = {}) {
+    return [
+        new app_version_1.AppVersionTask({ version }),
+        new app_info_1.AppInfoTask(),
+        new age_rating_1.AgeRatingTask(),
+        new app_review_detail_1.AppReviewDetailTask(),
+    ];
+}

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

@@ -0,0 +1,43 @@
+import type { AgeRatingDeclarationProps } from '@expo/apple-utils';
+export type AppleLocale = string;
+export interface AppleMetadata {
+    version?: string;
+    copyright?: string;
+    info?: Record<AppleLocale, AppleInfo>;
+    categories?: AppleCategory;
+    release?: AppleRelease;
+    advisory?: AppleAdvisory;
+    preview?: Record<string, string[]>;
+    review?: AppleReview;
+}
+export type AppleAdvisory = Omit<Partial<AgeRatingDeclarationProps>, 'seventeenPlus' | 'gamblingAndContests'>;
+/** Apps can define up to two categories, or categories with up to two subcategories */
+export type AppleCategory = (string | string[])[];
+export interface AppleRelease {
+    automaticRelease?: boolean | string;
+    phasedRelease?: boolean;
+}
+export interface AppleInfo {
+    title: string;
+    subtitle?: string;
+    /** Does not effect ASO https://developer-mdn.apple.com/app-store/product-page/ */
+    promoText?: string;
+    description?: string;
+    keywords?: string[];
+    releaseNotes?: string;
+    marketingUrl?: string;
+    privacyPolicyUrl?: string;
+    privacyPolicyText?: string;
+    privacyChoicesUrl?: string;
+    supportUrl?: string;
+}
+export interface AppleReview {
+    firstName: string;
+    lastName: string;
+    phone: string;
+    email: string;
+    demoUsername?: string;
+    demoPassword?: string;
+    demoRequired?: boolean;
+    notes?: string;
+}

package/build/metadata/apple/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/auth.d.ts

@@ -0,0 +1,20 @@
+import { App, Session } from '@expo/apple-utils';
+import { ExpoConfig } from '@expo/config';
+import { SubmitProfile } from '@expo/eas-json';
+import { CredentialsContext } from '../credentials/context';
+export type MetadataAppStoreAuthentication = {
+    /** The root entity of the App store */
+    app: App;
+    /** The authentication state we used to fetch the root entity */
+    auth: Partial<Session.AuthState>;
+};
+/**
+ * To start syncing ASC entities, we need access to the apple utils App instance.
+ * This resolves both the authentication and that App instance.
+ */
+export declare function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    exp: ExpoConfig;
+    credentialsCtx: CredentialsContext;
+}): Promise<MetadataAppStoreAuthentication>;

package/build/metadata/auth.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAppStoreAuthAsync = getAppStoreAuthAsync;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const authenticate_1 = require("../credentials/ios/appstore/authenticate");
+const bundleIdentifier_1 = require("../project/ios/bundleIdentifier");
+/**
+ * Resolve the bundle identifier from the selected submit profile.
+ * This bundle identifier is used as target for the metadata submission.
+ */
+async function resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, vcsClient) {
+    if ('bundleIdentifier' in profile) {
+        return profile.bundleIdentifier ?? (await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient));
+    }
+    return await (0, bundleIdentifier_1.getBundleIdentifierAsync)(projectDir, exp, vcsClient);
+}
+/**
+ * To start syncing ASC entities, we need access to the apple utils App instance.
+ * This resolves both the authentication and that App instance.
+ */
+async function getAppStoreAuthAsync({ projectDir, profile, exp, credentialsCtx, }) {
+    const bundleId = await resolveAppStoreBundleIdentifierAsync(projectDir, profile, exp, credentialsCtx.vcsClient);
+    const authCtx = await credentialsCtx.appStore.ensureAuthenticatedAsync();
+    (0, assert_1.default)(authCtx.authState, 'Failed to authenticate with App Store Connect');
+    // TODO: improve error handling by mentioning possible configuration errors
+    const app = await apple_utils_1.App.findAsync((0, authenticate_1.getRequestContext)(authCtx), { bundleId });
+    (0, assert_1.default)(app, `Failed to load app "${bundleId}" from App Store Connect`);
+    return { app, auth: authCtx.authState };
+}

package/build/metadata/config/issue.d.ts

@@ -0,0 +1,21 @@
+import { MetadataConfig } from './schema';
+export declare enum IssueSeverity {
+    info = 0,
+    warn = 1,
+    error = 2
+}
+export interface Issue {
+    /** The type of issue, auto-generated for AJV errors based on the validation type */
+    id: string;
+    /** The severity of the lint message */
+    severity: IssueSeverity;
+    /** The data path, using segments, to the source of this message */
+    path: string[];
+    /** A human readable description of the issue, presented to users */
+    message: string;
+}
+export interface IssueRule<Data = MetadataConfig> {
+    id: string;
+    severity: IssueSeverity;
+    validate(config: Data): null | Issue | Issue[];
+}

package/build/metadata/config/issue.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IssueSeverity = void 0;
+var IssueSeverity;
+(function (IssueSeverity) {
+    IssueSeverity[IssueSeverity["info"] = 0] = "info";
+    IssueSeverity[IssueSeverity["warn"] = 1] = "warn";
+    IssueSeverity[IssueSeverity["error"] = 2] = "error";
+})(IssueSeverity || (exports.IssueSeverity = IssueSeverity = {}));

package/build/metadata/config/resolve.d.ts

@@ -0,0 +1,27 @@
+import { SubmitProfile } from '@expo/eas-json';
+import { MetadataConfig } from './schema';
+import { AppleConfigReader } from '../apple/config/reader';
+import { AppleConfigWriter } from '../apple/config/writer';
+/**
+ * Get the static configuration file path, based on the metadata context.
+ * This uses any custom name provided, but swaps out the extension for `.json`.
+ */
+export declare function getStaticConfigFilePath({ projectDir, profile, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+}): string;
+/**
+ * Load the store configuration from a metadata context.
+ * This can load `.json` and `.js` config files, using `require`.
+ * It throws MetadataValidationErrors when the file doesn't exist, or contains errors.
+ * The user is prompted to try anyway when errors are found.
+ */
+export declare function loadConfigAsync({ projectDir, profile, skipValidation, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    skipValidation?: boolean;
+}): Promise<MetadataConfig>;
+/** Create a versioned deserializer to fetch App Store data from the store configuration. */
+export declare function createAppleReader(config: MetadataConfig): AppleConfigReader;
+/** Create the serializer to write the App Store to the store configuration. */
+export declare function createAppleWriter(): AppleConfigWriter;

package/build/metadata/config/resolve.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStaticConfigFilePath = getStaticConfigFilePath;
+exports.loadConfigAsync = loadConfigAsync;
+exports.createAppleReader = createAppleReader;
+exports.createAppleWriter = createAppleWriter;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const fs_extra_1 = tslib_1.__importDefault(require("fs-extra"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const validate_1 = require("./validate");
+const reader_1 = require("../apple/config/reader");
+const writer_1 = require("../apple/config/writer");
+const errors_1 = require("../errors");
+/**
+ * Resolve the dynamic config from the user.
+ * It supports methods, async methods, or objects (json).
+ */
+async function resolveDynamicConfigAsync(configFile) {
+    const userConfigOrFunction = await Promise.resolve(`${configFile}`).then(s => tslib_1.__importStar(require(s))).then(file => file.default ?? file);
+    return typeof userConfigOrFunction === 'function'
+        ? // eslint-disable-next-line @typescript-eslint/return-await
+            await userConfigOrFunction()
+        : userConfigOrFunction;
+}
+/**
+ * Resolve the prefered store config file name from the submit profile.
+ * This is relative to the project directory, and uses `store.config.json` by default.
+ */
+function resolveConfigFilePath(profile) {
+    if ('metadataPath' in profile) {
+        return profile.metadataPath ?? 'store.config.json';
+    }
+    return 'store.config.json';
+}
+/**
+ * Get the static configuration file path, based on the metadata context.
+ * This uses any custom name provided, but swaps out the extension for `.json`.
+ */
+function getStaticConfigFilePath({ projectDir, profile, }) {
+    const configFile = path_1.default.join(projectDir, resolveConfigFilePath(profile));
+    const configExtension = path_1.default.extname(configFile);
+    return path_1.default.join(projectDir, `${path_1.default.basename(configFile, configExtension)}.json`);
+}
+/**
+ * Load the store configuration from a metadata context.
+ * This can load `.json` and `.js` config files, using `require`.
+ * It throws MetadataValidationErrors when the file doesn't exist, or contains errors.
+ * The user is prompted to try anyway when errors are found.
+ */
+async function loadConfigAsync({ projectDir, profile, skipValidation = false, }) {
+    const configFile = path_1.default.join(projectDir, resolveConfigFilePath(profile));
+    if (!(await fs_extra_1.default.pathExists(configFile))) {
+        throw new errors_1.MetadataValidationError(`Metadata store config file not found: "${configFile}"`);
+    }
+    const configData = await resolveDynamicConfigAsync(configFile);
+    if (!skipValidation) {
+        const issues = (0, validate_1.validateConfig)(configData);
+        if (issues.length > 0) {
+            throw new errors_1.MetadataValidationError(`Metadata store config errors found`, issues);
+        }
+    }
+    return configData;
+}
+/** Create a versioned deserializer to fetch App Store data from the store configuration. */
+function createAppleReader(config) {
+    (0, assert_1.default)(config.configVersion === 0, 'Unsupported store configuration version');
+    (0, assert_1.default)(config.apple !== undefined, 'No apple configuration found');
+    return new reader_1.AppleConfigReader(config.apple);
+}
+/** Create the serializer to write the App Store to the store configuration. */
+function createAppleWriter() {
+    return new writer_1.AppleConfigWriter();
+}

package/build/metadata/config/schema.d.ts

@@ -0,0 +1,7 @@
+import { AppleMetadata } from '../apple/types';
+export interface MetadataConfig {
+    /** The store configuration version */
+    configVersion: number;
+    /** All App Store related configuration */
+    apple?: AppleMetadata;
+}

package/build/metadata/config/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/metadata/config/validate.d.ts

@@ -0,0 +1,3 @@
+import { Issue } from './issue';
+/** Validate the user-provided validation for issues */
+export declare function validateConfig(config: unknown): Issue[];

package/build/metadata/config/validate.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateConfig = validateConfig;
+const issue_1 = require("./issue");
+const rules_1 = require("../apple/rules");
+const ajv_1 = require("../utils/ajv");
+const metadataSchema = require('../../../schema/metadata-0.json');
+/** Validate the user-provided validation for issues */
+function validateConfig(config) {
+    const validator = (0, ajv_1.createValidator)().compile(metadataSchema);
+    validator(config);
+    const issues = (0, ajv_1.getReadableErrors)(validator.errors ?? []).map(error => {
+        const path = error.path === '$' ? [] : error.path.substring(2).split('.');
+        const id = error.original?.keyword ?? 'unknown';
+        return {
+            id: `json-schema.${id}`,
+            path,
+            severity: issue_1.IssueSeverity.error,
+            message: error.message,
+        };
+    });
+    try {
+        issues.push(...validateRules(rules_1.appleRules, config));
+    }
+    catch {
+        // When the rules are failing, the json schema validation errors explain the issue
+        // TODO(cedric): optionally add debugging logging for these types of errors
+    }
+    return issues;
+}
+/** Validate the set of rules against the parsed metadata config */
+function validateRules(rules, config) {
+    const issues = [];
+    for (const rule of rules) {
+        const result = rule.validate(config);
+        if (Array.isArray(result)) {
+            issues.push(...result);
+        }
+        else if (result) {
+            issues.push(result);
+        }
+    }
+    return issues;
+}

package/build/metadata/download.d.ts

@@ -0,0 +1,15 @@
+import { ExpoConfig } from '@expo/config';
+import { SubmitProfile } from '@expo/eas-json';
+import { Analytics } from '../analytics/AnalyticsManager';
+import { CredentialsContext } from '../credentials/context';
+/**
+ * Generate a local store configuration from the stores.
+ * Note, only App Store is supported at this time.
+ */
+export declare function downloadMetadataAsync({ projectDir, profile, exp, analytics, credentialsCtx, }: {
+    projectDir: string;
+    profile: SubmitProfile;
+    exp: ExpoConfig;
+    analytics: Analytics;
+    credentialsCtx: CredentialsContext;
+}): Promise<string>;