@donotuse/eas-cli 18.5.0-rc.1

package/build/commands/project/init.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const config_1 = require("@expo/config");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const getProjectIdAsync_1 = require("../../commandUtils/context/contextUtils/getProjectIdAsync");
+const flags_1 = require("../../commandUtils/flags");
+const projectNameValidation_1 = require("../../commandUtils/projectNameValidation");
+const generated_1 = require("../../graphql/generated");
+const AppMutation_1 = require("../../graphql/mutations/AppMutation");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const ora_1 = require("../../ora");
+const expoConfig_1 = require("../../project/expoConfig");
+const fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1 = require("../../project/fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync");
+const prompts_1 = require("../../prompts");
+class ProjectInit extends EasCommand_1.default {
+    static description = 'create or link an EAS project';
+    static aliases = ['init'];
+    static flags = {
+        id: core_1.Flags.string({
+            description: 'ID of the EAS project to link',
+        }),
+        force: core_1.Flags.boolean({
+            description: 'Whether to create a new project/link an existing project without additional prompts or overwrite any existing project ID when running with --id flag',
+        }),
+        ...flags_1.EASNonInteractiveFlag,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+        ...this.ContextOptions.ProjectDir,
+    };
+    static async saveProjectIdAndLogSuccessAsync(projectDir, projectId) {
+        await (0, getProjectIdAsync_1.saveProjectIdToAppConfigAsync)(projectDir, projectId);
+        log_1.default.withTick(`Project successfully linked (ID: ${chalk_1.default.bold(projectId)}) (modified app.json)`);
+    }
+    static async modifyExpoConfigAsync(projectDir, modifications) {
+        let result;
+        try {
+            result = await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDir, modifications);
+        }
+        catch (error) {
+            if (error instanceof config_1.ConfigError && error.code === 'MODULE_NOT_FOUND') {
+                log_1.default.warn('Cannot determine which native SDK version your project uses because the module `expo` is not installed.');
+                return;
+            }
+            else {
+                throw error;
+            }
+        }
+        switch (result.type) {
+            case 'success':
+                break;
+            case 'warn': {
+                log_1.default.warn();
+                log_1.default.warn(`Warning: Your project uses dynamic app configuration, and cannot be automatically modified.`);
+                log_1.default.warn(chalk_1.default.dim('https://docs.expo.dev/workflow/configuration/#dynamic-configuration-with-appconfigjs'));
+                log_1.default.warn();
+                log_1.default.warn(`To complete the setup process, add the following in your ${chalk_1.default.bold((0, config_1.getProjectConfigDescription)(projectDir))}:`);
+                log_1.default.warn();
+                log_1.default.warn(chalk_1.default.bold(JSON.stringify(modifications, null, 2)));
+                log_1.default.warn();
+                throw new Error(result.message);
+            }
+            case 'fail':
+                throw new Error(result.message);
+            default:
+                throw new Error('Unexpected result type from modifyConfigAsync');
+        }
+    }
+    static async ensureOwnerSlugConsistencyAsync(graphqlClient, projectId, projectDir, { force, nonInteractive }) {
+        const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir);
+        const appForProjectId = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
+        const correctOwner = appForProjectId.ownerAccount.name;
+        const correctSlug = appForProjectId.slug;
+        if (exp.owner && exp.owner !== correctOwner) {
+            if (force) {
+                await this.modifyExpoConfigAsync(projectDir, { owner: correctOwner });
+            }
+            else {
+                const message = `Project owner (${correctOwner}) does not match the value configured in the "owner" field (${exp.owner}).`;
+                if (nonInteractive) {
+                    throw new Error(`Project config error: ${message} Use --force flag to overwrite.`);
+                }
+                const confirm = await (0, prompts_1.confirmAsync)({
+                    message: `${message}. Do you wish to overwrite it?`,
+                });
+                if (!confirm) {
+                    throw new Error('Aborting');
+                }
+                await this.modifyExpoConfigAsync(projectDir, { owner: correctOwner });
+            }
+        }
+        else if (!exp.owner) {
+            await this.modifyExpoConfigAsync(projectDir, { owner: correctOwner });
+        }
+        if (exp.slug && exp.slug !== correctSlug) {
+            if (force) {
+                await this.modifyExpoConfigAsync(projectDir, { slug: correctSlug });
+            }
+            else {
+                const message = `Project slug (${correctSlug}) does not match the value configured in the "slug" field (${exp.slug}).`;
+                if (nonInteractive) {
+                    throw new Error(`Project config error: ${message} Use --force flag to overwrite.`);
+                }
+                const confirm = await (0, prompts_1.confirmAsync)({
+                    message: `${message}. Do you wish to overwrite it?`,
+                });
+                if (!confirm) {
+                    throw new Error('Aborting');
+                }
+                await this.modifyExpoConfigAsync(projectDir, { slug: correctSlug });
+            }
+        }
+        else if (!exp.slug) {
+            await this.modifyExpoConfigAsync(projectDir, { slug: correctSlug });
+        }
+    }
+    static async setExplicitIDAsync(projectId, projectDir, { force, nonInteractive }) {
+        const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir);
+        const existingProjectId = exp.extra?.eas?.projectId;
+        if (projectId === existingProjectId) {
+            log_1.default.succeed(`Project already linked (ID: ${chalk_1.default.bold(existingProjectId)})`);
+            return;
+        }
+        if (!existingProjectId) {
+            await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, projectId);
+            return;
+        }
+        if (projectId !== existingProjectId) {
+            if (force) {
+                await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, projectId);
+                return;
+            }
+            if (nonInteractive) {
+                throw new Error(`Project is already linked to a different ID: ${chalk_1.default.bold(existingProjectId)}. Use --force flag to overwrite.`);
+            }
+            const confirm = await (0, prompts_1.confirmAsync)({
+                message: `Project is already linked to a different ID: ${chalk_1.default.bold(existingProjectId)}. Do you wish to overwrite it?`,
+            });
+            if (!confirm) {
+                throw new Error('Aborting');
+            }
+            await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, projectId);
+        }
+    }
+    static async initializeWithExplicitIDAsync(projectId, projectDir, { force, nonInteractive }) {
+        await this.setExplicitIDAsync(projectId, projectDir, {
+            force,
+            nonInteractive,
+        });
+    }
+    static async initializeWithoutExplicitIDAsync(graphqlClient, actor, projectDir, { force, nonInteractive }) {
+        const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDir);
+        const existingProjectId = exp.extra?.eas?.projectId;
+        if (existingProjectId) {
+            log_1.default.succeed(`Project already linked (ID: ${chalk_1.default.bold(existingProjectId)}). To re-configure, remove the "extra.eas.projectId" field from your app config.`);
+            return existingProjectId;
+        }
+        const allAccounts = actor.accounts;
+        const accountNamesWhereUserHasSufficientPermissionsToCreateApp = new Set(allAccounts
+            .filter(a => a.users.find(it => it.actor.id === actor.id)?.role !== generated_1.Role.ViewOnly)
+            .map(it => it.name));
+        // if no owner field, ask the user which account they want to use to create/link the project
+        let accountName = exp.owner;
+        if (!accountName) {
+            if (allAccounts.length === 1) {
+                accountName = allAccounts[0].name;
+            }
+            else if (nonInteractive) {
+                if (!force) {
+                    throw new Error(`There are multiple accounts that you have access to: ${allAccounts
+                        .map(a => a.name)
+                        .join(', ')}. Explicitly set the owner property in your app config or run this command with the --force flag to proceed with a default account: ${allAccounts[0].name}.`);
+                }
+                accountName = allAccounts[0].name;
+                log_1.default.log(`Using default account ${accountName} for non-interactive and force mode`);
+            }
+            else {
+                const choices = ProjectInit.getAccountChoices(actor, accountNamesWhereUserHasSufficientPermissionsToCreateApp);
+                accountName = (await (0, prompts_1.promptAsync)({
+                    type: 'select',
+                    name: 'account',
+                    message: 'Which account should own this project?',
+                    choices,
+                })).account.name;
+            }
+        }
+        if (!accountName) {
+            throw new Error('No account selected for project. Canceling.');
+        }
+        const projectName = (0, projectNameValidation_1.validSlugName)(exp.slug); // This filters out invalid characters
+        const projectFullName = `@${accountName}/${projectName}`;
+        (0, projectNameValidation_1.validateFullNameAndSlug)(projectFullName, projectName);
+        const existingProjectIdOnServer = await (0, fetchOrCreateProjectIDForWriteToConfigWithConfirmationAsync_1.findProjectIdByAccountNameAndSlugNullableAsync)(graphqlClient, accountName, projectName);
+        if (existingProjectIdOnServer) {
+            if (!force) {
+                if (nonInteractive) {
+                    throw new Error(`Existing project found: ${projectFullName} (ID: ${existingProjectIdOnServer}). Use --force flag to continue with this project.`);
+                }
+                const affirmedLink = await (0, prompts_1.confirmAsync)({
+                    message: `Existing project found: ${projectFullName} (ID: ${existingProjectIdOnServer}). Link this project?`,
+                });
+                if (!affirmedLink) {
+                    throw new Error(`Project ID configuration canceled. Re-run the command to select a different account/project.`);
+                }
+            }
+            await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, existingProjectIdOnServer);
+            return existingProjectIdOnServer;
+        }
+        if (!accountNamesWhereUserHasSufficientPermissionsToCreateApp.has(accountName)) {
+            throw new Error(`You don't have permission to create a new project on the ${accountName} account and no matching project already exists on the account.`);
+        }
+        if (!force) {
+            if (nonInteractive) {
+                throw new Error(`Project does not exist: ${projectFullName}. Use --force flag to create this project.`);
+            }
+            const affirmedCreate = await (0, prompts_1.confirmAsync)({
+                message: `Would you like to create a project for ${projectFullName}?`,
+            });
+            if (!affirmedCreate) {
+                throw new Error(`Project ID configuration canceled for ${projectFullName}.`);
+            }
+        }
+        const projectDashboardUrl = (0, url_1.getProjectDashboardUrl)(accountName, projectName);
+        const projectLink = (0, log_1.link)(projectDashboardUrl, { text: projectFullName });
+        const account = (0, nullthrows_1.default)(allAccounts.find(a => a.name === accountName));
+        const spinner = (0, ora_1.ora)(`Creating ${chalk_1.default.bold(projectFullName)}`).start();
+        let createdProjectId;
+        try {
+            createdProjectId = await AppMutation_1.AppMutation.createAppAsync(graphqlClient, {
+                accountId: account.id,
+                projectName,
+            });
+            spinner.succeed(`Created ${chalk_1.default.bold(projectLink)}`);
+        }
+        catch (err) {
+            spinner.fail();
+            throw err;
+        }
+        await ProjectInit.saveProjectIdAndLogSuccessAsync(projectDir, createdProjectId);
+        return createdProjectId;
+    }
+    static getAccountChoices(actor, namesWithSufficientPermissions) {
+        const allAccounts = actor.accounts;
+        const sortedAccounts = actor.__typename === 'Robot'
+            ? allAccounts
+            : [...allAccounts].sort((a, _b) => actor.__typename === 'User' ? (a.name === actor.username ? -1 : 1) : 0);
+        if (actor.__typename !== 'Robot') {
+            const personalAccount = allAccounts?.find(account => account?.ownerUserActor?.id === actor.id);
+            const personalAccountChoice = personalAccount
+                ? {
+                    title: personalAccount.name,
+                    value: personalAccount,
+                    description: !namesWithSufficientPermissions.has(personalAccount.name)
+                        ? '(Personal) (Viewer Role)'
+                        : '(Personal)',
+                }
+                : undefined;
+            const userAccounts = allAccounts
+                ?.filter(account => account.ownerUserActor && account.name !== actor.username)
+                .map(account => ({
+                title: account.name,
+                value: account,
+                description: !namesWithSufficientPermissions.has(account.name)
+                    ? '(Team) (Viewer Role)'
+                    : '(Team)',
+            }));
+            const organizationAccounts = allAccounts
+                ?.filter(account => account.name !== actor.username && !account.ownerUserActor)
+                .map(account => ({
+                title: account.name,
+                value: account,
+                description: !namesWithSufficientPermissions.has(account.name)
+                    ? '(Organization) (Viewer Role)'
+                    : '(Organization)',
+            }));
+            let choices = [];
+            if (personalAccountChoice) {
+                choices = [personalAccountChoice];
+            }
+            return [...choices, ...userAccounts, ...organizationAccounts].sort((a, _b) => actor.__typename === 'User' ? (a.value.name === actor.username ? -1 : 1) : 0);
+        }
+        return sortedAccounts.map(account => ({
+            title: account.name,
+            value: account,
+            description: !namesWithSufficientPermissions.has(account.name) ? '(Viewer Role)' : undefined,
+        }));
+    }
+    async runAsync() {
+        const { flags: { id: idArgument, force, 'non-interactive': nonInteractive }, } = await this.parse(ProjectInit);
+        const { loggedIn: { actor, graphqlClient }, projectDir, } = await this.getContextAsync(ProjectInit, { nonInteractive });
+        let idForConsistency;
+        if (idArgument) {
+            await ProjectInit.initializeWithExplicitIDAsync(idArgument, projectDir, {
+                force,
+                nonInteractive,
+            });
+            idForConsistency = idArgument;
+        }
+        else {
+            idForConsistency = await ProjectInit.initializeWithoutExplicitIDAsync(graphqlClient, actor, projectDir, {
+                force,
+                nonInteractive,
+            });
+        }
+        await ProjectInit.ensureOwnerSlugConsistencyAsync(graphqlClient, idForConsistency, projectDir, {
+            force,
+            nonInteractive,
+        });
+    }
+}
+exports.default = ProjectInit;

package/build/commands/project/new.d.ts

@@ -0,0 +1,34 @@
+import EasCommand from '../../commandUtils/EasCommand';
+import { ExpoGraphqlClient } from '../../commandUtils/context/contextUtils/createGraphqlClient';
+import { AppFragment } from '../../graphql/generated';
+import { PackageManager } from '../../onboarding/installDependencies';
+import { Actor } from '../../user/User';
+export declare function generateConfigsAsync(args: {
+    path?: string;
+}, actor: Actor, graphqlClient: ExpoGraphqlClient): Promise<{
+    projectName: string;
+    projectDirectory: string;
+    projectAccount: string;
+}>;
+export declare function createProjectAsync({ graphqlClient, actor, projectDirectory, projectAccount, projectName, }: {
+    graphqlClient: ExpoGraphqlClient;
+    actor: Actor;
+    projectDirectory: string;
+    projectAccount: string;
+    projectName: string;
+}): Promise<string>;
+export declare function generateProjectFilesAsync(projectDir: string, app: AppFragment, packageManager: PackageManager): Promise<void>;
+export default class New extends EasCommand {
+    static aliases: string[];
+    static description: string;
+    static args: {
+        path: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        'package-manager': import("@oclif/core/lib/interfaces").OptionFlag<"npm" | "pnpm" | "bun" | "yarn", import("@oclif/core/lib/interfaces").CustomOptions>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}

package/build/commands/project/new.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConfigsAsync = generateConfigsAsync;
+exports.createProjectAsync = createProjectAsync;
+exports.generateProjectFilesAsync = generateProjectFilesAsync;
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const nullthrows_1 = tslib_1.__importDefault(require("nullthrows"));
+const url_1 = require("../../build/utils/url");
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const commands_1 = require("../../commandUtils/new/commands");
+const configs_1 = require("../../commandUtils/new/configs");
+const projectFiles_1 = require("../../commandUtils/new/projectFiles");
+const utils_1 = require("../../commandUtils/new/utils");
+const AppMutation_1 = require("../../graphql/mutations/AppMutation");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const log_1 = tslib_1.__importStar(require("../../log"));
+const installDependencies_1 = require("../../onboarding/installDependencies");
+const ora_1 = require("../../ora");
+const expoConfig_1 = require("../../project/expoConfig");
+async function generateConfigsAsync(args, actor, graphqlClient) {
+    const projectAccount = await (0, configs_1.promptForProjectAccountAsync)(actor);
+    const { projectName, projectDirectory } = await (0, configs_1.generateProjectConfigAsync)(args.path, {
+        graphqlClient,
+        projectAccount,
+    });
+    return {
+        projectAccount,
+        projectDirectory,
+        projectName,
+    };
+}
+async function createProjectAsync({ graphqlClient, actor, projectDirectory, projectAccount, projectName, }) {
+    const projectFullName = `@${projectAccount}/${projectName}`;
+    const projectDashboardUrl = (0, url_1.getProjectDashboardUrl)(projectAccount, projectName);
+    const projectLink = (0, log_1.link)(projectDashboardUrl, { text: projectFullName });
+    const account = (0, nullthrows_1.default)(actor.accounts.find(a => a.name === projectAccount));
+    const spinner = (0, ora_1.ora)(`Creating ${chalk_1.default.bold(projectFullName)}`).start();
+    let projectId;
+    try {
+        projectId = await AppMutation_1.AppMutation.createAppAsync(graphqlClient, {
+            accountId: account.id,
+            projectName,
+        });
+        spinner.succeed(`Created ${chalk_1.default.bold(projectLink)}`);
+    }
+    catch (err) {
+        spinner.fail();
+        throw err;
+    }
+    const exp = await (0, expoConfig_1.getPrivateExpoConfigAsync)(projectDirectory, { skipPlugins: true });
+    await (0, expoConfig_1.createOrModifyExpoConfigAsync)(projectDirectory, {
+        extra: { ...exp.extra, eas: { ...exp.extra?.eas, projectId } },
+    }, { skipSDKVersionRequirement: true });
+    log_1.default.withInfo(`Project successfully linked (ID: ${chalk_1.default.bold(projectId)})`);
+    return projectId;
+}
+async function generateProjectFilesAsync(projectDir, app, packageManager) {
+    const spinner = (0, ora_1.ora)(`Generating project files`).start();
+    await (0, projectFiles_1.generateAppConfigAsync)(projectDir, app);
+    await (0, projectFiles_1.generateEasConfigAsync)(projectDir);
+    await (0, projectFiles_1.updatePackageJsonAsync)(projectDir);
+    await (0, projectFiles_1.copyProjectTemplatesAsync)(projectDir);
+    await (0, projectFiles_1.updateReadmeAsync)(projectDir, packageManager);
+    spinner.succeed(`Generated project files`);
+    log_1.default.withInfo(`Generated ${chalk_1.default.bold('app.json')}. ${(0, log_1.learnMore)('https://docs.expo.dev/versions/latest/config/app/')}`);
+    log_1.default.withInfo(`Generated ${chalk_1.default.bold('eas.json')}. ${(0, log_1.learnMore)('https://docs.expo.dev/build-reference/eas-json/')}`);
+}
+class New extends EasCommand_1.default {
+    static aliases = ['new'];
+    static description = 'Create a new project configured with Expo Application Services (EAS)';
+    static args = {
+        path: core_1.Args.string({
+            description: 'Path to create the project (defaults to current directory)',
+            required: false,
+        }),
+    };
+    static flags = {
+        'package-manager': core_1.Flags.option({
+            char: 'p',
+            description: 'Package manager to use for installing dependencies',
+            options: [...installDependencies_1.PACKAGE_MANAGERS],
+            default: 'npm',
+        })(),
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args, flags } = await this.parse(New);
+        const { loggedIn: { actor, graphqlClient }, } = await this.getContextAsync(New, { nonInteractive: false });
+        if (actor.__typename === 'Robot') {
+            throw new Error('This command is not available for robot users. Make sure you are not using a robot token and try again.');
+        }
+        log_1.default.log(`👋 Welcome to Expo, ${actor.username}!`);
+        const { projectName, projectDirectory: targetProjectDirectory, projectAccount, } = await generateConfigsAsync(args, actor, graphqlClient);
+        const projectDirectory = await (0, commands_1.cloneTemplateAsync)(targetProjectDirectory);
+        const packageManager = flags['package-manager'];
+        await (0, commands_1.installProjectDependenciesAsync)(projectDirectory, packageManager);
+        const projectId = await createProjectAsync({
+            projectDirectory,
+            projectAccount,
+            projectName,
+            actor,
+            graphqlClient,
+        });
+        const app = await AppQuery_1.AppQuery.byIdAsync(graphqlClient, projectId);
+        await generateProjectFilesAsync(projectDirectory, app, packageManager);
+        await (0, commands_1.initializeGitRepositoryAsync)(projectDirectory);
+        log_1.default.log('🎉 We finished creating your new project.');
+        log_1.default.newLine();
+        log_1.default.log('Next steps:');
+        log_1.default.withInfo(`Run ${chalk_1.default.bold(`cd ${(0, utils_1.printDirectory)(projectDirectory)}`)} to navigate to your project.`);
+        log_1.default.withInfo(`Run ${chalk_1.default.bold(`${packageManager} run draft`)} to create a preview on EAS. ${(0, log_1.learnMore)('https://docs.expo.dev/eas/workflows/examples/publish-preview-update/')}`);
+        log_1.default.withInfo(`Run ${chalk_1.default.bold(`${packageManager} run start`)} to start developing locally. ${(0, log_1.learnMore)('https://docs.expo.dev/get-started/start-developing/')}`);
+        log_1.default.withInfo(`See the ${chalk_1.default.bold('README.md')} for more information about your project.`);
+    }
+}
+exports.default = New;

package/build/commands/project/onboarding.d.ts

@@ -0,0 +1,14 @@
+import EasCommand from '../../commandUtils/EasCommand';
+export default class Onboarding extends EasCommand {
+    static aliases: string[];
+    static description: string;
+    static flags: {};
+    static args: {
+        TARGET_PROJECT_DIRECTORY: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static contextDefinition: {
+        analytics: import("../../commandUtils/context/AnalyticsContextField").default;
+        loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
+    };
+    runAsync(): Promise<void>;
+}