@onboardbase/cli/lib/common/http.service.js

[](https://www.npmjs.com/package/@onboardbase/cli) [](https://www.npmjs.com/package/@onboardbase/cli) [![License](https://img

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.HTTPService = void 0;
const axios_1 = require("axios");
const chalk = require("chalk");
const perf_hooks_1 = require("perf_hooks");
const defaults_1 = require("./defaults");
const errors_1 = require("./errors");
const jwt_decode_1 = require("jwt-decode");
const utils_1 = require("../utils");
const messages = {
    errInvalidDeviceToken: `Unable to authenticate the CLI, please run ${chalk.green("onboardbase login")} or ${chalk.green("onboardbase config:set --token [TOKEN]")} to authenticate the CLI`,
    errUnableToAcknowledgeShareLogs: ``,
};
class HTTPService {
    constructor(apiHost = defaults_1.DEFAULT_API_HOST) {
        this.apiHost = apiHost;
        // TODO: Find a better way to pass in api-host from the config
        HTTPService.instance = axios_1.default.create({
            baseURL: this.apiHost,
        });
    }
    async createRecommendation(accessToken, environmentId, secrets, comment) {
        const query = `mutation addMergeRequest ($addSecretsInput: [BaseAddSecretInput!]) {
        addMergeRequest(addMergeRequestInput: { environmentId: "${environmentId}", comment: "${comment}", secrets: $addSecretsInput }) {
          comment
        }
      }`;
        const variables = {
            addSecretsInput: [secrets],
        };
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "add_merge_request",
            accessToken,
            variables,
        });
        return data;
    }
    async getCliEnvironment(project, environment, accessToken) {
        const query = `query {
    getCliEnvironment(project: "${project}", environment: "${environment}") {
      totalSecrets
    }
  }
  `;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "get_cli_environment",
            accessToken,
        });
        return data.getCliEnvironment;
    }
    async fetchSecrets(project, environment, accessToken) {
        var _a, _b;
        const environmentData = await this.getCliEnvironment(project, environment, accessToken);
        const projects = await this.fetchProjects(accessToken);
        const projectEnvironments = (_a = projects.find(({ title }) => title === project)) === null || _a === void 0 ? void 0 : _a.environments.list;
        const environmentId = (_b = projectEnvironments.find(({ title }) => title === environment)) === null || _b === void 0 ? void 0 : _b.id;
        const query = `query {
    generalSecrets(
      filterInput: {
        environmentId: "${environmentId}",
        fromCli: true
      },
      take: ${Number(environmentData.totalSecrets)},
      skip: 0
    ) {
      list {
        id
        key
        keySha
        value
        comment
        member
        user {
          email
        }
        environment {
          id
          title
          member
        }
        project {
          id
          title
          member
        }
        mergeRequest {
          id
          comment
        }
        createdDate
      }
    }
  }`;
        return this.makeOnboardbaseRequest({
            query,
            metricsName: "get_secret",
        });
    }
    async downloadSecretsForRecommendation(localSecrets, recommendationProject, environmentToRecommendUpdateFor, accessToken) {
        var _a, _b, _c;
        let secrets = await this.fetchSecrets(recommendationProject, environmentToRecommendUpdateFor, accessToken);
        const generalSecrets = ((_b = (_a = secrets === null || secrets === void 0 ? void 0 : secrets.data) === null || _a === void 0 ? void 0 : _a.generalSecrets) === null || _b === void 0 ? void 0 : _b.list) || [];
        const userCanFetchSecretUnderEnvironment = Boolean((_c = generalSecrets[0]) === null || _c === void 0 ? void 0 : _c.member);
        if (generalSecrets.length && !userCanFetchSecretUnderEnvironment) {
            console.log(`Error: ${chalk.red(`You don't have enough permission to fetch secrets under the ${chalk.bold.greenBright(environmentToRecommendUpdateFor)} environment.`)}`);
            process.exit(1);
        }
        secrets = secrets === null || secrets === void 0 ? void 0 : secrets.generalSecrets.list;
        if (secrets && Array.isArray(secrets)) {
            const secretKeyAndValue = secrets.map(({ key, value }) => {
                return { key, value };
            });
            const aesSecret = await (0, utils_1.aesDecryptSecret)(secretKeyAndValue);
            const recommendationSecrets = [];
            if (Object.keys(localSecrets).length) {
                Object.keys(localSecrets).map((localSecretkey) => {
                    const key = localSecretkey;
                    const value = localSecrets[key];
                    if (!aesSecret[key])
                        recommendationSecrets.push(key);
                });
                return recommendationSecrets;
            }
        }
    }
    async teamMateSignup(options) {
        const query = `mutation {
    setupNewEmployeeProfile(id: "${options.userId}", authCode: "${options.authCode}", fromNonBrowserEnvironment: true, userInput: {name: "${options.name}", confirmationCode: "${options.confirmationCode}"}) {
      accessToken
    }
  }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "teammate-signup",
            accessToken: options.accessToken,
        });
        return data;
    }
    async getTeamMateByCode(accessToken, confirmationCode) {
        const query = `query {
      newEmployee(confirmationCode: "${confirmationCode}") {
        id
        teamName
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "get_teammate_by_code",
            accessToken,
        });
        return data.newEmployee.id;
    }
    async createProject(accessToken, title, description, environment) {
        const query = `mutation {
      addProject(
        addProjectInput: {
          title: "${title}"
          ${description ? `description: "${description}"` : ""}
          ${environment ? `environment: "${environment}"` : ""}
          type: "api_keys"
        }
      ) {
        id
      }
    }
    `;
        await this.makeOnboardbaseRequest({
            query,
            metricsName: "create-project",
            accessToken,
        });
    }
    async signup(input) {
        const query = `mutation {
      signup(registrationInput: {email: "${input.email}", teamName: "${input.teamName}", name: "${input.name}", cliSignUpAuthCode: "${input.authCode}"}) {
        backendPublicKey
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "signup-user",
        });
        return data;
    }
    async createShareLogs({ receiverId, receiverEmail, senderId, senderEmail, secrets, accessToken, }) {
        var _a;
        const query = `mutation createShareLogs($createShareLogInput: CreateShareLogsInput!){
          createShareLogs(createShareLogInput: $createShareLogInput) {
            id
          }
        }`;
        const variables = {
            senderEmail,
            senderId,
            receiverEmail,
            receiverId,
            secrets,
        };
        const data = await this.makeOnboardbaseRequest({
            query,
            variables: { createShareLogInput: variables },
            metricsName: "create-share-logs",
            accessToken,
        });
        return (_a = data === null || data === void 0 ? void 0 : data.createShareLogs) === null || _a === void 0 ? void 0 : _a.id;
    }
    async fetchProjectTeammates(project, accessToken) {
        const query = `query {
      generalProjects(filterOptions: { title: "${project}", fromCli: true }) {
        list {
          team {
            users {
              list{
                user {
                  email
                  id
                  name
                }
              }
            }
          }
        }
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "fetch-project-teammates",
            accessToken,
        });
        return data;
    }
    async getCurrentUser(accessToken) {
        const decodedData = (0, jwt_decode_1.default)(accessToken);
        const query = `query {
      user(id: "${decodedData.sub}") {
        id
        name
        defaultTeam {
          id
          paymentTier {
            id
            tier
          }
        }
        teams {
          id
          team {
            name
            id
          }
        }
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "get-current-user",
        });
        return data.user;
    }
    async revokeAuthToken(token) {
        const query = `mutation {
      revokeAuthToken(token: "${token}") {
        status
        message
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "revoke-auth-token",
            returnErrorResponse: true,
        });
        return data === null || data === void 0 ? void 0 : data.revokeAuthToken;
    }
    async getAuthToken(pollingCode) {
        const query = `query {
      verifyAuthCode(pollingCode: "${pollingCode}") {
        id
        token
        user {
          role {
            name
            id
          }
          id
          email
          name
        }
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "get-auth-code",
            returnErrorResponse: true,
        });
        return data;
    }
    async generateAuthCode(fingerprint, hostOS, hostname, hostARCH) {
        const query = `mutation {
      addAuthCode(addAuthCodeInput: {fingerprint: "${fingerprint}", hostOS: "${hostOS}", hostName: "${hostname}", hostARCH: "${hostARCH}"}) {
        pollingCode
        authCode
        hostOS
        hostName
        hostARCH
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            query,
            metricsName: "generate_auth_code",
        });
        return data === null || data === void 0 ? void 0 : data.addAuthCode;
    }
    async checkEnvironmentAccess(accessToken, environmentId, revalidate = false) {
        var _a;
        const query = `
    query {
      checkEnvironmentAccess (environmentId: "${environmentId}") {
        access
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "check_environment_access",
            headers: { "Cache-Control": revalidate ? "no-cache" : "public" },
        });
        return (_a = data === null || data === void 0 ? void 0 : data.checkEnvironmentAccess) === null || _a === void 0 ? void 0 : _a.access;
    }
    getShareLogsQuery(userId) {
        return `query {
      findShareLogsByReceiverEmailOrId(receiver: "${userId}"){
        id
        secrets
      }
    }`;
    }
    async getShareLogs(accessToken, userId) {
        const query = this.getShareLogsQuery(userId);
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "get_share_logs",
        });
        return data.findShareLogsByReceiverEmailOrId;
    }
    getAcknowledgeShareLogsQuery(shareLogId) {
        return `mutation {
      updateShareLogStatus(shareId: "${shareLogId}", ack: true){
        id
      }
    }`;
    }
    async acknowledgeShareLogs(accessToken, shareLogId) {
        const query = this.getAcknowledgeShareLogsQuery(shareLogId);
        await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "acknowledge_logs",
        });
    }
    _createGetSecretsQuery(project, environment) {
        return `query {
      generalSecrets(
        filterInput: {
          environmentTitle: "${environment}",
          projectTitle: "${project}",
          fromCli: true
        },
        take: 10,
        skip: 0
      ) {
        list {
          id
          key
          keySha
          value
          comment
          member
          user {
            email
          }
          environment {
            id
            title
            member
            secretVersion
          }
          project {
            id
            title
            member
          }
          mergeRequest {
            id
            comment
          }
          createdDate
        }
      }
    }`;
    }
    async getSecrets(input) {
        var _a, _b, _c;
        const { accessToken, project, environment } = input;
        const query = this._createGetSecretsQuery(project, environment);
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "get_cli_secrets",
        });
        if (!((_a = data === null || data === void 0 ? void 0 : data.generalSecrets) === null || _a === void 0 ? void 0 : _a.list))
            throw new errors_1.BadNetworkError("An error occured while trying to fetch secrets");
        if (!((_b = data === null || data === void 0 ? void 0 : data.generalSecrets) === null || _b === void 0 ? void 0 : _b.list.length))
            console.warn("Secret is empty OR project does not exist.");
        return (_c = data === null || data === void 0 ? void 0 : data.generalSecrets) === null || _c === void 0 ? void 0 : _c.list;
    }
    createFetchSecretQuery(token, publicKey) {
        return `mutation {
        authenticateToken(token: "${token}", frontendPublicKey: ${JSON.stringify(publicKey)}) {
          accessToken
          authToken {
            serviceName
            project {
              title
              id
            }
            environment {
              title
              id
            }
          }
          user {
            email
            id
            name
            role {
              id
              name
            }
          }
        }
      }`;
    }
    async makeOnboardbaseRequest(config) {
        var _a;
        const { accessToken, query, metricsName, variables, customErrMsg = "", returnErrorResponse, headers, } = config;
        try {
            if (accessToken) {
                HTTPService.instance.defaults.headers["Authorization"] = `Bearer ${accessToken}`;
            }
            perf_hooks_1.performance.mark("start_request");
            const response = await HTTPService.instance.post("/graphql", {
                query,
                variables,
            }, { headers });
            const data = response === null || response === void 0 ? void 0 : response.data;
            if (data === null || data === void 0 ? void 0 : data.errors) {
                if (returnErrorResponse)
                    return Object.assign(Object.assign({}, data.errors[0]), { error: true });
                const errMsg = customErrMsg || ((_a = data.errors[0]) === null || _a === void 0 ? void 0 : _a.message);
                throw errors_1.BadNetworkError.from(errMsg);
            }
            perf_hooks_1.performance.mark("end_request");
            process.env.NODE_ENV === "development" &&
                perf_hooks_1.performance.measure(metricsName, "start_request", "end_request");
            return data === null || data === void 0 ? void 0 : data.data;
        }
        catch (error) {
            throw errors_1.UnexpectedError.from(`${metricsName}:${this.apiHost} An API error occurred: ${error.message} please try again `);
        }
    }
    async getAuthInfoFromDeviceToken({ token, publicKey, }) {
        const query = this.createFetchSecretQuery(token, publicKey);
        const data = await this.makeOnboardbaseRequest({
            accessToken: "",
            query,
            metricsName: "get_access_token",
            customErrMsg: messages.errInvalidDeviceToken,
        });
        return data === null || data === void 0 ? void 0 : data.authenticateToken;
    }
    async checkProjectAccess(accessToken, projectName) {
        var _a, _b;
        const query = `
query {
  getProject(projectName: "${projectName}") {
    checkProjectAccess {
      status
    }
    id
  }
}
`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "check_project_access",
        });
        console.log(data);
        return ((_b = (_a = data === null || data === void 0 ? void 0 : data.getProject) === null || _a === void 0 ? void 0 : _a.checkProjectAccess) === null || _b === void 0 ? void 0 : _b.status) || false;
    }
    async getEnvironmentVersion({ project, environment, accessToken, }) {
        var _a;
        const query = `query {
      getCliEnvironment(
        project: "${project}",
        environment: "${environment}"
      ) {
        secretVersion
        version
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "get_cli_environment_version",
        });
        return ((_a = data === null || data === void 0 ? void 0 : data.getCliEnvironment) === null || _a === void 0 ? void 0 : _a.secretVersion) || -1;
    }
    async fetchProjects(accessToken) {
        const query = `query {
    generalProjects(filterOptions: { fromCli: true}, take: 1000, skip: 0) {
      list {
        id
        title
        member
        businessOwner {
          name
          email
          role {
            id
            name
          }
        }
        environments(take: 1000, skip: 0) {
          list {
            title
            id
            member
          }
        }
      }
    }
  }`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "get_projects",
            customErrMsg: `There was an error fetching a list of your projects... Please run ${chalk.greenBright.bold("onboardbase login")} command again to be sure you have access to this organization.`,
        });
        return data.generalProjects.list;
    }
    async fetchSingleProject(accessToken, project) {
        const query = `query {
      generalProjects(filterOptions: { title: "${project}", fromCli: true }) {
        list {
          id
          environments(take: 1000, skip: 0) {
            list {
              title
              id
              member
            }
          }
        }
      }
    }`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "get_single_project",
        });
        return data.generalProjects.list;
    }
    async createEnvironment(accessToken, project, environment) {
        const query = `mutation {
    addEnvironment(
      addEnvironmentInput: { project: "${project}", title: "${environment}" }
    ) {
      title
      id
    }
  }`;
        const data = await this.makeOnboardbaseRequest({
            accessToken,
            query,
            metricsName: "add_environment",
        });
        return data.addEnvironment;
    }
}
exports.HTTPService = HTTPService;