@donotuse/eas-cli 18.5.0-rc.1

package/build/credentials/android/api/graphql/mutations/AndroidAppCredentialsMutation.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidAppCredentialsMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AndroidAppCredentials_1 = require("../../../../../graphql/types/credentials/AndroidAppCredentials");
+exports.AndroidAppCredentialsMutation = {
+    async createAndroidAppCredentialsAsync(graphqlClient, androidAppCredentialsInput, appId, applicationIdentifier) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAndroidAppCredentialsMutation(
+              $androidAppCredentialsInput: AndroidAppCredentialsInput!
+              $appId: ID!
+              $applicationIdentifier: String!
+            ) {
+              androidAppCredentials {
+                createAndroidAppCredentials(
+                  androidAppCredentialsInput: $androidAppCredentialsInput
+                  appId: $appId
+                  applicationIdentifier: $applicationIdentifier
+                ) {
+                  id
+                  ...CommonAndroidAppCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppCredentials_1.CommonAndroidAppCredentialsFragmentNode)}
+          `, {
+            androidAppCredentialsInput,
+            appId,
+            applicationIdentifier,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppCredentials.createAndroidAppCredentials, 'GraphQL: `createAndroidAppCredentials` not defined in server response');
+        return data.androidAppCredentials.createAndroidAppCredentials;
+    },
+    async setFcmKeyAsync(graphqlClient, androidAppCredentialsId, fcmId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation SetFcmMutation($androidAppCredentialsId: ID!, $fcmId: ID!) {
+              androidAppCredentials {
+                setFcm(id: $androidAppCredentialsId, fcmId: $fcmId) {
+                  id
+                  ...CommonAndroidAppCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppCredentials_1.CommonAndroidAppCredentialsFragmentNode)}
+          `, {
+            androidAppCredentialsId,
+            fcmId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppCredentials.setFcm, 'GraphQL: `setFcm` not defined in server response');
+        return data.androidAppCredentials.setFcm;
+    },
+    async setGoogleServiceAccountKeyForSubmissionsAsync(graphqlClient, androidAppCredentialsId, googleServiceAccountKeyId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation SetGoogleServiceAccountKeyForSubmissionsMutation(
+              $androidAppCredentialsId: ID!
+              $googleServiceAccountKeyId: ID!
+            ) {
+              androidAppCredentials {
+                setGoogleServiceAccountKeyForSubmissions(
+                  id: $androidAppCredentialsId
+                  googleServiceAccountKeyId: $googleServiceAccountKeyId
+                ) {
+                  id
+                  ...CommonAndroidAppCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppCredentials_1.CommonAndroidAppCredentialsFragmentNode)}
+          `, {
+            androidAppCredentialsId,
+            googleServiceAccountKeyId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppCredentials.setGoogleServiceAccountKeyForSubmissions, 'GraphQL: `setGoogleServiceAccountKeyForSubmissions` not defined in server response');
+        return data.androidAppCredentials.setGoogleServiceAccountKeyForSubmissions;
+    },
+    async setGoogleServiceAccountKeyForFcmV1Async(graphqlClient, androidAppCredentialsId, googleServiceAccountKeyId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation SetGoogleServiceAccountKeyForFcmV1Mutation(
+              $androidAppCredentialsId: ID!
+              $googleServiceAccountKeyId: ID!
+            ) {
+              androidAppCredentials {
+                setGoogleServiceAccountKeyForFcmV1(
+                  id: $androidAppCredentialsId
+                  googleServiceAccountKeyId: $googleServiceAccountKeyId
+                ) {
+                  id
+                  ...CommonAndroidAppCredentialsFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppCredentials_1.CommonAndroidAppCredentialsFragmentNode)}
+          `, {
+            androidAppCredentialsId,
+            googleServiceAccountKeyId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidAppCredentials.setGoogleServiceAccountKeyForFcmV1, 'GraphQL: `setGoogleServiceAccountKeyForFcmV1` not defined in server response');
+        return data.androidAppCredentials.setGoogleServiceAccountKeyForFcmV1;
+    },
+};

package/build/credentials/android/api/graphql/mutations/AndroidFcmMutation.d.ts

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AndroidFcmFragment, AndroidFcmInput } from '../../../../../graphql/generated';
+export declare const AndroidFcmMutation: {
+    createAndroidFcmAsync(graphqlClient: ExpoGraphqlClient, androidFcmInput: AndroidFcmInput, accountId: string): Promise<AndroidFcmFragment>;
+    deleteAndroidFcmAsync(graphqlClient: ExpoGraphqlClient, androidFcmId: string): Promise<void>;
+};

package/build/credentials/android/api/graphql/mutations/AndroidFcmMutation.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidFcmMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AndroidFcm_1 = require("../../../../../graphql/types/credentials/AndroidFcm");
+exports.AndroidFcmMutation = {
+    async createAndroidFcmAsync(graphqlClient, androidFcmInput, accountId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAndroidFcmMutation($androidFcmInput: AndroidFcmInput!, $accountId: ID!) {
+              androidFcm {
+                createAndroidFcm(androidFcmInput: $androidFcmInput, accountId: $accountId) {
+                  id
+                  ...AndroidFcmFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidFcm_1.AndroidFcmFragmentNode)}
+          `, {
+            androidFcmInput,
+            accountId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidFcm.createAndroidFcm, 'GraphQL: `createAndroidFcm` not defined in server response');
+        return data.androidFcm.createAndroidFcm;
+    },
+    async deleteAndroidFcmAsync(graphqlClient, androidFcmId) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteAndroidFcmMutation($androidFcmId: ID!) {
+              androidFcm {
+                deleteAndroidFcm(id: $androidFcmId) {
+                  id
+                }
+              }
+            }
+          `, {
+            androidFcmId,
+        }, {
+            additionalTypenames: ['AndroidFcm', 'AndroidAppCredentials'],
+        })
+            .toPromise());
+    },
+};

package/build/credentials/android/api/graphql/mutations/AndroidKeystoreMutation.d.ts

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AndroidKeystoreFragment, AndroidKeystoreInput } from '../../../../../graphql/generated';
+export declare const AndroidKeystoreMutation: {
+    createAndroidKeystoreAsync(graphqlClient: ExpoGraphqlClient, androidKeystoreInput: AndroidKeystoreInput, accountId: string): Promise<AndroidKeystoreFragment>;
+    deleteAndroidKeystoreAsync(graphqlClient: ExpoGraphqlClient, androidKeystoreId: string): Promise<void>;
+};

package/build/credentials/android/api/graphql/mutations/AndroidKeystoreMutation.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidKeystoreMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AndroidKeystore_1 = require("../../../../../graphql/types/credentials/AndroidKeystore");
+exports.AndroidKeystoreMutation = {
+    async createAndroidKeystoreAsync(graphqlClient, androidKeystoreInput, accountId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateAndroidKeystoreMutation(
+              $androidKeystoreInput: AndroidKeystoreInput!
+              $accountId: ID!
+            ) {
+              androidKeystore {
+                createAndroidKeystore(
+                  androidKeystoreInput: $androidKeystoreInput
+                  accountId: $accountId
+                ) {
+                  id
+                  ...AndroidKeystoreFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidKeystore_1.AndroidKeystoreFragmentNode)}
+          `, {
+            androidKeystoreInput,
+            accountId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.androidKeystore.createAndroidKeystore, 'GraphQL: `createAndroidKeystore` not defined in server response');
+        return data.androidKeystore.createAndroidKeystore;
+    },
+    async deleteAndroidKeystoreAsync(graphqlClient, androidKeystoreId) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteAndroidKeystoreMutation($androidKeystoreId: ID!) {
+              androidKeystore {
+                deleteAndroidKeystore(id: $androidKeystoreId) {
+                  id
+                }
+              }
+            }
+          `, {
+            androidKeystoreId,
+        }, {
+            additionalTypenames: ['AndroidKeystore', 'AndroidAppBuildCredentials'],
+        })
+            .toPromise());
+    },
+};

package/build/credentials/android/api/graphql/mutations/GoogleServiceAccountKeyMutation.d.ts

@@ -0,0 +1,6 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { GoogleServiceAccountKeyFragment, GoogleServiceAccountKeyInput } from '../../../../../graphql/generated';
+export declare const GoogleServiceAccountKeyMutation: {
+    createGoogleServiceAccountKeyAsync(graphqlClient: ExpoGraphqlClient, googleServiceAccountKeyInput: GoogleServiceAccountKeyInput, accountId: string): Promise<GoogleServiceAccountKeyFragment>;
+    deleteGoogleServiceAccountKeyAsync(graphqlClient: ExpoGraphqlClient, googleServiceAccountKeyId: string): Promise<void>;
+};

package/build/credentials/android/api/graphql/mutations/GoogleServiceAccountKeyMutation.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleServiceAccountKeyMutation = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const GoogleServiceAccountKey_1 = require("../../../../../graphql/types/credentials/GoogleServiceAccountKey");
+exports.GoogleServiceAccountKeyMutation = {
+    async createGoogleServiceAccountKeyAsync(graphqlClient, googleServiceAccountKeyInput, accountId) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation CreateGoogleServiceAccountKeyMutation(
+              $googleServiceAccountKeyInput: GoogleServiceAccountKeyInput!
+              $accountId: ID!
+            ) {
+              googleServiceAccountKey {
+                createGoogleServiceAccountKey(
+                  googleServiceAccountKeyInput: $googleServiceAccountKeyInput
+                  accountId: $accountId
+                ) {
+                  id
+                  ...GoogleServiceAccountKeyFragment
+                }
+              }
+            }
+            ${(0, graphql_1.print)(GoogleServiceAccountKey_1.GoogleServiceAccountKeyFragmentNode)}
+          `, {
+            googleServiceAccountKeyInput,
+            accountId,
+        })
+            .toPromise());
+        (0, assert_1.default)(data.googleServiceAccountKey.createGoogleServiceAccountKey, 'GraphQL: `createAndroidFcm` not defined in server response');
+        return data.googleServiceAccountKey.createGoogleServiceAccountKey;
+    },
+    async deleteGoogleServiceAccountKeyAsync(graphqlClient, googleServiceAccountKeyId) {
+        await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .mutation((0, graphql_tag_1.default) `
+            mutation DeleteGoogleServiceAccountKeyMutation($googleServiceAccountKeyId: ID!) {
+              googleServiceAccountKey {
+                deleteGoogleServiceAccountKey(id: $googleServiceAccountKeyId) {
+                  id
+                }
+              }
+            }
+          `, {
+            googleServiceAccountKeyId,
+        }, {
+            additionalTypenames: ['GoogleServiceAccountKey', 'AndroidAppCredentials'],
+        })
+            .toPromise());
+    },
+};

package/build/credentials/android/api/graphql/queries/AndroidAppCredentialsQuery.d.ts

@@ -0,0 +1,8 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { CommonAndroidAppCredentialsFragment } from '../../../../../graphql/generated';
+export declare const AndroidAppCredentialsQuery: {
+    withCommonFieldsByApplicationIdentifierAsync(graphqlClient: ExpoGraphqlClient, projectFullName: string, { androidApplicationIdentifier, legacyOnly, }: {
+        androidApplicationIdentifier?: string;
+        legacyOnly?: boolean;
+    }): Promise<CommonAndroidAppCredentialsFragment | null>;
+};

package/build/credentials/android/api/graphql/queries/AndroidAppCredentialsQuery.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AndroidAppCredentialsQuery = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const AndroidAppCredentials_1 = require("../../../../../graphql/types/credentials/AndroidAppCredentials");
+exports.AndroidAppCredentialsQuery = {
+    async withCommonFieldsByApplicationIdentifierAsync(graphqlClient, projectFullName, { androidApplicationIdentifier, legacyOnly, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query CommonAndroidAppCredentialsWithBuildCredentialsByApplicationIdentifierQuery(
+              $projectFullName: String!
+              $applicationIdentifier: String
+              $legacyOnly: Boolean
+            ) {
+              app {
+                byFullName(fullName: $projectFullName) {
+                  id
+                  androidAppCredentials(
+                    filter: {
+                      applicationIdentifier: $applicationIdentifier
+                      legacyOnly: $legacyOnly
+                    }
+                  ) {
+                    id
+                    ...CommonAndroidAppCredentialsFragment
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(AndroidAppCredentials_1.CommonAndroidAppCredentialsFragmentNode)}
+          `, {
+            projectFullName,
+            applicationIdentifier: androidApplicationIdentifier,
+            legacyOnly,
+        }, {
+            additionalTypenames: [
+                'AndroidAppCredentials',
+                'AndroidAppBuildCredentials',
+                'App',
+                'AndroidFcm',
+            ],
+        })
+            .toPromise());
+        (0, assert_1.default)(data.app, 'GraphQL: `app` not defined in server response');
+        return data.app.byFullName.androidAppCredentials[0] ?? null;
+    },
+};

package/build/credentials/android/api/graphql/queries/GoogleServiceAccountKeyQuery.d.ts

@@ -0,0 +1,11 @@
+import { ExpoGraphqlClient } from '../../../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { GoogleServiceAccountKeyFragment, GoogleServiceAccountKeysPaginatedByAccountQuery } from '../../../../../graphql/generated';
+export declare const GoogleServiceAccountKeyQuery: {
+    getAllForAccountAsync(graphqlClient: ExpoGraphqlClient, accountName: string): Promise<GoogleServiceAccountKeyFragment[]>;
+    getAllForAccountPaginatedAsync(graphqlClient: ExpoGraphqlClient, accountName: string, { after, first, before, last, }: {
+        after?: string;
+        first?: number;
+        before?: string;
+        last?: number;
+    }): Promise<GoogleServiceAccountKeysPaginatedByAccountQuery["account"]["byName"]["googleServiceAccountKeysPaginated"]>;
+};

package/build/credentials/android/api/graphql/queries/GoogleServiceAccountKeyQuery.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleServiceAccountKeyQuery = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const graphql_tag_1 = tslib_1.__importDefault(require("graphql-tag"));
+const client_1 = require("../../../../../graphql/client");
+const GoogleServiceAccountKey_1 = require("../../../../../graphql/types/credentials/GoogleServiceAccountKey");
+const relay_1 = require("../../../../../utils/relay");
+exports.GoogleServiceAccountKeyQuery = {
+    async getAllForAccountAsync(graphqlClient, accountName) {
+        const paginatedGetterAsync = async (relayArgs) => {
+            return await exports.GoogleServiceAccountKeyQuery.getAllForAccountPaginatedAsync(graphqlClient, accountName, relayArgs);
+        };
+        return await (0, relay_1.fetchEntireDatasetAsync)({
+            paginatedGetterAsync,
+            progressBarLabel: 'fetching Google Service Account Keys...',
+        });
+    },
+    async getAllForAccountPaginatedAsync(graphqlClient, accountName, { after, first, before, last, }) {
+        const data = await (0, client_1.withErrorHandlingAsync)(graphqlClient
+            .query((0, graphql_tag_1.default) `
+            query GoogleServiceAccountKeysPaginatedByAccountQuery(
+              $accountName: String!
+              $after: String
+              $first: Int
+              $before: String
+              $last: Int
+            ) {
+              account {
+                byName(accountName: $accountName) {
+                  id
+                  googleServiceAccountKeysPaginated(
+                    after: $after
+                    first: $first
+                    before: $before
+                    last: $last
+                  ) {
+                    edges {
+                      cursor
+                      node {
+                        id
+                        ...GoogleServiceAccountKeyFragment
+                      }
+                    }
+                    pageInfo {
+                      hasNextPage
+                      hasPreviousPage
+                      startCursor
+                      endCursor
+                    }
+                  }
+                }
+              }
+            }
+            ${(0, graphql_1.print)(GoogleServiceAccountKey_1.GoogleServiceAccountKeyFragmentNode)}
+          `, {
+            accountName,
+            after,
+            first,
+            before,
+            last,
+        }, {
+            additionalTypenames: ['GoogleServiceAccountKey'],
+        })
+            .toPromise());
+        return data.account.byName.googleServiceAccountKeysPaginated;
+    },
+};

package/build/credentials/android/credentials.d.ts

@@ -0,0 +1,26 @@
+import { AndroidKeystoreType } from '../../graphql/generated';
+import { CredentialSchema } from '../utils/promptForCredentials';
+export interface FcmCredentials {
+    fcmApiKey: string;
+}
+export interface Keystore {
+    keystore: string;
+    keystorePassword: string;
+    keyAlias: string;
+    keyPassword?: string;
+}
+export type KeystoreWithType = Keystore & {
+    type: AndroidKeystoreType;
+};
+export type GoogleServiceAccountKey = {
+    [key: string]: any;
+    private_key: string;
+    type: string;
+    client_email: string;
+};
+export type AndroidCredentials = {
+    experienceName: string;
+    keystore: Keystore | null;
+    pushCredentials: FcmCredentials | null;
+};
+export declare const keystoreSchema: CredentialSchema<Keystore>;

package/build/credentials/android/credentials.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keystoreSchema = void 0;
+exports.keystoreSchema = {
+    name: 'Android Keystore',
+    provideMethodQuestion: {
+        question: `Generate a new Android Keystore?`,
+    },
+    questions: [
+        {
+            field: 'keystore',
+            question: 'Path to the Keystore file.',
+            type: 'file',
+            base64Encode: true,
+        },
+        {
+            field: 'keystorePassword',
+            question: 'Keystore password',
+            type: 'password',
+        },
+        {
+            field: 'keyAlias',
+            question: 'Key alias',
+            type: 'string',
+        },
+        {
+            field: 'keyPassword',
+            question: 'Key password',
+            type: 'password',
+        },
+    ],
+};

package/build/credentials/android/utils/googleServiceAccountKey.d.ts

@@ -0,0 +1,7 @@
+import Joi from 'joi';
+import { GoogleServiceAccountKeyFragment } from '../../../graphql/generated';
+import { GoogleServiceAccountKey } from '../credentials';
+export declare const MinimalGoogleServiceAccountKeySchema: Joi.ObjectSchema<any>;
+export declare function readAndValidateServiceAccountKey(keyJsonPath: string): GoogleServiceAccountKey;
+export declare function selectGoogleServiceAccountKeyAsync(keys: GoogleServiceAccountKeyFragment[]): Promise<GoogleServiceAccountKeyFragment>;
+export declare function detectGoogleServiceAccountKeyPathAsync(projectDir: string): Promise<string | null>;

package/build/credentials/android/utils/googleServiceAccountKey.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinimalGoogleServiceAccountKeySchema = void 0;
+exports.readAndValidateServiceAccountKey = readAndValidateServiceAccountKey;
+exports.selectGoogleServiceAccountKeyAsync = selectGoogleServiceAccountKeyAsync;
+exports.detectGoogleServiceAccountKeyPathAsync = detectGoogleServiceAccountKeyPathAsync;
+const tslib_1 = require("tslib");
+const json_file_1 = tslib_1.__importDefault(require("@expo/json-file"));
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fast_glob_1 = tslib_1.__importDefault(require("fast-glob"));
+const joi_1 = tslib_1.__importDefault(require("joi"));
+const path_1 = tslib_1.__importDefault(require("path"));
+const log_1 = tslib_1.__importStar(require("../../../log"));
+const prompts_1 = require("../../../prompts");
+const date_1 = require("../../../utils/date");
+exports.MinimalGoogleServiceAccountKeySchema = joi_1.default.object({
+    type: joi_1.default.string().required(),
+    private_key: joi_1.default.string().required(),
+    client_email: joi_1.default.string().required(),
+});
+function fileIsServiceAccountKey(keyJsonPath) {
+    try {
+        readAndValidateServiceAccountKey(keyJsonPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readAndValidateServiceAccountKey(keyJsonPath) {
+    try {
+        const jsonKeyObject = json_file_1.default.read(keyJsonPath);
+        const { error, value } = exports.MinimalGoogleServiceAccountKeySchema.validate(jsonKeyObject, {
+            abortEarly: false,
+            allowUnknown: true,
+        });
+        if (error) {
+            const maybeGoogleServicesJson = keyJsonPath.includes('google-services');
+            if (maybeGoogleServicesJson) {
+                log_1.default.error(`Oops! Looks like you uploaded a google-services.json instead of your service account key. ${(0, log_1.learnMore)('https://expo.fyi/creating-google-service-account')}`);
+            }
+            throw new Error(`Google Service Account JSON Key is not valid [${error.toString()}].`);
+        }
+        return value;
+    }
+    catch (err) {
+        if (err.code === 'EJSONPARSE') {
+            err.message = `Found invalid JSON in Google Service Account JSON Key. ${err.message}`;
+        }
+        throw err;
+    }
+}
+async function selectGoogleServiceAccountKeyAsync(keys) {
+    const sortedKeys = sortGoogleServiceAccountKeysByUpdatedAtDesc(keys);
+    const { chosenKey } = await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'chosenKey',
+        message: 'Select a Google Service Account Key:',
+        choices: sortedKeys.map(key => ({
+            title: formatGoogleServiceAccountKey(key),
+            value: key,
+        })),
+    });
+    return chosenKey;
+}
+function sortGoogleServiceAccountKeysByUpdatedAtDesc(keys) {
+    return keys.sort((keyA, keyB) => new Date(keyB.updatedAt).getTime() - new Date(keyA.updatedAt).getTime());
+}
+function formatGoogleServiceAccountKey({ projectIdentifier, privateKeyIdentifier, clientEmail, clientIdentifier, updatedAt, }) {
+    let line = `Client Email: ${clientEmail}, Project Id: ${projectIdentifier}`;
+    line += chalk_1.default.gray(`\n    Client Id: ${clientIdentifier}, Private Key Id: ${privateKeyIdentifier}`);
+    line += chalk_1.default.gray(`\n    Updated: ${(0, date_1.fromNow)(new Date(updatedAt))} ago,`);
+    return line;
+}
+async function detectGoogleServiceAccountKeyPathAsync(projectDir) {
+    const foundFilePaths = await (0, fast_glob_1.default)('**/*.json', {
+        cwd: projectDir,
+        ignore: ['app.json', 'package*.json', 'tsconfig.json', 'node_modules', 'google-services.json'],
+    });
+    const googleServiceFiles = foundFilePaths
+        .map(file => path_1.default.join(projectDir, file))
+        .filter(fileIsServiceAccountKey);
+    if (googleServiceFiles.length > 1) {
+        const selectedPath = await displayPathChooserAsync(googleServiceFiles, projectDir);
+        if (selectedPath) {
+            return selectedPath;
+        }
+    }
+    else if (googleServiceFiles.length === 1) {
+        const [detectedPath] = googleServiceFiles;
+        if (await confirmDetectedPathAsync(detectedPath)) {
+            return detectedPath;
+        }
+    }
+    return null;
+}
+async function displayPathChooserAsync(paths, projectDir) {
+    const choices = paths.map(f => ({
+        value: f,
+        title: f.startsWith(projectDir) ? path_1.default.relative(projectDir, f) : f,
+    }));
+    choices.push({
+        title: 'None of the above',
+        value: null,
+    });
+    log_1.default.log('Multiple Google Service Account JSON keys have been found inside your project directory.');
+    const { selectedPath } = await (0, prompts_1.promptAsync)({
+        name: 'selectedPath',
+        type: 'select',
+        message: 'Choose the key you want to use:',
+        choices,
+    });
+    log_1.default.addNewLineIfNone();
+    return selectedPath;
+}
+async function confirmDetectedPathAsync(path) {
+    log_1.default.log(`A Google Service Account JSON key has been found at\n  ${chalk_1.default.underline(path)}`);
+    const confirm = await (0, prompts_1.confirmAsync)({
+        message: 'Would you like to use this file?',
+    });
+    log_1.default.addNewLineIfNone();
+    return confirm;
+}

package/build/credentials/android/utils/keystore.d.ts

@@ -0,0 +1,5 @@
+import { Analytics } from '../../../analytics/AnalyticsManager';
+import { ExpoGraphqlClient } from '../../../commandUtils/context/contextUtils/createGraphqlClient';
+import { KeystoreWithType } from '../credentials';
+export declare function keytoolCommandExistsAsync(): Promise<boolean>;
+export declare function generateRandomKeystoreAsync(graphqlClient: ExpoGraphqlClient, analytics: Analytics, projectId: string): Promise<KeystoreWithType>;