esa-cli/dist/commands/deploy/helper.js

A CLI for operating Alibaba Cloud ESA EdgeRoutine (Edge Functions).

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import SelectItems from '../../components/selectInput.js';
import { yesNoPrompt } from '../../components/yesNoPrompt.js';
import { PublishType } from '../../libs/interface.js';
import { ApiService } from '../../libs/apiService.js';
import { descriptionInput } from '../../components/descriptionInput.js';
import { readEdgeRoutineFile } from '../../utils/fileUtils/index.js';
import { createEdgeRoutine, releaseOfficialVersion, uploadEdgeRoutineCode } from '../commit/index.js';
import logger from '../../libs/logger.js';
import t from '../../i18n/index.js';
import prodBuild from '../commit/prodBuild.js';
export function yesNoPromptAndExecute(message, execute) {
    return new Promise((resolve) => {
        yesNoPrompt((item) => __awaiter(this, void 0, void 0, function* () {
            if (item.value === 'yes') {
                const result = yield execute();
                resolve(result);
            }
            else {
                resolve(false);
            }
        }), message);
    });
}
export function promptSelectVersion(versionList) {
    const items = versionList
        .filter((version) => version.codeVersion !== 'unstable')
        .map((version, index) => {
        var _a;
        return ({
            label: (_a = version.codeVersion) !== null && _a !== void 0 ? _a : '',
            value: String(index)
        });
    });
    return new Promise((resolve) => {
        const handleSelection = (item) => __awaiter(this, void 0, void 0, function* () {
            resolve(item.label);
        });
        SelectItems({ items, handleSelect: handleSelection });
    });
}
export function displaySelectDeployType() {
    logger.log(`📃 ${t('deploy_env_select_description').d('Please select which environment you want to deploy')}`);
    const selectItems = [
        { label: t('deploy_env_staging').d('Staging'), value: PublishType.Staging },
        {
            label: t('deploy_env_production').d('Production'),
            value: PublishType.Production
        }
    ];
    return new Promise((resolve) => {
        const handleSelection = (item) => __awaiter(this, void 0, void 0, function* () {
            resolve(item.value);
        });
        SelectItems({ items: selectItems, handleSelect: handleSelection });
    });
}
export function createAndDeployVersion(projectConfig_1) {
    return __awaiter(this, arguments, void 0, function* (projectConfig, createUnstable = false, customEntry) {
        try {
            const server = yield ApiService.getInstance();
            const description = yield descriptionInput(createUnstable
                ? `🖊️ ${t('deploy_description_routine').d('Enter the description of the routine')}:`
                : `🖊️ ${t('deploy_description_version').d('Enter the description of the code version')}:`, false);
            yield prodBuild(false, customEntry);
            const code = readEdgeRoutineFile();
            const edgeRoutine = {
                name: projectConfig.name,
                code: code || '',
                description: description
            };
            if (createUnstable) {
                return yield createEdgeRoutine(edgeRoutine);
            }
            else {
                const uploadResult = yield uploadEdgeRoutineCode(edgeRoutine);
                if (!uploadResult) {
                    return false;
                }
                return yield releaseOfficialVersion(edgeRoutine);
            }
        }
        catch (error) {
            logger.error(`
      ${t('deploy_error').d('An error occurred during the creation or publishing process')}: ${error}`);
            return false;
        }
    });
}