@donotuse/eas-cli 18.5.0-rc.1

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppleConfigReader = exports.DEFAULT_WHATSNEW = void 0;
+const tslib_1 = require("tslib");
+const apple_utils_1 = require("@expo/apple-utils");
+const uniq_1 = tslib_1.__importDefault(require("../../../utils/expodash/uniq"));
+const date_1 = require("../../utils/date");
+// TODO: find out if we can move this to default JSON schema normalization
+exports.DEFAULT_WHATSNEW = 'Bug fixes and improved stability';
+/**
+ * Deserializes the metadata config schema into attributes for different models.
+ * This uses version 0 of the config schema.
+ */
+class AppleConfigReader {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    getAgeRating() {
+        const attributes = this.schema.advisory;
+        if (!attributes) {
+            return null;
+        }
+        return {
+            ageRatingOverride: attributes.ageRatingOverride ?? apple_utils_1.RatingOverride.NONE,
+            alcoholTobaccoOrDrugUseOrReferences: attributes.alcoholTobaccoOrDrugUseOrReferences ?? apple_utils_1.Rating.NONE,
+            contests: attributes.contests ?? apple_utils_1.Rating.NONE,
+            gambling: attributes.gambling ?? false,
+            gamblingSimulated: attributes.gamblingSimulated ?? apple_utils_1.Rating.NONE,
+            horrorOrFearThemes: attributes.horrorOrFearThemes ?? apple_utils_1.Rating.NONE,
+            kidsAgeBand: attributes.kidsAgeBand ?? null,
+            koreaAgeRatingOverride: attributes.koreaAgeRatingOverride ?? apple_utils_1.KoreaRatingOverride.NONE,
+            lootBox: attributes.lootBox ?? false,
+            matureOrSuggestiveThemes: attributes.matureOrSuggestiveThemes ?? apple_utils_1.Rating.NONE,
+            medicalOrTreatmentInformation: attributes.medicalOrTreatmentInformation ?? apple_utils_1.Rating.NONE,
+            profanityOrCrudeHumor: attributes.profanityOrCrudeHumor ?? apple_utils_1.Rating.NONE,
+            sexualContentGraphicAndNudity: attributes.sexualContentGraphicAndNudity ?? apple_utils_1.Rating.NONE,
+            sexualContentOrNudity: attributes.sexualContentOrNudity ?? apple_utils_1.Rating.NONE,
+            unrestrictedWebAccess: attributes.unrestrictedWebAccess ?? false,
+            violenceCartoonOrFantasy: attributes.violenceCartoonOrFantasy ?? apple_utils_1.Rating.NONE,
+            violenceRealistic: attributes.violenceRealistic ?? apple_utils_1.Rating.NONE,
+            violenceRealisticProlongedGraphicOrSadistic: attributes.violenceRealisticProlongedGraphicOrSadistic ?? apple_utils_1.Rating.NONE,
+        };
+    }
+    getLocales() {
+        // TODO: filter "default" locales, add option to add non-localized info to the config
+        return (0, uniq_1.default)(Object.keys(this.schema.info ?? {}));
+    }
+    getInfoLocale(locale) {
+        const info = this.schema.info?.[locale];
+        if (!info) {
+            return null;
+        }
+        return {
+            locale,
+            name: info.title,
+            subtitle: info.subtitle,
+            privacyChoicesUrl: info.privacyChoicesUrl,
+            privacyPolicyText: info.privacyPolicyText,
+            privacyPolicyUrl: info.privacyPolicyUrl,
+        };
+    }
+    getCategories() {
+        const { categories } = this.schema;
+        if (!categories || categories.length <= 0) {
+            return null;
+        }
+        // We validate the categories based on enums, but they will still be strings here.
+        const categoryIds = {};
+        if (Array.isArray(categories[0])) {
+            categoryIds.primaryCategory = categories[0][0];
+            categoryIds.primarySubcategoryOne = categories[0][1];
+            categoryIds.primarySubcategoryTwo = categories[0][2];
+        }
+        else {
+            categoryIds.primaryCategory = categories[0];
+        }
+        if (Array.isArray(categories[1])) {
+            categoryIds.secondaryCategory = categories[1][0];
+            categoryIds.secondarySubcategoryOne = categories[1][1];
+            categoryIds.secondarySubcategoryTwo = categories[1][2];
+        }
+        else {
+            categoryIds.secondaryCategory = categories[1];
+        }
+        // Because we handle categories as normal strings,
+        // the type doesn't match with the actual CategoryIds types.
+        return categoryIds;
+    }
+    /** Get the `AppStoreVersion` object. */
+    getVersion() {
+        const attributes = {
+            versionString: this.schema.version ?? '',
+            copyright: this.schema.copyright ?? null,
+        };
+        const hasValues = Object.values(attributes).some(Boolean);
+        return hasValues ? attributes : null;
+    }
+    getVersionReleaseType() {
+        const { release } = this.schema;
+        if (typeof release?.automaticRelease === 'string') {
+            return {
+                releaseType: apple_utils_1.ReleaseType.SCHEDULED,
+                // Convert time format to 2020-06-17T12:00:00-07:00, if that fails, try the date anyways.
+                earliestReleaseDate: (0, date_1.removeDatePrecision)(release.automaticRelease)?.toISOString() ?? release.automaticRelease,
+            };
+        }
+        if (release?.automaticRelease === true) {
+            return {
+                releaseType: apple_utils_1.ReleaseType.AFTER_APPROVAL,
+                earliestReleaseDate: null,
+            };
+        }
+        if (release?.automaticRelease === false) {
+            return {
+                releaseType: apple_utils_1.ReleaseType.MANUAL,
+                earliestReleaseDate: null,
+            };
+        }
+        return null;
+    }
+    getVersionReleasePhased() {
+        if (this.schema.release?.phasedRelease === true) {
+            return {
+                phasedReleaseState: apple_utils_1.PhasedReleaseState.ACTIVE,
+            };
+        }
+        // When phased release is turned off, we need to delete the phased release request.
+        // There is no concept (yet) of pausing the phased release through EAS metadata.
+        return null;
+    }
+    getVersionLocale(locale, context) {
+        const info = this.schema.info?.[locale];
+        if (!info) {
+            return null;
+        }
+        return {
+            locale,
+            description: info.description,
+            keywords: info.keywords?.join(','),
+            // TODO: maybe move this to task logic, it's more an exception than data handling
+            whatsNew: context.versionIsFirst ? undefined : info.releaseNotes || exports.DEFAULT_WHATSNEW,
+            marketingUrl: info.marketingUrl,
+            promotionalText: info.promoText,
+            supportUrl: info.supportUrl,
+        };
+    }
+    getReviewDetails() {
+        const review = this.schema.review;
+        if (!review) {
+            return null;
+        }
+        return {
+            contactFirstName: review.firstName,
+            contactLastName: review.lastName,
+            contactEmail: review.email,
+            contactPhone: review.phone,
+            demoAccountName: review.demoUsername,
+            demoAccountPassword: review.demoPassword,
+            demoAccountRequired: review.demoRequired,
+            notes: review.notes,
+            // TODO: add attachment
+        };
+    }
+}
+exports.AppleConfigReader = AppleConfigReader;

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

@@ -0,0 +1,24 @@
+import { AgeRatingDeclaration, AppInfo, AppInfoLocalization, AppStoreReviewDetail, AppStoreVersion, AppStoreVersionLocalization, AppStoreVersionPhasedRelease } 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: Omit<AttributesOf<AgeRatingDeclaration>, 'seventeenPlus' | 'gamblingAndContests'>): void;
+    setInfoLocale(attributes: AttributesOf<AppInfoLocalization>): void;
+    setCategories(attributes: Pick<AttributesOf<AppInfo>, 'primaryCategory' | 'primarySubcategoryOne' | 'primarySubcategoryTwo' | 'secondaryCategory' | 'secondarySubcategoryOne' | 'secondarySubcategoryTwo'>): void;
+    setVersion(attributes: Omit<AttributesOf<AppStoreVersion>, 'releaseType' | 'earliestReleaseDate'>): void;
+    setVersionReleaseType(attributes: Pick<AttributesOf<AppStoreVersion>, 'releaseType' | 'earliestReleaseDate'>): void;
+    setVersionReleasePhased(attributes?: AttributesOf<AppStoreVersionPhasedRelease>): void;
+    setVersionLocale(attributes: AttributesOf<AppStoreVersionLocalization>): void;
+    setReviewDetails(attributes: AttributesOf<AppStoreReviewDetail>): void;
+}

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

@@ -0,0 +1,153 @@
+"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 {
+    schema;
+    constructor(schema = {}) {
+        this.schema = schema;
+    }
+    /** Get the schema result to write it to the config file */
+    toSchema() {
+        return {
+            configVersion: 0,
+            apple: this.schema,
+        };
+    }
+    // Note, both `seventeenPlus` and `gamlingAndContests` are deprecated
+    setAgeRating(attributes) {
+        this.schema.advisory = {
+            ageRatingOverride: attributes.ageRatingOverride ?? apple_utils_1.RatingOverride.NONE,
+            alcoholTobaccoOrDrugUseOrReferences: attributes.alcoholTobaccoOrDrugUseOrReferences ?? apple_utils_1.Rating.NONE,
+            contests: attributes.contests ?? apple_utils_1.Rating.NONE,
+            gambling: attributes.gambling ?? false,
+            gamblingSimulated: attributes.gamblingSimulated ?? apple_utils_1.Rating.NONE,
+            horrorOrFearThemes: attributes.horrorOrFearThemes ?? apple_utils_1.Rating.NONE,
+            kidsAgeBand: attributes.kidsAgeBand ?? null,
+            koreaAgeRatingOverride: attributes.koreaAgeRatingOverride ?? apple_utils_1.KoreaRatingOverride.NONE,
+            lootBox: attributes.lootBox ?? false,
+            matureOrSuggestiveThemes: attributes.matureOrSuggestiveThemes ?? apple_utils_1.Rating.NONE,
+            medicalOrTreatmentInformation: attributes.medicalOrTreatmentInformation ?? apple_utils_1.Rating.NONE,
+            profanityOrCrudeHumor: attributes.profanityOrCrudeHumor ?? apple_utils_1.Rating.NONE,
+            sexualContentGraphicAndNudity: attributes.sexualContentGraphicAndNudity ?? apple_utils_1.Rating.NONE,
+            sexualContentOrNudity: attributes.sexualContentOrNudity ?? apple_utils_1.Rating.NONE,
+            unrestrictedWebAccess: attributes.unrestrictedWebAccess ?? false,
+            violenceCartoonOrFantasy: attributes.violenceCartoonOrFantasy ?? apple_utils_1.Rating.NONE,
+            violenceRealistic: attributes.violenceRealistic ?? apple_utils_1.Rating.NONE,
+            violenceRealisticProlongedGraphicOrSadistic: attributes.violenceRealisticProlongedGraphicOrSadistic ?? apple_utils_1.Rating.NONE,
+        };
+    }
+    setInfoLocale(attributes) {
+        this.schema.info = this.schema.info ?? {};
+        const existing = this.schema.info[attributes.locale] ?? {};
+        this.schema.info[attributes.locale] = {
+            ...existing,
+            title: attributes.name ?? '',
+            subtitle: optional(attributes.subtitle),
+            privacyPolicyUrl: optional(attributes.privacyPolicyUrl),
+            privacyPolicyText: optional(attributes.privacyPolicyText),
+            privacyChoicesUrl: optional(attributes.privacyChoicesUrl),
+        };
+    }
+    setCategories(attributes) {
+        this.schema.categories = undefined;
+        if (!attributes.primaryCategory && !attributes.secondaryCategory) {
+            return;
+        }
+        this.schema.categories = [];
+        if (attributes.primaryCategory && attributes.primarySubcategoryOne) {
+            this.schema.categories[0] = [
+                attributes.primaryCategory.id,
+                attributes.primarySubcategoryOne?.id,
+                attributes.primarySubcategoryTwo?.id,
+            ].filter(Boolean);
+        }
+        else {
+            // If only the secondaryCategory was provided,
+            // autofill with an empty string and cause a store config error.
+            this.schema.categories[0] = attributes.primaryCategory?.id ?? '';
+        }
+        if (attributes.secondaryCategory && attributes.secondarySubcategoryOne) {
+            this.schema.categories[1] = [
+                attributes.secondaryCategory.id,
+                attributes.secondarySubcategoryOne?.id,
+                attributes.secondarySubcategoryTwo?.id,
+            ].filter(Boolean);
+        }
+        else if (attributes.secondaryCategory) {
+            this.schema.categories[1] = attributes.secondaryCategory.id;
+        }
+    }
+    setVersion(attributes) {
+        this.schema.version = optional(attributes.versionString);
+        this.schema.copyright = optional(attributes.copyright);
+    }
+    setVersionReleaseType(attributes) {
+        if (attributes.releaseType === apple_utils_1.ReleaseType.SCHEDULED && attributes.earliestReleaseDate) {
+            this.schema.release = {
+                ...this.schema.release,
+                automaticRelease: attributes.earliestReleaseDate,
+            };
+        }
+        if (attributes.releaseType === apple_utils_1.ReleaseType.AFTER_APPROVAL) {
+            this.schema.release = {
+                ...this.schema.release,
+                automaticRelease: true,
+            };
+        }
+        if (attributes.releaseType === apple_utils_1.ReleaseType.MANUAL) {
+            this.schema.release = {
+                ...this.schema.release,
+                automaticRelease: false,
+            };
+        }
+    }
+    setVersionReleasePhased(attributes) {
+        if (!attributes) {
+            delete this.schema.release?.phasedRelease;
+        }
+        else {
+            this.schema.release = {
+                ...this.schema.release,
+                phasedRelease: true,
+            };
+        }
+    }
+    setVersionLocale(attributes) {
+        this.schema.info = this.schema.info ?? {};
+        const existing = this.schema.info[attributes.locale] ?? {};
+        this.schema.info[attributes.locale] = {
+            ...existing,
+            description: optional(attributes.description),
+            keywords: optional(attributes.keywords)
+                ?.split(',')
+                .map(keyword => keyword.trim()),
+            releaseNotes: optional(attributes.whatsNew),
+            marketingUrl: optional(attributes.marketingUrl),
+            promoText: optional(attributes.promotionalText),
+            supportUrl: optional(attributes.supportUrl),
+        };
+    }
+    setReviewDetails(attributes) {
+        this.schema.review = {
+            firstName: attributes.contactFirstName ?? '',
+            lastName: attributes.contactLastName ?? '',
+            email: attributes.contactEmail ?? '',
+            phone: attributes.contactPhone ?? '',
+            demoUsername: optional(attributes.demoAccountName),
+            demoPassword: optional(attributes.demoAccountPassword),
+            demoRequired: optional(attributes.demoAccountRequired),
+            notes: optional(attributes.notes),
+            // TODO: add attachment
+        };
+    }
+}
+exports.AppleConfigWriter = AppleConfigWriter;
+/** Helper function to convert `T | null` to `T | undefined`, required for the entity properties */
+function optional(value) {
+    return value ?? undefined;
+}

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

@@ -0,0 +1,20 @@
+import type { App } from '@expo/apple-utils';
+import type { AgeRatingData } from './tasks/age-rating';
+import type { AppInfoData } from './tasks/app-info';
+import type { AppReviewData } from './tasks/app-review-detail';
+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 type AppleData = {
+    app: App;
+} & AppInfoData & AppVersionData & AgeRatingData & AppReviewData;
+/**
+ * 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 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/rules/index.d.ts

@@ -0,0 +1 @@
+export declare const appleRules: import("../../config/issue").IssueRule<import("../../config/schema").MetadataConfig>[];

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.appleRules = void 0;
+const infoKeywordLength_1 = require("./infoKeywordLength");
+const infoRestrictedWords_1 = require("./infoRestrictedWords");
+exports.appleRules = [infoKeywordLength_1.infoKeywordLength, infoRestrictedWords_1.infoRestrictedWords];

package/build/metadata/apple/rules/infoKeywordLength.d.ts

@@ -0,0 +1,6 @@
+import { IssueRule } from '../../config/issue';
+/**
+ * Keywords are limited to 100 characters when converted to a comma separated string.
+ * @see https://developer-mdn.apple.com/app-store/search/
+ */
+export declare const infoKeywordLength: IssueRule;

package/build/metadata/apple/rules/infoKeywordLength.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoKeywordLength = void 0;
+const filter_1 = require("../../../utils/expodash/filter");
+const KEYWORD_CHARACTER_LIMIT = 100;
+/**
+ * Keywords are limited to 100 characters when converted to a comma separated string.
+ * @see https://developer-mdn.apple.com/app-store/search/
+ */
+exports.infoKeywordLength = {
+    id: 'apple.info.keyword.length',
+    severity: 2,
+    validate(config) {
+        if (!config.apple?.info || Object.keys(config.apple.info).length === 0) {
+            return null;
+        }
+        return Object.keys(config.apple.info)
+            .map(locale => {
+            const keywords = config.apple?.info?.[locale].keywords ?? [];
+            const length = keywords.join(',').length;
+            if (length > KEYWORD_CHARACTER_LIMIT) {
+                return {
+                    id: this.id,
+                    severity: this.severity,
+                    path: ['apple', 'info', locale, 'keywords'],
+                    message: `Keywords are limited to ${KEYWORD_CHARACTER_LIMIT} characters, but found ${length}.`,
+                };
+            }
+            return null;
+        })
+            .filter(filter_1.truthy);
+    },
+};

package/build/metadata/apple/rules/infoRestrictedWords.d.ts

@@ -0,0 +1,6 @@
+import { IssueRule } from '../../config/issue';
+/**
+ * Apple restricts certain words from being used in name, description, or keywords.
+ * Using these words likely result in a rejection.
+ */
+export declare const infoRestrictedWords: IssueRule;

package/build/metadata/apple/rules/infoRestrictedWords.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infoRestrictedWords = void 0;
+const filter_1 = require("../../../utils/expodash/filter");
+const RESTRICTED_PROPERTIES = ['title', 'subtitle', 'description', 'keywords'];
+const RESTRICTED_WORDS = {
+    beta: 'Apple restricts the word "beta" and synonyms implying incomplete functionality.',
+};
+/**
+ * Apple restricts certain words from being used in name, description, or keywords.
+ * Using these words likely result in a rejection.
+ */
+exports.infoRestrictedWords = {
+    id: 'apple.info.restrictedWords',
+    severity: 1,
+    validate(config) {
+        if (!config.apple?.info || Object.keys(config.apple.info).length === 0) {
+            return null;
+        }
+        return Object.keys(config.apple.info)
+            .map(locale => RESTRICTED_PROPERTIES.map(property => {
+            const value = getStringValue(config.apple?.info?.[locale][property]);
+            const issueDescription = getDescriptionForFirstMatch(value);
+            if (issueDescription) {
+                return {
+                    id: this.id,
+                    severity: this.severity,
+                    path: ['apple', 'info', locale, property],
+                    message: issueDescription,
+                };
+            }
+            return null;
+        }).filter(filter_1.truthy))
+            .filter(filter_1.truthy)
+            .flat();
+    },
+};
+function getDescriptionForFirstMatch(value) {
+    const sanitized = value.toLowerCase();
+    for (const [word, description] of Object.entries(RESTRICTED_WORDS)) {
+        if (sanitized.includes(word)) {
+            return description;
+        }
+    }
+    return null;
+}
+function getStringValue(value) {
+    if (!value) {
+        return '';
+    }
+    if (Array.isArray(value)) {
+        return value.join(' ');
+    }
+    return value;
+}

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 type TaskPrepareOptions = {
+    context: PartialAppleData;
+};
+export type TaskDownloadOptions = {
+    config: AppleConfigWriter;
+    context: AppleData;
+};
+export 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,12 @@
+import { AgeRatingDeclaration } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export 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,35 @@
+"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 {
+    name = () => 'age rating declarations';
+    async prepareAsync({ context }) {
+        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,14 @@
+import { AppInfo, AppInfoLocalization } from '@expo/apple-utils';
+import { AppleTask, TaskDownloadOptions, TaskPrepareOptions, TaskUploadOptions } from '../task';
+export 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,81 @@
+"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 {
+    name = () => 'app information';
+    async prepareAsync({ context }) {
+        let info = await (0, retry_1.retryIfNullAsync)(() => context.app.getEditAppInfoAsync());
+        // Fallback to live app info if no editable info is found (for metadata:pull)
+        if (!info) {
+            info = await context.app.getLiveAppInfoAsync();
+        }
+        if (!info) {
+            // No app info available - this is OK for metadata:pull
+            // when the app hasn't been set up yet
+            return;
+        }
+        context.info = info;
+        context.infoLocales = await info.getLocalizationsAsync();
+    }
+    async downloadAsync({ config, context }) {
+        if (!context.info) {
+            // No app info available to download - skip silently
+            return;
+        }
+        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;