@cto.ai/ops/lib/commands/secrets/set.js

💻 CTO.ai Ops - The CLI built for Teams 🚀

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const sdk_1 = require("@cto.ai/sdk");
const base_1 = tslib_1.__importDefault(require("../../base"));
const utils_1 = require("../../utils");
const CustomErrors_1 = require("../../errors/CustomErrors");
const parser_1 = require("@oclif/parser");
const { white, reset } = sdk_1.ux.colors;
class SecretsSet extends base_1.default {
    constructor() {
        super(...arguments);
        this.validateRegisterInput = async (input) => {
            if (!input) {
                return `😞 Sorry, the value cannot be empty`;
            }
            return true;
        };
        this.promptForSecret = async (input) => {
            if (input.key && input.value) {
                return input;
            }
            await sdk_1.ux.print(`\n🔑 Add a secret to secret storage for team ${input.state.config.team.name} ${reset.green('→')}`);
            const { key, valueOriginal, valueConfirm } = await sdk_1.ux.prompt([
                {
                    type: 'input',
                    name: 'key',
                    message: `Enter the name of the secret to be stored ${reset.green('→')}`,
                    afterMessage: `${reset.white('Secret name:')}`,
                    validate: this.validateRegisterInput.bind(this),
                },
                {
                    type: 'password',
                    name: 'valueOriginal',
                    message: `\nNext add the secret's value to be stored ${reset.green('→')}`,
                    validate: this.validateRegisterInput.bind(this),
                },
                {
                    type: 'password',
                    name: 'valueConfirm',
                    message: `\nPlease confirm the secret's value to be stored ${reset.green('→')}`,
                    validate: this.validateRegisterInput.bind(this),
                },
            ]);
            if (valueOriginal !== valueConfirm) {
                throw new CustomErrors_1.SecretsValuesNotEqual();
            }
            return {
                key: key,
                value: valueOriginal,
                state: input.state,
            };
        };
        this.setSecret = async (inputs) => {
            try {
                await this.services.api.create(`/private/teams/${inputs.state.config.team.name}/secrets`, {
                    secrets: {
                        [inputs.key]: inputs.value,
                    },
                }, {
                    headers: {
                        Authorization: this.accessToken,
                    },
                });
                return inputs;
            }
            catch (err) {
                this.debug('%O', err);
                switch (err.error[0].code) {
                    case 400:
                        throw new CustomErrors_1.InvalidSecretVault(err);
                    case 401:
                        throw new CustomErrors_1.UserUnauthorized(err);
                    case 403:
                        if (err.error[0].message.includes('invalid secret token')) {
                            throw new CustomErrors_1.InvalidSecretToken(err);
                        }
                        else {
                            throw new CustomErrors_1.NoSecretsProviderFound(err);
                        }
                    default:
                        throw new CustomErrors_1.SetSecretsProvider(err);
                }
            }
        };
        this.logMessage = (inputs) => {
            this.log(`\n ${white(`🙌 Great job! Secret ${sdk_1.ux.colors.callOutCyan(inputs.key)} has been added to your team ${sdk_1.ux.colors.blueBright(inputs.state.config.team.name)}!`)}`);
            return inputs;
        };
        this.sendAnalytics = async (inputs) => {
            const { team } = inputs.state.config;
            const { email, username } = inputs.state.config.user;
            try {
                this.services.analytics.track({
                    userId: email,
                    teamId: team.id,
                    cliEvent: 'Ops CLI Set Secrets',
                    event: 'Ops CLI Set Secrets',
                    properties: {
                        email,
                        username,
                    },
                }, this.accessToken);
                return inputs;
            }
            catch (err) {
                this.debug('%O', err);
                throw new CustomErrors_1.AnalyticsError(err);
            }
        };
        this.validateFlags = (k, v) => {
            if ((k && !v) || (v && !k)) {
                throw new CustomErrors_1.SecretsFlagsRequired();
            }
        };
    }
    async run() {
        let { flags: { key, value }, } = this.parse(SecretsSet);
        try {
            await this.isLoggedIn();
            const secretProviderErr = await this.services.secretService.checkForSecretProviderErrors(this.services.api, this.state.config);
            if (secretProviderErr instanceof Error) {
                throw secretProviderErr;
            }
            this.validateFlags(key, value);
            const switchPipeline = utils_1.asyncPipe(this.promptForSecret, this.setSecret, this.sendAnalytics, this.logMessage);
            await switchPipeline({
                state: this.state,
                key,
                value,
            });
        }
        catch (err) {
            this.debug('%O', err);
            this.config.runHook('error', { err, accessToken: this.accessToken });
        }
    }
}
exports.default = SecretsSet;
SecretsSet.description = 'Add a key & value';
SecretsSet.flags = {
    key: parser_1.flags.string({ char: 'k' }),
    value: parser_1.flags.string({ char: 'v' }),
};