eas-cli 16.15.0 → 16.17.0

package/build/commandUtils/workflow/fetchLogs.d.ts

@@ -0,0 +1,2 @@
+import { WorkflowJobResult } from './types';
+export declare function fetchRawLogsForJobAsync(job: WorkflowJobResult): Promise<string | null>;

package/build/commandUtils/workflow/fetchLogs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchRawLogsForJobAsync = void 0;
+// This function is in a separate module for testing purposes
+async function fetchRawLogsForJobAsync(job) {
+    const firstLogFileUrl = job.turtleJobRun?.logFileUrls?.[0];
+    if (!firstLogFileUrl) {
+        return null;
+    }
+    const response = await fetch(firstLogFileUrl, {
+        method: 'GET',
+    });
+    const rawLogs = await response.text();
+    return rawLogs;
+}
+exports.fetchRawLogsForJobAsync = fetchRawLogsForJobAsync;

package/build/commandUtils/workflow/stateMachine.d.ts

@@ -0,0 +1,44 @@
+import { WorkflowJobResult, WorkflowLogs } from './types';
+import { ExpoGraphqlClient } from '../context/contextUtils/createGraphqlClient';
+export declare enum WorkflowCommandSelectionStateValue {
+    WORKFLOW_RUN_SELECTION = "WORKFLOW_RUN_SELECTION",
+    WORKFLOW_JOB_SELECTION = "WORKFLOW_JOB_SELECTION",
+    WORKFLOW_STEP_SELECTION = "WORKFLOW_STEP_SELECTION",
+    FINISH = "FINISH",
+    ERROR = "ERROR"
+}
+export type WorkflowCommandSelectionState = {
+    graphqlClient: ExpoGraphqlClient;
+    projectId: string;
+    nonInteractive: boolean;
+    allSteps: boolean;
+    state: WorkflowCommandSelectionStateValue;
+    runId?: string;
+    jobId?: string;
+    step?: string;
+    job?: WorkflowJobResult;
+    logs?: WorkflowLogs | null;
+    message?: string;
+};
+export type WorkflowCommandSelectionStateParameters = Omit<WorkflowCommandSelectionState, 'graphqlClient' | 'projectId' | 'state' | 'nonInteractive' | 'allSteps'>;
+export type WorkflowCommandSelectionAction = (prevState: WorkflowCommandSelectionState) => Promise<WorkflowCommandSelectionState>;
+export declare function moveToNewWorkflowCommandSelectionState(previousState: WorkflowCommandSelectionState, newStateValue: WorkflowCommandSelectionStateValue, parameters: WorkflowCommandSelectionStateParameters): WorkflowCommandSelectionState;
+export declare function moveToWorkflowRunSelectionState(previousState: WorkflowCommandSelectionState, params?: {
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowJobSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    jobId?: string | undefined;
+    runId?: string | undefined;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowStepSelectionState(previousState: WorkflowCommandSelectionState, params: {
+    job: WorkflowJobResult;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionFinishedState(previousState: WorkflowCommandSelectionState, params: {
+    step: string;
+    logs: WorkflowLogs;
+}): WorkflowCommandSelectionState;
+export declare function moveToWorkflowSelectionErrorState(previousState: WorkflowCommandSelectionState, message: string): WorkflowCommandSelectionState;
+export declare const workflowRunSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowJobSelectionAction: WorkflowCommandSelectionAction;
+export declare const workflowStepSelectionAction: WorkflowCommandSelectionAction;
+export declare const executeWorkflowSelectionActionsAsync: WorkflowCommandSelectionAction;

package/build/commandUtils/workflow/stateMachine.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeWorkflowSelectionActionsAsync = exports.workflowStepSelectionAction = exports.workflowJobSelectionAction = exports.workflowRunSelectionAction = exports.moveToWorkflowSelectionErrorState = exports.moveToWorkflowSelectionFinishedState = exports.moveToWorkflowStepSelectionState = exports.moveToWorkflowJobSelectionState = exports.moveToWorkflowRunSelectionState = exports.moveToNewWorkflowCommandSelectionState = exports.WorkflowCommandSelectionStateValue = void 0;
+const tslib_1 = require("tslib");
+const utils_1 = require("./utils");
+const AppQuery_1 = require("../../graphql/queries/AppQuery");
+const WorkflowJobQuery_1 = require("../../graphql/queries/WorkflowJobQuery");
+const WorkflowRunQuery_1 = require("../../graphql/queries/WorkflowRunQuery");
+const log_1 = tslib_1.__importDefault(require("../../log"));
+const prompts_1 = require("../../prompts");
+/*
+ * State machine types and functions for moving between different workflow command states
+ */
+var WorkflowCommandSelectionStateValue;
+(function (WorkflowCommandSelectionStateValue) {
+    WorkflowCommandSelectionStateValue["WORKFLOW_RUN_SELECTION"] = "WORKFLOW_RUN_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_JOB_SELECTION"] = "WORKFLOW_JOB_SELECTION";
+    WorkflowCommandSelectionStateValue["WORKFLOW_STEP_SELECTION"] = "WORKFLOW_STEP_SELECTION";
+    WorkflowCommandSelectionStateValue["FINISH"] = "FINISH";
+    WorkflowCommandSelectionStateValue["ERROR"] = "ERROR";
+})(WorkflowCommandSelectionStateValue || (exports.WorkflowCommandSelectionStateValue = WorkflowCommandSelectionStateValue = {}));
+const workflowCommandSelectionAllowedStateTransitions = {
+    WORKFLOW_JOB_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION,
+        WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    WORKFLOW_RUN_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+    ],
+    WORKFLOW_STEP_SELECTION: [
+        WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION,
+        WorkflowCommandSelectionStateValue.ERROR,
+        WorkflowCommandSelectionStateValue.FINISH,
+    ],
+    ERROR: [WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION],
+    FINISH: [],
+};
+function moveToNewWorkflowCommandSelectionState(previousState, newStateValue, parameters) {
+    if (!workflowCommandSelectionAllowedStateTransitions[previousState.state].includes(newStateValue)) {
+        const errorMessage = `Invalid state transition from ${previousState.state} to ${newStateValue}. Allowed transitions from ${previousState.state}: ${workflowCommandSelectionAllowedStateTransitions[previousState.state].join(', ')}`;
+        throw new Error(errorMessage);
+    }
+    return {
+        ...previousState,
+        state: newStateValue,
+        ...parameters,
+    };
+}
+exports.moveToNewWorkflowCommandSelectionState = moveToNewWorkflowCommandSelectionState;
+function moveToWorkflowRunSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION, {
+        runId: params?.runId,
+        jobId: undefined,
+    });
+}
+exports.moveToWorkflowRunSelectionState = moveToWorkflowRunSelectionState;
+function moveToWorkflowJobSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION, params);
+}
+exports.moveToWorkflowJobSelectionState = moveToWorkflowJobSelectionState;
+function moveToWorkflowStepSelectionState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION, params);
+}
+exports.moveToWorkflowStepSelectionState = moveToWorkflowStepSelectionState;
+function moveToWorkflowSelectionFinishedState(previousState, params) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.FINISH, params);
+}
+exports.moveToWorkflowSelectionFinishedState = moveToWorkflowSelectionFinishedState;
+function moveToWorkflowSelectionErrorState(previousState, message) {
+    return moveToNewWorkflowCommandSelectionState(previousState, WorkflowCommandSelectionStateValue.ERROR, {
+        message,
+    });
+}
+exports.moveToWorkflowSelectionErrorState = moveToWorkflowSelectionErrorState;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowRunSelectionAction = async (prevState) => {
+    const { graphqlClient, projectId, runId, jobId, allSteps } = prevState;
+    log_1.default.debug(`workflowRunSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (runId) {
+        return moveToWorkflowJobSelectionState(prevState, { runId });
+    }
+    const runs = await AppQuery_1.AppQuery.byIdWorkflowRunsFilteredByStatusAsync(graphqlClient, projectId, undefined, 20);
+    if (runs.length === 0) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No workflow runs found');
+    }
+    const processedRuns = (0, utils_1.processWorkflowRuns)(runs);
+    const choices = processedRuns.map(run => (0, utils_1.choiceFromWorkflowRun)(run));
+    const selectedId = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedRun',
+        message: 'Select a workflow run:',
+        choices,
+    })).selectedRun;
+    return moveToWorkflowJobSelectionState(prevState, { runId: selectedId });
+};
+exports.workflowRunSelectionAction = workflowRunSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowJobSelectionAction = async (prevState) => {
+    const { graphqlClient, runId, jobId, nonInteractive, allSteps } = prevState;
+    log_1.default.debug(`workflowJobSelectionAction: runId = ${runId}, jobId = ${jobId}, allSteps = ${allSteps}`);
+    if (jobId) {
+        let workflowJobResult = undefined;
+        try {
+            workflowJobResult = await WorkflowJobQuery_1.WorkflowJobQuery.byIdAsync(graphqlClient, jobId, {
+                useCache: false,
+            });
+            return moveToWorkflowStepSelectionState(prevState, { job: workflowJobResult });
+        }
+        catch { }
+        if (nonInteractive && !workflowJobResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job found that matched the provided ID');
+        }
+        else {
+            // The passed in ID may be a run ID, pass it back to run selection action
+            return moveToWorkflowRunSelectionState(prevState, { runId: jobId });
+        }
+    }
+    else {
+        // No job ID was passed in
+        if (nonInteractive) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow job ID provided in non-interactive mode');
+        }
+        else if (!runId) {
+            // If no jobId or runId, we should go back to run selection
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const workflowRunResult = await WorkflowRunQuery_1.WorkflowRunQuery.withJobsByIdAsync(graphqlClient, runId, {
+            useCache: false,
+        });
+        if (!workflowRunResult) {
+            return moveToWorkflowSelectionErrorState(prevState, 'No workflow run found that matched the provided ID');
+        }
+        const choices = [
+            ...workflowRunResult.jobs.map((job, i) => (0, utils_1.choiceFromWorkflowJob)(job, i)),
+            {
+                title: 'Go back and select a different workflow run',
+                value: -1,
+            },
+        ];
+        const selectedJobIndex = (await (0, prompts_1.promptAsync)({
+            type: 'select',
+            name: 'selectedJob',
+            message: 'Select a job:',
+            choices,
+        })).selectedJob;
+        if (selectedJobIndex === -1) {
+            return moveToWorkflowRunSelectionState(prevState);
+        }
+        const selectedJob = workflowRunResult.jobs[selectedJobIndex];
+        return moveToWorkflowStepSelectionState(prevState, { job: selectedJob });
+    }
+};
+exports.workflowJobSelectionAction = workflowJobSelectionAction;
+// eslint-disable-next-line async-protect/async-suffix
+const workflowStepSelectionAction = async (prevState) => {
+    const { job, allSteps } = prevState;
+    log_1.default.debug(`workflowStepSelectionAction: job = ${job?.id}, allSteps = ${allSteps}`);
+    if (!job) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No job found');
+    }
+    const logs = await (0, utils_1.processLogsFromJobAsync)(job);
+    if (!logs) {
+        return moveToWorkflowSelectionErrorState(prevState, 'No logs found');
+    }
+    if (allSteps) {
+        return moveToWorkflowSelectionFinishedState(prevState, { step: '', logs });
+    }
+    const choices = [
+        ...(0, utils_1.choicesFromWorkflowLogs)(logs),
+        {
+            title: 'Go back and select a different workflow job',
+            value: 'go-back',
+        },
+    ];
+    const selectedStep = (await (0, prompts_1.promptAsync)({
+        type: 'select',
+        name: 'selectedStep',
+        message: 'Select a step:',
+        choices,
+    })).selectedStep ?? '';
+    if (selectedStep === 'go-back') {
+        return moveToWorkflowJobSelectionState(prevState, {
+            runId: job.workflowRun.id,
+            jobId: undefined,
+        });
+    }
+    return moveToWorkflowSelectionFinishedState(prevState, { step: selectedStep, logs });
+};
+exports.workflowStepSelectionAction = workflowStepSelectionAction;
+const executeWorkflowSelectionActionsAsync = async (prevState) => {
+    let currentState = prevState;
+    while (currentState.state !== WorkflowCommandSelectionStateValue.FINISH &&
+        currentState.state !== WorkflowCommandSelectionStateValue.ERROR) {
+        log_1.default.debug(`${currentState.state}`);
+        switch (currentState.state) {
+            case WorkflowCommandSelectionStateValue.WORKFLOW_JOB_SELECTION:
+                currentState = await (0, exports.workflowJobSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_RUN_SELECTION:
+                currentState = await (0, exports.workflowRunSelectionAction)(currentState);
+                break;
+            case WorkflowCommandSelectionStateValue.WORKFLOW_STEP_SELECTION:
+                currentState = await (0, exports.workflowStepSelectionAction)(currentState);
+                break;
+        }
+    }
+    return currentState;
+};
+exports.executeWorkflowSelectionActionsAsync = executeWorkflowSelectionActionsAsync;

package/build/commandUtils/workflow/types.d.ts

@@ -0,0 +1,39 @@
+import { WorkflowJobByIdQuery, WorkflowRunByIdWithJobsQuery } from '../../graphql/generated';
+export declare enum WorkflowTriggerType {
+    MANUAL = "Manual",
+    GITHUB = "GitHub",
+    SCHEDULED = "Scheduled",
+    OTHER = "Other"
+}
+export type WorkflowRunResult = {
+    id: string;
+    status: string;
+    gitCommitMessage: string | null;
+    gitCommitHash: string | null;
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+    startedAt: string;
+    finishedAt: string;
+    workflowId: string;
+    workflowName: string | null;
+    workflowFileName: string;
+};
+export type WorkflowResult = {
+    id: string;
+    name?: string | null | undefined;
+    fileName: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type WorkflowJobResult = WorkflowRunByIdWithJobsQuery['workflowRuns']['byId']['jobs'][number] | WorkflowJobByIdQuery['workflowJobs']['byId'];
+export type WorkflowRunWithJobsResult = WorkflowRunResult & {
+    jobs: WorkflowJobResult[];
+    logs?: string;
+};
+export type WorkflowLogLine = {
+    time: string;
+    msg: string;
+    result?: string;
+    marker?: string;
+};
+export type WorkflowLogs = Map<string, WorkflowLogLine[]>;

package/build/commandUtils/workflow/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowTriggerType = void 0;
+/*
+ * Utility types for workflow commands
+ */
+var WorkflowTriggerType;
+(function (WorkflowTriggerType) {
+    WorkflowTriggerType["MANUAL"] = "Manual";
+    WorkflowTriggerType["GITHUB"] = "GitHub";
+    WorkflowTriggerType["SCHEDULED"] = "Scheduled";
+    WorkflowTriggerType["OTHER"] = "Other";
+})(WorkflowTriggerType || (exports.WorkflowTriggerType = WorkflowTriggerType = {}));

package/build/commandUtils/workflow/utils.d.ts

@@ -0,0 +1,12 @@
+import { WorkflowJobResult, WorkflowLogs, WorkflowRunResult, WorkflowTriggerType } from './types';
+import { WorkflowRunFragment } from '../../graphql/generated';
+import { Choice } from '../../prompts';
+export declare function computeTriggerInfoForWorkflowRun(run: WorkflowRunFragment): {
+    triggerType: WorkflowTriggerType;
+    trigger: string | null;
+};
+export declare function choiceFromWorkflowRun(run: WorkflowRunResult): Choice;
+export declare function choiceFromWorkflowJob(job: WorkflowJobResult, index: number): Choice;
+export declare function choicesFromWorkflowLogs(logs: WorkflowLogs): Choice[];
+export declare function processWorkflowRuns(runs: WorkflowRunFragment[]): WorkflowRunResult[];
+export declare function processLogsFromJobAsync(job: WorkflowJobResult): Promise<WorkflowLogs | null>;

package/build/commandUtils/workflow/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLogsFromJobAsync = exports.processWorkflowRuns = exports.choicesFromWorkflowLogs = exports.choiceFromWorkflowJob = exports.choiceFromWorkflowRun = exports.computeTriggerInfoForWorkflowRun = void 0;
+const fetchLogs_1 = require("./fetchLogs");
+const types_1 = require("./types");
+const generated_1 = require("../../graphql/generated");
+function computeTriggerInfoForWorkflowRun(run) {
+    let triggerType = types_1.WorkflowTriggerType.OTHER;
+    let trigger = '';
+    if (run.actor?.__typename === 'Robot') {
+        if (run.actor.firstName?.startsWith('GitHub App · ')) {
+            trigger = `${run.requestedGitRef ?? ''}@${run.gitCommitHash?.substring(0, 12) ?? ''}`;
+        }
+    }
+    else if (run.actor?.__typename === 'User') {
+        trigger = run.actor.username;
+    }
+    switch (run.triggerEventType) {
+        case generated_1.WorkflowRunTriggerEventType.Manual:
+            triggerType = types_1.WorkflowTriggerType.MANUAL;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestLabeled:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestOpened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestReopened:
+        case generated_1.WorkflowRunTriggerEventType.GithubPullRequestSynchronize:
+        case generated_1.WorkflowRunTriggerEventType.GithubPush:
+            triggerType = types_1.WorkflowTriggerType.GITHUB;
+            break;
+        case generated_1.WorkflowRunTriggerEventType.Schedule:
+            triggerType = types_1.WorkflowTriggerType.SCHEDULED;
+            trigger = run.triggeringSchedule ?? '';
+            break;
+    }
+    return { triggerType, trigger };
+}
+exports.computeTriggerInfoForWorkflowRun = computeTriggerInfoForWorkflowRun;
+function choiceFromWorkflowRun(run) {
+    const titleArray = [
+        run.workflowFileName,
+        run.status,
+        run.startedAt,
+        run.triggerType,
+        run.trigger,
+    ];
+    return {
+        title: titleArray.join(' - '),
+        value: run.id,
+        description: `ID: ${run.id}, Message: ${run.gitCommitMessage?.split('\n')[0] ?? ''}`,
+    };
+}
+exports.choiceFromWorkflowRun = choiceFromWorkflowRun;
+function choiceFromWorkflowJob(job, index) {
+    return {
+        title: `${job.name} - ${job.status}`,
+        value: index,
+        description: `ID: ${job.id}`,
+    };
+}
+exports.choiceFromWorkflowJob = choiceFromWorkflowJob;
+function choicesFromWorkflowLogs(logs) {
+    return Array.from(logs.keys()).map(step => {
+        const logLines = logs.get(step);
+        const stepStatus = logLines?.filter((line) => line.marker === 'end-step')[0]?.result ?? '';
+        return {
+            title: `${step} - ${stepStatus}`,
+            value: step,
+        };
+    });
+}
+exports.choicesFromWorkflowLogs = choicesFromWorkflowLogs;
+function processWorkflowRuns(runs) {
+    return runs.map(run => {
+        const finishedAt = run.status === generated_1.WorkflowRunStatus.InProgress ? null : run.updatedAt;
+        const { triggerType, trigger } = computeTriggerInfoForWorkflowRun(run);
+        return {
+            id: run.id,
+            status: run.status,
+            gitCommitMessage: run.gitCommitMessage?.split('\n')[0] ?? null,
+            gitCommitHash: run.gitCommitHash ?? null,
+            startedAt: run.createdAt,
+            finishedAt,
+            triggerType,
+            trigger,
+            workflowId: run.workflow.id,
+            workflowName: run.workflow.name ?? null,
+            workflowFileName: run.workflow.fileName,
+        };
+    });
+}
+exports.processWorkflowRuns = processWorkflowRuns;
+async function processLogsFromJobAsync(job) {
+    const rawLogs = await (0, fetchLogs_1.fetchRawLogsForJobAsync)(job);
+    if (!rawLogs) {
+        return null;
+    }
+    const logs = new Map();
+    const logKeys = new Set();
+    rawLogs.split('\n').forEach(line => {
+        try {
+            const parsedLine = JSON.parse(line);
+            const { result, marker } = parsedLine;
+            const { buildStepDisplayName, buildStepInternalId, time, msg } = parsedLine;
+            const stepId = buildStepDisplayName ?? buildStepInternalId;
+            if (stepId) {
+                if (!logKeys.has(stepId)) {
+                    logKeys.add(stepId);
+                    logs.set(stepId, []);
+                }
+                logs.get(stepId)?.push({ time, msg, result, marker });
+            }
+        }
+        catch { }
+    });
+    return logs;
+}
+exports.processLogsFromJobAsync = processLogsFromJobAsync;

package/build/commands/deploy/alias/delete.d.ts

@@ -0,0 +1,21 @@
+import EasCommand from '../../../commandUtils/EasCommand';
+export default class WorkerAliasDelete extends EasCommand {
+    static description: string;
+    static aliases: string[];
+    static state: string;
+    static args: {
+        name: string;
+    }[];
+    static flags: {
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        'non-interactive': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../../commandUtils/context/LoggedInContextField").default;
+        projectDir: import("../../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeFlags;
+}

package/build/commands/deploy/alias/delete.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+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");
+class WorkerAliasDelete extends EasCommand_1.default {
+    static description = 'Delete deployment aliases.';
+    static aliases = ['worker:alias:delete'];
+    static state = 'preview';
+    static args = [{ name: 'ALIAS_NAME' }];
+    static flags = {
+        ...flags_1.EasNonInteractiveAndJsonFlags,
+    };
+    static contextDefinition = {
+        ...this.ContextOptions.DynamicProjectConfig,
+        ...this.ContextOptions.ProjectDir,
+        ...this.ContextOptions.LoggedIn,
+    };
+    async runAsync() {
+        const { args: { ALIAS_NAME: aliasNameFromArg }, flags: rawFlags, } = await this.parse(WorkerAliasDelete);
+        const flags = this.sanitizeFlags(rawFlags);
+        if (flags.json) {
+            (0, json_1.enableJsonOutput)();
+        }
+        log_1.default.warn('EAS Hosting is still in preview and subject to changes.');
+        const { getDynamicPrivateProjectConfigAsync, loggedIn: { graphqlClient }, } = await this.getContextAsync(WorkerAliasDelete, {
+            nonInteractive: true,
+            withServerSideEnvironment: null,
+        });
+        const { projectId } = await getDynamicPrivateProjectConfigAsync();
+        const aliasName = await resolveDeploymentAliasAsync(flags, graphqlClient, projectId, aliasNameFromArg);
+        const isProduction = !aliasName;
+        if (!flags.nonInteractive) {
+            log_1.default.addNewLineIfNone();
+            log_1.default.warn(isProduction
+                ? `You are about to delete your production alias`
+                : `You are about to delete alias: "${aliasName}"`);
+            log_1.default.newLine();
+            const confirmed = await (0, prompts_1.toggleConfirmAsync)({ message: 'Are you sure you wish to proceed?' });
+            if (!confirmed) {
+                log_1.default.log('Aborted.');
+                return;
+            }
+        }
+        let progress = null;
+        let deleteResult = null;
+        try {
+            progress = (0, ora_1.ora)((0, chalk_1.default) `Deleting alias {bold ${aliasName ?? 'production'}}`).start();
+            deleteResult = await (0, deployment_1.deleteWorkerDeploymentAliasAsync)({
+                graphqlClient,
+                appId: projectId,
+                aliasName,
+            });
+            progress.text = (0, chalk_1.default) `Deleted alias {bold ${aliasName ?? 'production'}}`;
+        }
+        catch (error) {
+            progress?.fail((0, chalk_1.default) `Failed to delete alias {bold ${aliasName ?? 'production'}}`);
+            throw error;
+        }
+        progress?.succeed((0, chalk_1.default) `Deleted alias {bold ${aliasName ?? 'production'}}`);
+        if (flags.json) {
+            (0, json_1.printJsonOnlyOutput)({
+                aliasName: deleteResult.aliasName,
+                id: deleteResult.id,
+            });
+        }
+    }
+    sanitizeFlags(flags) {
+        return {
+            nonInteractive: flags['non-interactive'],
+            json: flags['json'],
+        };
+    }
+}
+exports.default = WorkerAliasDelete;
+async function resolveDeploymentAliasAsync(flags, graphqlClient, projectId, aliasNameFromArg) {
+    if (aliasNameFromArg?.trim()) {
+        return aliasNameFromArg.trim().toLowerCase();
+    }
+    if (flags.nonInteractive) {
+        throw new Error('Alias name must be provided in non-interactive mode');
+    }
+    const alias = await (0, deployment_1.selectWorkerDeploymentAliasOnAppAsync)({
+        graphqlClient,
+        appId: projectId,
+        selectTitle: 'alias to delete',
+    });
+    if (!alias) {
+        throw new Error('No aliases found for this project, create aliases with "eas deploy:alias"');
+    }
+    return alias.aliasName;
+}

package/build/commands/deploy/alias/index.d.ts

@@ -0,0 +1,21 @@
+import EasCommand from '../../../commandUtils/EasCommand';
+export default class WorkerAlias extends EasCommand {
+    static description: string;
+    static aliases: string[];
+    static state: string;
+    static flags: {
+        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>;
+    };
+    static contextDefinition: {
+        loggedIn: import("../../../commandUtils/context/LoggedInContextField").default;
+        projectDir: import("../../../commandUtils/context/ProjectDirContextField").default;
+        getDynamicPublicProjectConfigAsync: import("../../../commandUtils/context/DynamicProjectConfigContextField").DynamicPublicProjectConfigContextField;
+        getDynamicPrivateProjectConfigAsync: import("../../../commandUtils/context/DynamicProjectConfigContextField").DynamicPrivateProjectConfigContextField;
+    };
+    runAsync(): Promise<void>;
+    private sanitizeFlags;
+}

package/build/commands/deploy/{alias.js → alias/index.js}

@@ -3,14 +3,14 @@ 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");
+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 {
     static description = 'Assign deployment aliases.';
     static aliases = ['worker:alias', 'deploy:promote'];

package/build/commands/deploy/{alias.d.ts → delete.d.ts}

@@ -1,14 +1,14 @@
 import EasCommand from '../../commandUtils/EasCommand';
-export default class WorkerAlias extends EasCommand {
+export default class WorkerDelete extends EasCommand {
     static description: string;
     static aliases: string[];
     static state: string;
+    static args: {
+        name: string;
+    }[];
     static flags: {
         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>;
     };
     static contextDefinition: {
         loggedIn: import("../../commandUtils/context/LoggedInContextField").default;