eas-cli 0.52.0 → 0.54.0

package/build/metadata/apple/config/writer.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { AgeRatingDeclaration, AppInfo, AppInfoLocalization, AppStoreVersion, AppStoreVersionLocalization } from '@expo/apple-utils';
+import { AttributesOf } from '../../utils/asc';
+import { AppleMetadata } from '../types';
+/**
+ * Serializes the Apple ASC entities into the metadata configuration schema.
+ * This uses version 0 of the config schema.
+ */
+export declare class AppleConfigWriter {
+    readonly schema: Partial<AppleMetadata>;
+    constructor(schema?: Partial<AppleMetadata>);
+    /** Get the schema result to write it to the config file */
+    toSchema(): {
+        configVersion: number;
+        apple: Partial<AppleMetadata>;
+    };
+    setAgeRating(attributes: AttributesOf<AgeRatingDeclaration>): void;
+    setInfoLocale(attributes: AttributesOf<AppInfoLocalization>): void;
+    setCategories({ primaryCategory, secondaryCategory }: AttributesOf<AppInfo>): void;
+    setVersion(attributes: Omit<AttributesOf<AppStoreVersion>, 'releaseType' | 'earliestReleaseDate'>): void;
+    setVersionRelease(attributes: Pick<AttributesOf<AppStoreVersion>, 'releaseType' | 'earliestReleaseDate'>): void;
+    setVersionLocale(attributes: AttributesOf<AppStoreVersionLocalization>): void;
+}

package/build/metadata/apple/config/writer.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleConfigWriter = void 0;
+const apple_utils_1 = require("@expo/apple-utils");
+/**
+ * Serializes the Apple ASC entities into the metadata configuration schema.
+ * This uses version 0 of the config schema.
+ */
+class AppleConfigWriter {
+    constructor(schema = {}) {
+        this.schema = schema;
+    }
+    /** Get the schema result to write it to the config file */
+    toSchema() {
+        return {
+            configVersion: 0,
+            apple: this.schema,
+        };
+    }
+    setAgeRating(attributes) {
+        this.schema.advisory = attributes;
+    }
+    setInfoLocale(attributes) {
+        var _a, _b, _c;
+        this.schema.info = (_a = this.schema.info) !== null && _a !== void 0 ? _a : {};
+        const existing = (_b = this.schema.info[attributes.locale]) !== null && _b !== void 0 ? _b : {};
+        this.schema.info[attributes.locale] = {
+            ...existing,
+            title: (_c = attributes.name) !== null && _c !== void 0 ? _c : 'no name provided',
+            subtitle: optional(attributes.subtitle),
+            privacyPolicyUrl: optional(attributes.privacyPolicyUrl),
+            privacyPolicyText: optional(attributes.privacyPolicyText),
+            privacyChoicesUrl: optional(attributes.privacyChoicesUrl),
+        };
+    }
+    setCategories({ primaryCategory, secondaryCategory }) {
+        this.schema.categories = [];
+        // TODO: see why these types are conflicting
+        if (primaryCategory) {
+            this.schema.categories.push(primaryCategory.id);
+            if (secondaryCategory) {
+                this.schema.categories.push(secondaryCategory.id);
+            }
+        }
+    }
+    setVersion(attributes) {
+        this.schema.copyright = optional(attributes.copyright);
+    }
+    setVersionRelease(attributes) {
+        if (attributes.releaseType === apple_utils_1.ReleaseType.SCHEDULED) {
+            this.schema.release = {
+                autoReleaseDate: optional(attributes.earliestReleaseDate),
+            };
+        }
+        if (attributes.releaseType === apple_utils_1.ReleaseType.AFTER_APPROVAL) {
+            this.schema.release = {
+                automaticRelease: true,
+            };
+        }
+        if (attributes.releaseType === apple_utils_1.ReleaseType.MANUAL) {
+            this.schema.release = {
+                automaticRelease: false,
+            };
+        }
+    }
+    setVersionLocale(attributes) {
+        var _a, _b, _c;
+        this.schema.info = (_a = this.schema.info) !== null && _a !== void 0 ? _a : {};
+        const existing = (_b = this.schema.info[attributes.locale]) !== null && _b !== void 0 ? _b : {};
+        this.schema.info[attributes.locale] = {
+            ...existing,
+            description: optional(attributes.description),
+            keywords: (_c = optional(attributes.keywords)) === null || _c === void 0 ? void 0 : _c.split(',').map(keyword => keyword.trim()),
+            releaseNotes: optional(attributes.whatsNew),
+            marketingUrl: optional(attributes.marketingUrl),
+            promoText: optional(attributes.promotionalText),
+            supportUrl: optional(attributes.supportUrl),
+        };
+    }
+}
+exports.AppleConfigWriter = AppleConfigWriter;
+/** Helper function to convert `T | null` to `T | undefined`, required for the entity properties */
+function optional(value) {
+    return value !== null && value !== void 0 ? value : undefined;
+}

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

@@ -0,0 +1,20 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import type { App } from '@expo/apple-utils';
+import type { AgeRatingData } from './tasks/age-rating';
+import type { AppInfoData } from './tasks/app-info';
+import type { AppVersionData } from './tasks/app-version';
+/**
+ * The fully prepared apple data, used within the `downloadAsync` or `uploadAsync` tasks.
+ * It contains references to each individual models, to either upload or download App Store data.
+ */
+export declare type AppleData = {
+    app: App;
+} & AppInfoData & AppVersionData & AgeRatingData;
+/**
+ * The unprepared partial apple data, used within the `prepareAsync` tasks.
+ * It contains a reference to the app, each task should populate the necessary data.
+ * If an entity fails to prepare the data, individual tasks should raise errors about the missing data.
+ */
+export declare type PartialAppleData = {
+    app: App;
+} & Partial<Omit<AppleData, 'app'>>;

package/build/metadata/apple/data.js

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

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

@@ -0,0 +1,24 @@
+import { AppleConfigReader } from './config/reader';
+import { AppleConfigWriter } from './config/writer';
+import { AppleData, PartialAppleData } from './data';
+export declare abstract class AppleTask {
+    /** Get a description from the task to use as section headings in the log */
+    abstract name(): string;
+    /** Prepare the data from the App Store to start syncing with the store configuration */
+    abstract prepareAsync(options: TaskPrepareOptions): Promise<void>;
+    /** Download all information from the App Store to generate the store configuration */
+    abstract downloadAsync(options: TaskDownloadOptions): Promise<void>;
+    /** Upload all information from the store configuration to the App Store */
+    abstract uploadAsync(options: TaskUploadOptions): Promise<void>;
+}
+export declare type TaskPrepareOptions = {
+    context: PartialAppleData;
+};
+export declare type TaskDownloadOptions = {
+    config: AppleConfigWriter;
+    context: AppleData;
+};
+export declare type TaskUploadOptions = {
+    config: AppleConfigReader;
+    context: AppleData;
+};

package/build/metadata/apple/task.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleTask = void 0;
+class AppleTask {
+}
+exports.AppleTask = AppleTask;

package/build/metadata/apple/tasks/age-rating.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { AgeRatingDeclaration } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export declare type AgeRatingData = {
+    /** The app age rating declaration for the app version */
+    ageRating: AgeRatingDeclaration;
+};
+export declare class AgeRatingTask 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/age-rating.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgeRatingTask = 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");
+class AgeRatingTask extends task_1.AppleTask {
+    constructor() {
+        super(...arguments);
+        this.name = () => 'age rating declarations';
+    }
+    async prepareAsync({ context }) {
+        (0, assert_1.default)(context.version, `App version information is not prepared, can't update age rating`);
+        context.ageRating = (await context.version.getAgeRatingDeclarationAsync()) || undefined;
+    }
+    async downloadAsync({ config, context }) {
+        if (context.ageRating) {
+            config.setAgeRating(context.ageRating.attributes);
+        }
+    }
+    async uploadAsync({ config, context }) {
+        (0, assert_1.default)(context.ageRating, `Age rating not initialized, can't update age rating`);
+        const ageRating = config.getAgeRating();
+        if (!ageRating) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped age rating update, no advisory configured}`);
+        }
+        else {
+            context.ageRating = await (0, log_2.logAsync)(() => context.ageRating.updateAsync(ageRating), {
+                pending: 'Updating age rating declaration...',
+                success: 'Updated age rating declaration',
+                failure: 'Failed to update age rating declaration',
+            });
+        }
+    }
+}
+exports.AgeRatingTask = AgeRatingTask;

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

@@ -0,0 +1,15 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { AppInfo, AppInfoLocalization } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export declare type AppInfoData = {
+    /** The current app info that should be edited */
+    info: AppInfo;
+    /** All info locales that are enabled */
+    infoLocales: AppInfoLocalization[];
+};
+export declare class AppInfoTask 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-info.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppInfoTask = 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 retry_1 = require("../../utils/retry");
+const task_1 = require("../task");
+class AppInfoTask extends task_1.AppleTask {
+    constructor() {
+        super(...arguments);
+        this.name = () => 'app information';
+    }
+    async prepareAsync({ context }) {
+        const info = await (0, retry_1.retryIfNullAsync)(() => context.app.getEditAppInfoAsync());
+        (0, assert_1.default)(info, 'Could not resolve the editable app info to update');
+        context.info = info;
+        context.infoLocales = await info.getLocalizationsAsync();
+    }
+    async downloadAsync({ config, context }) {
+        (0, assert_1.default)(context.info, `App info not initialized, can't download info`);
+        config.setCategories(context.info.attributes);
+        for (const locale of context.infoLocales) {
+            config.setInfoLocale(locale.attributes);
+        }
+    }
+    async uploadAsync({ config, context }) {
+        (0, assert_1.default)(context.info, `App info not initialized, can't update info`);
+        const categories = config.getCategories();
+        if (!categories) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped app category update, not configured}`);
+        }
+        else {
+            context.info = await (0, log_2.logAsync)(() => context.info.updateCategoriesAsync(categories), {
+                pending: 'Updating app categories...',
+                success: 'Updated app categories',
+                failure: 'Failed updating app categories',
+            });
+        }
+        const locales = config.getLocales();
+        if (locales.length <= 0) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped localized info update, no locales configured}`);
+        }
+        else {
+            // BUG: new issue introduced in ASC 1.8.0, when creating version locales, info locales are also generated
+            context.infoLocales = await (0, log_2.logAsync)(() => context.info.getLocalizationsAsync(), {
+                pending: 'Reloading localized info...',
+                success: 'Reloaded localized info',
+                failure: 'Failed reloading localized info',
+            });
+            for (const locale of locales) {
+                const attributes = config.getInfoLocale(locale);
+                if (!attributes) {
+                    continue;
+                }
+                const model = context.infoLocales.find(model => model.attributes.locale === locale);
+                await (0, log_2.logAsync)(async () => {
+                    return model
+                        ? await model.updateAsync(attributes)
+                        : await context.info.createLocalizationAsync({ ...attributes, locale });
+                }, {
+                    pending: `${model ? 'Updating' : 'Creating'} localized info for ${chalk_1.default.bold(locale)}...`,
+                    success: `${model ? 'Updated' : 'Created'} localized info for ${chalk_1.default.bold(locale)}`,
+                    failure: `Failed ${model ? 'updating' : 'creating'} localized info for ${chalk_1.default.bold(locale)}`,
+                });
+            }
+            context.infoLocales = await context.info.getLocalizationsAsync();
+        }
+    }
+}
+exports.AppInfoTask = AppInfoTask;

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

@@ -0,0 +1,27 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { AppStoreVersion, AppStoreVersionLocalization, Platform } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export declare 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;
+};
+export declare 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[];
+};
+export declare class AppVersionTask extends AppleTask {
+    private 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,104 @@
+"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 {
+    constructor(options = {}) {
+        var _a, _b;
+        super();
+        this.name = () => (this.options.editLive ? 'live app version' : 'editable app version');
+        this.options = {
+            platform: (_a = options.platform) !== null && _a !== void 0 ? _a : apple_utils_1.Platform.IOS,
+            editLive: (_b = options.editLive) !== null && _b !== void 0 ? _b : false,
+        };
+    }
+    async prepareAsync({ context }) {
+        const { version, versionIsFirst, versionIsLive } = await resolveVersionAsync(context.app, this.options);
+        (0, assert_1.default)(version, 'Could not resolve a live or editable app version');
+        context.version = version;
+        context.versionIsFirst = versionIsFirst;
+        context.versionIsLive = versionIsLive;
+        context.versionLocales = await version.getLocalizationsAsync();
+    }
+    async downloadAsync({ config, context }) {
+        (0, assert_1.default)(context.version, `App version not initialized, can't download version`);
+        config.setVersion(context.version.attributes);
+        config.setVersionRelease(context.version.attributes);
+        for (const locale of context.versionLocales) {
+            config.setVersionLocale(locale.attributes);
+        }
+    }
+    async uploadAsync({ config, context }) {
+        (0, assert_1.default)(context.version, `App version not initialized, can't update version`);
+        const version = config.getVersion();
+        const release = config.getVersionRelease();
+        if (!version && !release) {
+            log_1.default.log((0, chalk_1.default) `{dim - Skipped version and release update, not configured}`);
+        }
+        else {
+            const { versionString } = context.version.attributes;
+            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 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 live or editable version.
+ * This also checks if this is the first version, which disallow release notes.
+ */
+async function resolveVersionAsync(app, { editLive, platform }) {
+    let version = null;
+    let versionIsLive = false;
+    if (editLive) {
+        version = await app.getLiveAppStoreVersionAsync({ platform });
+        versionIsLive = !!version;
+    }
+    if (!version) {
+        version = await (0, retry_1.retryIfNullAsync)(() => app.getEditAppStoreVersionAsync({ platform }));
+    }
+    const versions = await app.getAppStoreVersionsAsync({
+        query: { limit: 2, filter: { platform } },
+    });
+    return {
+        version,
+        versionIsLive,
+        versionIsFirst: versions.length === 1,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { MetadataContext } from '../../context';
+import { AppleTask } from '../task';
+/**
+ * List of all eligible tasks to sync local store configuration to the App store.
+ */
+export declare function createAppleTasks(_ctx: MetadataContext): AppleTask[];

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

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

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

@@ -0,0 +1,50 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import type { AgeRatingDeclarationProps, AppCategoryId, AppSubcategoryId } from '@expo/apple-utils';
+export declare type AppleLocale = string;
+export interface AppleMetadata {
+    copyright?: string;
+    info?: Record<AppleLocale, AppleInfo>;
+    categories?: AppCategoryId[] | AppleCategory;
+    release?: AppleRelease;
+    advisory?: AppleAdvisory;
+    preview?: Record<string, string[]>;
+    review?: AppleReview;
+}
+export declare type AppleAdvisory = Partial<AgeRatingDeclarationProps>;
+export interface AppleCategory {
+    category: AppCategoryId;
+    subcategory?: AppSubcategoryId[];
+}
+export interface AppleRelease {
+    isPhasedReleaseEnabled?: boolean;
+    shouldResetRatings?: boolean;
+    autoReleaseDate?: number | string;
+    automaticRelease?: boolean;
+    usesThirdPartyContent?: boolean;
+    /** Alternative to setting `ITSAppUsesNonExemptEncryption` in the binary's `Info.plist`. */
+    usesNonExemptEncryption?: boolean;
+}
+export interface AppleInfo {
+    title: string;
+    subtitle?: string;
+    /** Does not effect ASO https://developer.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;
+    notes?: string;
+    attachment?: string;
+}

package/build/metadata/apple/types.js

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

package/build/metadata/config.d.ts

@@ -0,0 +1,22 @@
+import Ajv from 'ajv';
+import { AppleConfigReader } from './apple/config/reader';
+import { AppleConfigWriter } from './apple/config/writer';
+import { AppleMetadata } from './apple/types';
+export interface MetadataConfig {
+    /** The store configuration version */
+    configVersion: number;
+    /** All App Store related configuration */
+    apple?: AppleMetadata;
+}
+/**
+ * Run the JSON Schema validation to normalize defaults and flag early config errors.
+ * This includes validating the known store limitations for every configurable property.
+ */
+export declare function validateConfig(config: unknown): {
+    valid: boolean;
+    errors: Ajv.ErrorObject[];
+};
+/** 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.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAppleWriter = exports.createAppleReader = exports.validateConfig = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const reader_1 = require("./apple/config/reader");
+const writer_1 = require("./apple/config/writer");
+/**
+ * Run the JSON Schema validation to normalize defaults and flag early config errors.
+ * This includes validating the known store limitations for every configurable property.
+ */
+function validateConfig(config) {
+    const validator = new ajv_1.default({ allErrors: true, useDefaults: true })
+        .addMetaSchema(require('ajv/lib/refs/json-schema-draft-06.json'))
+        .compile(require('../../schema/metadata-0.json'));
+    const valid = validator(config);
+    return { valid, errors: validator.errors || [] };
+}
+exports.validateConfig = validateConfig;
+/** 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, 'No apple configuration found');
+    return new reader_1.AppleConfigReader(config.apple);
+}
+exports.createAppleReader = createAppleReader;
+/** Create the serializer to write the App Store to the store configuration. */
+function createAppleWriter() {
+    return new writer_1.AppleConfigWriter();
+}
+exports.createAppleWriter = createAppleWriter;

package/build/metadata/context.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="@expo/apple-utils/ts-declarations/expo__app-store" />
+import { App, Session } from '@expo/apple-utils';
+import { ExpoConfig } from '@expo/config';
+import { Platform } from '@expo/eas-build-job';
+import { SubmitProfile } from '@expo/eas-json';
+import { CredentialsContext } from '../credentials/context';
+import { Actor } from '../user/User';
+export declare type MetadataContext = {
+    /** Submission profile platform to use */
+    platform: Platform.IOS;
+    /** Resolved submission profile configuration */
+    profile: SubmitProfile<Platform.IOS>;
+    /** Configured store config path, relative from projectDir (defaults to store.config.json) */
+    metadataPath: string;
+    /** Authenticated Expo account */
+    user: Actor;
+    /** The store credentials manager */
+    credentialsCtx: CredentialsContext;
+    /** The app bundle identifier to use for the store */
+    bundleIdentifier: string;
+    /** Root of the Expo project directory */
+    projectDir: string;
+    /** Resolved Expo app configuration */
+    exp: ExpoConfig;
+};
+export declare 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>;
+};
+/**
+ * Metadata uses the submission profile to find the configured metadata filename.
+ * Note, only iOS is supported for metadata right now.
+ */
+export declare function createMetadataContextAsync(params: {
+    projectDir: string;
+    credentialsCtx: CredentialsContext;
+    exp?: ExpoConfig;
+    profileName?: string;
+}): Promise<MetadataContext>;
+/**
+ * To start syncing ASC entities, we need access to the apple utils App instance.
+ * This ensures we are authenticated and have the app instance ready to use.
+ */
+export declare function ensureMetadataAppStoreAuthenticatedAsync({ credentialsCtx, bundleIdentifier, }: MetadataContext): Promise<MetadataAppStoreAuthentication>;