eas-cli 12.3.0 → 12.4.0

package/build/commands/worker/alias.js

@@ -0,0 +1,170 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const ora_1 = require("../../ora");
+const prompts_1 = require("../../prompts");
+const json_1 = require("../../utils/json");
+const deployment_1 = require("../../worker/deployment");
+const logs_1 = require("../../worker/utils/logs");
+class WorkerAlias extends EasCommand_1.default {
+    async runAsync() {
+        // NOTE(cedric): `Log.warn` uses `console.log`, which is incorrect when running with `--json`
+        // eslint-disable-next-line no-console
+        console.warn(chalk_1.default.yellow('EAS Worker Deployments are in beta and subject to breaking changes.'));
+        const { flags: rawFlags } = await this.parse(_a);
+        const flags = this.sanitizeFlags(rawFlags);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
+            nonInteractive: true,
+        });
+        const { projectId } = await getDynamicPrivateProjectConfigAsync();
+        const aliasName = await resolveDeploymentAliasAsync(flags);
+        const deploymentId = await resolveDeploymentIdAsync({
+            ...flags,
+            graphqlClient,
+            projectId,
+            aliasName,
+        });
+        let progress = null;
+        let deploymentAlias = null;
+        if (aliasName) {
+            try {
+                progress = (0, ora_1.ora)((0, chalk_1.default) `Assigning alias {bold ${aliasName}} to deployment`).start();
+                deploymentAlias = await (0, deployment_1.assignWorkerDeploymentAliasAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId,
+                    aliasName,
+                });
+                progress.text = (0, chalk_1.default) `Assigned alias {bold ${aliasName}} to deployment`;
+            }
+            catch (error) {
+                progress?.fail((0, chalk_1.default) `Failed to assign {bold ${aliasName}} alias to deployment`);
+                throw error;
+            }
+        }
+        let deploymentProdAlias = null;
+        if (flags.isProduction) {
+            try {
+                progress = (progress ?? (0, ora_1.ora)()).start((0, chalk_1.default) `Promoting deployment to {bold production}`);
+                deploymentProdAlias = await (0, deployment_1.assignWorkerDeploymentProductionAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId,
+                });
+                progress.text = (0, chalk_1.default) `Promoted deployment to {bold production}`;
+            }
+            catch (error) {
+                progress?.fail((0, chalk_1.default) `Failed to promote deployment to {bold production}`);
+                throw error;
+            }
+        }
+        progress?.succeed(!deploymentAlias
+            ? (0, chalk_1.default) `Promoted deployment to {bold production}`
+            : (0, chalk_1.default) `Promoted deployment to {bold production} with alias {bold ${deploymentAlias.aliasName}}`);
+        // Either use the alias, or production deployment information
+        const deployment = deploymentAlias?.workerDeployment ?? deploymentProdAlias?.workerDeployment;
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)((0, logs_1.formatWorkerDeploymentJson)({
+                projectId,
+                deployment: deployment,
+                aliases: [deploymentAlias].filter(Boolean),
+                production: deploymentProdAlias,
+            }));
+            return;
+        }
+        log_1.default.addNewLineIfNone();
+        log_1.default.log(`🎉 Your deployment is modified`);
+        log_1.default.addNewLineIfNone();
+        log_1.default.log((0, logs_1.formatWorkerDeploymentTable)({
+            projectId,
+            deployment: deployment,
+            aliases: [deploymentAlias].filter(Boolean),
+            production: deploymentProdAlias,
+        }));
+    }
+    sanitizeFlags(flags) {
+        return {
+            nonInteractive: flags['non-interactive'],
+            json: flags['json'],
+            aliasName: flags.alias?.trim().toLowerCase(),
+            deploymentIdentifier: flags.id?.trim().toLowerCase(),
+            isProduction: flags.prod,
+        };
+    }
+}
+_a = WorkerAlias;
+WorkerAlias.description = 'Assign deployment aliases';
+WorkerAlias.aliases = ['deploy:alias', 'deploy:promote'];
+// TODO(@kitten): Keep command hidden until worker deployments are live
+WorkerAlias.hidden = true;
+WorkerAlias.state = 'beta';
+WorkerAlias.flags = {
+    prod: core_1.Flags.boolean({
+        aliases: ['production'],
+        description: 'Promote an existing deployment to production',
+        default: false,
+    }),
+    alias: core_1.Flags.string({
+        description: 'Custom alias to assign to the existing deployment',
+        helpValue: 'name',
+        required: false,
+    }),
+    id: core_1.Flags.string({
+        description: 'Unique identifier of an existing deployment',
+        helpValue: 'xyz123',
+        required: false,
+    }),
+    ...flags_1.EasNonInteractiveAndJsonFlags,
+};
+WorkerAlias.contextDefinition = {
+    ..._a.ContextOptions.DynamicProjectConfig,
+    ..._a.ContextOptions.ProjectDir,
+    ..._a.ContextOptions.LoggedIn,
+};
+exports.default = WorkerAlias;
+async function resolveDeploymentAliasAsync(flags) {
+    if (flags.aliasName?.trim()) {
+        return flags.aliasName.trim().toLowerCase();
+    }
+    // Skip alias prompt when promoting deployments to prod
+    if (flags.isProduction) {
+        return null;
+    }
+    if (flags.nonInteractive) {
+        throw new Error('The `--alias` flag must be set when running in `--non-interactive` mode.');
+    }
+    const { alias: aliasName } = await (0, prompts_1.promptAsync)({
+        type: 'text',
+        name: 'alias',
+        message: 'Enter the alias to assign to a deployment',
+        validate: (value) => !!value.trim(),
+        hint: 'The alias name is case insensitive and must be URL safe',
+    });
+    return aliasName.trim().toLowerCase();
+}
+async function resolveDeploymentIdAsync({ graphqlClient, deploymentIdentifier, aliasName, projectId, nonInteractive, }) {
+    if (deploymentIdentifier) {
+        return deploymentIdentifier;
+    }
+    if (nonInteractive) {
+        throw new Error('The `--id` flag must be set when running in `--non-interactive` mode.');
+    }
+    const deployment = await (0, deployment_1.selectWorkerDeploymentOnAppAsync)({
+        graphqlClient,
+        appId: projectId,
+        selectTitle: (0, chalk_1.default) `deployment to assign the {underline ${aliasName}} alias`,
+    });
+    if (!deployment) {
+        throw new Error('No deployments found for this project, create a new deployment with "eas deploy"');
+    }
+    return deployment.deploymentIdentifier;
+}

package/build/commands/worker/deploy.d.ts

@@ -1,10 +1,20 @@
 import EasCommand from '../../commandUtils/EasCommand';
+import { EnvironmentVariableEnvironment } from '../../graphql/generated';
 export default class WorkerDeploy extends EasCommand {
     static description: string;
     static aliases: string[];
+    static usage: string[];
     static hidden: boolean;
     static state: string;
-    static flags: {};
+    static flags: {
+        environment: import("@oclif/core/lib/interfaces").OptionFlag<EnvironmentVariableEnvironment | undefined>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        prod: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        alias: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        id: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined>;
+        'export-dir': import("@oclif/core/lib/interfaces").OptionFlag<string>;
+    };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;
         projectDir: import("../../commandUtils/context/ProjectDirContextField").default;
@@ -12,4 +22,5 @@ export default class WorkerDeploy extends EasCommand {
         getDynamicPrivateProjectConfigAsync: import("../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
     };
     runAsync(): Promise<void>;
+    private sanitizeFlags;
 }

package/build/commands/worker/deploy.js

@@ -2,68 +2,52 @@
 var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
+const timeago_js_1 = require("@expo/timeago.js");
+const core_1 = require("@oclif/core");
 const chalk_1 = tslib_1.__importDefault(require("chalk"));
 const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
 const path = tslib_1.__importStar(require("node:path"));
 const EasCommand_1 = tslib_1.__importDefault(require("../../commandUtils/EasCommand"));
+const flags_1 = require("../../commandUtils/flags");
 const log_1 = tslib_1.__importDefault(require("../../log"));
 const ora_1 = require("../../ora");
+const json_1 = require("../../utils/json");
 const progress_1 = require("../../utils/progress");
 const WorkerAssets = tslib_1.__importStar(require("../../worker/assets"));
 const deployment_1 = require("../../worker/deployment");
 const upload_1 = require("../../worker/upload");
+const logs_1 = require("../../worker/utils/logs");
 const isDirectory = (directoryPath) => node_fs_1.default.promises
     .stat(directoryPath)
     .then(stat => stat.isDirectory())
     .catch(() => false);
 class WorkerDeploy extends EasCommand_1.default {
     async runAsync() {
-        log_1.default.warn('EAS Worker Deployments are in beta and subject to breaking changes.');
-        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, } = await this.getContextAsync(_a, {
-            nonInteractive: true,
-        });
-        const { projectId, projectDir, exp } = await getDynamicPrivateProjectConfigAsync();
-        const distPath = path.resolve(projectDir, 'dist');
-        let distServerPath;
-        let distClientPath;
-        if (exp.web?.output === 'static') {
-            distClientPath = distPath;
-            distServerPath = null;
-            if (!(await isDirectory(distClientPath))) {
-                throw new Error(`No "dist/" folder found. Prepare your project for deployment with "npx expo export"`);
-            }
-            log_1.default.log('Detected "static" worker deployment');
-        }
-        else if (exp.web?.output === 'server') {
-            distClientPath = path.resolve(distPath, 'client');
-            distServerPath = path.resolve(distPath, 'server');
-            if (!(await isDirectory(distClientPath))) {
-                throw new Error(`No "dist/client/" folder found. Prepare your project for deployment with "npx expo export"`);
-            }
-            else if (!(await isDirectory(distServerPath))) {
-                throw new Error(`No "dist/server/" folder found. Prepare your project for deployment with "npx expo export"`);
-            }
-            log_1.default.log('Detected "server" worker deployment');
-        }
-        else {
-            throw new Error(`Single-page apps are not supported. Ensure that app.json key "expo.web.output" is set to "server" or "static".`);
+        // NOTE(cedric): `Log.warn` uses `console.log`, which is incorrect when running with `--json`
+        // eslint-disable-next-line no-console
+        console.warn(chalk_1.default.yellow('EAS Worker Deployments are in beta and subject to breaking changes.'));
+        const { flags: rawFlags } = await this.parse(_a);
+        const flags = this.sanitizeFlags(rawFlags);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
         }
-        async function* emitWorkerTarballAsync(assetMap) {
-            yield ['assets.json', JSON.stringify(assetMap)];
-            // TODO: Create manifest from user configuration
-            const manifest = { env: {} };
-            yield ['manifest.json', JSON.stringify(manifest)];
-            if (distServerPath) {
-                const workerFiles = WorkerAssets.listWorkerFilesAsync(distServerPath);
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, projectDir, } = await this.getContextAsync(_a, flags);
+        const [{ projectId }, projectDist] = await Promise.all([
+            getDynamicPrivateProjectConfigAsync(),
+            resolveExportedProjectAsync(flags, projectDir),
+        ]);
+        logExportedProjectInfo(projectDist);
+        async function* emitWorkerTarballAsync(params) {
+            yield ['assets.json', JSON.stringify(params.assetMap)];
+            yield ['manifest.json', JSON.stringify(params.manifest)];
+            if (projectDist.type === 'server' && projectDist.serverPath) {
+                const workerFiles = WorkerAssets.listWorkerFilesAsync(projectDist.serverPath);
                 for await (const workerFile of workerFiles) {
                     yield [`server/${workerFile.normalizedPath}`, workerFile.data];
                 }
             }
         }
-        async function uploadTarballAsync(tarPath) {
-            const uploadUrl = await (0, deployment_1.getSignedDeploymentUrlAsync)(graphqlClient, exp, {
-                appId: projectId,
-            });
+        async function uploadTarballAsync(tarPath, uploadUrl) {
             const { response } = await (0, upload_1.uploadAsync)({
                 url: uploadUrl,
                 filePath: tarPath,
@@ -74,7 +58,7 @@ class WorkerDeploy extends EasCommand_1.default {
             });
             if (response.status === 413) {
                 throw new Error('Upload failed! (Payload too large)\n' +
-                    `The files in "dist/server/" (at: ${distServerPath}) exceed the maximum file size (10MB gzip).`);
+                    `The files in "${path.relative(projectDir, projectDist.path)}" (at: ${projectDir}) exceed the maximum file size (10MB gzip).`);
             }
             else if (!response.ok) {
                 throw new Error(`Upload failed! (${response.statusText})`);
@@ -93,7 +77,8 @@ class WorkerDeploy extends EasCommand_1.default {
             }
             // TODO(@kitten): Batch and upload multiple files in parallel
             const uploadParams = [];
-            for await (const asset of WorkerAssets.listAssetMapFilesAsync(distClientPath, assetMap)) {
+            const assetPath = projectDist.type === 'server' ? projectDist.clientPath : projectDist.path;
+            for await (const asset of WorkerAssets.listAssetMapFilesAsync(assetPath, assetMap)) {
                 const uploadURL = uploads[asset.normalizedPath];
                 if (uploadURL) {
                     uploadParams.push({ url: uploadURL, filePath: asset.path });
@@ -110,9 +95,9 @@ class WorkerDeploy extends EasCommand_1.default {
                 message(ratio) {
                     const percent = `${Math.floor(ratio * 100)}`;
                     const details = chalk_1.default.dim(`(${progress.pending} Pending, ${progress.transferred} Completed, ${progress.total} Total)`);
-                    return `Uploading client assets: ${percent.padStart(3)}% ${details}`;
+                    return `Uploading assets: ${percent.padStart(3)}% ${details}`;
                 },
-                completedMessage: 'Uploaded assets for serverless deployment',
+                completedMessage: 'Uploaded assets',
             });
             try {
                 for await (const signal of (0, upload_1.batchUploadAsync)(uploadParams)) {
@@ -132,46 +117,151 @@ class WorkerDeploy extends EasCommand_1.default {
             }
             updateProgress({ isComplete: true });
         }
-        let progress = (0, ora_1.ora)('Preparing worker upload');
         let assetMap;
         let tarPath;
-        try {
-            assetMap = await WorkerAssets.createAssetMapAsync(distClientPath);
-            tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync(assetMap));
-        }
-        catch (error) {
-            progress.fail('Failed to prepare worker upload');
-            throw error;
-        }
-        progress.succeed('Prepared worker upload');
-        progress = (0, ora_1.ora)('Creating worker deployment');
         let deployResult;
+        let progress = (0, ora_1.ora)('Preparing project').start();
         try {
-            deployResult = await uploadTarballAsync(tarPath);
+            const manifest = await WorkerAssets.createManifestAsync({
+                environment: flags.environment,
+                projectDir,
+                projectId,
+            }, graphqlClient);
+            assetMap = await WorkerAssets.createAssetMapAsync(projectDist.type === 'server' ? projectDist.clientPath : projectDist.path);
+            tarPath = await WorkerAssets.packFilesIterableAsync(emitWorkerTarballAsync({
+                assetMap,
+                manifest,
+            }));
+            const uploadUrl = await (0, deployment_1.getSignedDeploymentUrlAsync)(graphqlClient, {
+                appId: projectId,
+                deploymentIdentifier: flags.deploymentIdentifier,
+                // NOTE(cedric): this function might ask the user for a dev-domain name,
+                // when that happens, no ora spinner should be running.
+                onSetupDevDomain: () => progress.stop(),
+                nonInteractive: flags.nonInteractive,
+            });
+            progress.start('Creating deployment');
+            deployResult = await uploadTarballAsync(tarPath, uploadUrl);
+            progress.succeed('Created deployment');
         }
         catch (error) {
-            progress.fail('Failed to create worker deployment');
+            progress.fail('Failed to create deployment');
             throw error;
         }
-        progress.succeed('Created worker deployment');
         await uploadAssetsAsync(assetMap, deployResult.uploads);
-        const baseDomain = process.env.EXPO_STAGING ? 'staging.expo' : 'expo';
-        const deploymentURL = `https://${deployResult.fullName}.${baseDomain}.app`;
-        const deploymentsUrl = `https://${baseDomain}.dev/accounts/${exp.owner}/projects/${deployResult.name}/serverless/deployments`;
+        let deploymentAlias = null;
+        if (flags.aliasName) {
+            progress = (0, ora_1.ora)((0, chalk_1.default) `Assigning alias {bold ${flags.aliasName}} to deployment`).start();
+            try {
+                deploymentAlias = await (0, deployment_1.assignWorkerDeploymentAliasAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId: deployResult.id,
+                    aliasName: flags.aliasName,
+                });
+                // Only stop the spinner when not promoting to production
+                if (!flags.isProduction) {
+                    progress.succeed((0, chalk_1.default) `Assigned alias {bold ${flags.aliasName}} to deployment`);
+                }
+            }
+            catch (error) {
+                progress.fail((0, chalk_1.default) `Failed to assign {bold ${flags.aliasName}} alias to deployment`);
+                throw error;
+            }
+        }
+        let deploymentProdAlias = null;
+        if (flags.isProduction) {
+            try {
+                if (!flags.aliasName) {
+                    progress = (0, ora_1.ora)((0, chalk_1.default) `Promoting deployment to {bold production}`).start();
+                }
+                else {
+                    progress.text = (0, chalk_1.default) `Promoting deployment to {bold production}`;
+                }
+                deploymentProdAlias = await (0, deployment_1.assignWorkerDeploymentProductionAsync)({
+                    graphqlClient,
+                    appId: projectId,
+                    deploymentId: deployResult.id,
+                });
+                progress.succeed(!flags.aliasName
+                    ? (0, chalk_1.default) `Promoted deployment to {bold production}`
+                    : (0, chalk_1.default) `Promoted deployment to {bold production} with alias {bold ${flags.aliasName}}`);
+            }
+            catch (error) {
+                progress.fail('Failed to promote deployment to production');
+                throw error;
+            }
+        }
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)((0, logs_1.formatWorkerDeploymentJson)({
+                projectId,
+                deployment: {
+                    deploymentIdentifier: deployResult.id,
+                    url: (0, logs_1.getDeploymentUrlFromFullName)(deployResult.fullName),
+                },
+                aliases: [deploymentAlias].filter(Boolean),
+                production: deploymentProdAlias,
+            }));
+            return;
+        }
         log_1.default.addNewLineIfNone();
-        log_1.default.log(`🎉 Your worker deployment is ready: ${deploymentURL}`);
+        log_1.default.log(`🎉 Your deployment is ready`);
         log_1.default.addNewLineIfNone();
-        log_1.default.log(`🔗 Manage on EAS: ${deploymentsUrl}`);
+        log_1.default.log((0, logs_1.formatWorkerDeploymentTable)({
+            projectId,
+            deployment: {
+                deploymentIdentifier: deployResult.id,
+                url: (0, logs_1.getDeploymentUrlFromFullName)(deployResult.fullName),
+            },
+            aliases: [deploymentAlias].filter(Boolean),
+            production: deploymentProdAlias,
+        }));
+        if (!deploymentProdAlias) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.log('🚀 When you are ready to deploy to production:');
+            log_1.default.log((0, chalk_1.default) `  $ eas deploy {bold --prod}`);
+        }
+    }
+    sanitizeFlags(flags) {
+        return {
+            nonInteractive: flags['non-interactive'],
+            json: flags['json'],
+            isProduction: !!flags.prod,
+            aliasName: flags.alias?.trim().toLowerCase(),
+            deploymentIdentifier: flags.id?.trim(),
+            exportDir: flags['export-dir'],
+        };
     }
 }
 _a = WorkerDeploy;
-WorkerDeploy.description = 'deploy an Expo web build';
+WorkerDeploy.description = 'Deploy your Expo web build';
 WorkerDeploy.aliases = ['deploy'];
+WorkerDeploy.usage = [(0, chalk_1.default) `deploy {dim [options]}`, `deploy --prod`];
 // TODO(@kitten): Keep command hidden until worker deployments are live
 WorkerDeploy.hidden = true;
 WorkerDeploy.state = 'beta';
 WorkerDeploy.flags = {
-// TODO(@kitten): Allow deployment identifier to be specified
+    prod: core_1.Flags.boolean({
+        aliases: ['production'],
+        description: 'Create a new production deployment',
+        default: false,
+    }),
+    alias: core_1.Flags.string({
+        description: 'Custom alias to assign to the new deployment',
+        helpValue: 'name',
+    }),
+    id: core_1.Flags.string({
+        description: 'Custom unique identifier for the new deployment',
+        helpValue: 'xyz123',
+    }),
+    'export-dir': core_1.Flags.string({
+        description: 'Directory where the Expo project was exported',
+        helpValue: 'dir',
+        default: 'dist',
+    }),
+    // TODO(@kitten): Allow deployment identifier to be specified
+    ...flags_1.EasNonInteractiveAndJsonFlags,
+    ...flags_1.EASEnvironmentFlag,
 };
 WorkerDeploy.contextDefinition = {
     ..._a.ContextOptions.DynamicProjectConfig,
@@ -179,3 +269,21 @@ WorkerDeploy.contextDefinition = {
     ..._a.ContextOptions.LoggedIn,
 };
 exports.default = WorkerDeploy;
+async function resolveExportedProjectAsync(flags, projectDir) {
+    const exportPath = path.join(projectDir, flags.exportDir);
+    const serverPath = path.join(exportPath, 'server');
+    const clientPath = path.join(exportPath, 'client');
+    const [hasServerPath, hasClientPath, modifiedAt] = await Promise.all([
+        isDirectory(serverPath),
+        isDirectory(clientPath),
+        node_fs_1.default.promises.stat(exportPath).then(stat => stat.mtime),
+    ]);
+    if (hasServerPath && hasClientPath) {
+        return { type: 'server', path: exportPath, modifiedAt, serverPath, clientPath };
+    }
+    return { type: 'static', path: exportPath, modifiedAt };
+}
+function logExportedProjectInfo(project) {
+    const modifiedAgo = (0, timeago_js_1.format)(project.modifiedAt);
+    log_1.default.log((0, chalk_1.default) `{dim > Project export: ${project.type} - created ${modifiedAgo}}`);
+}