@hubspot/cli 6.4.0 → 7.0.0-beta.0

package/lib/projects/ProjectLogsManager.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectLogsManager = void 0;
+const index_1 = require("./index");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const lang_1 = require("../lang");
+const ui_1 = require("../ui");
+const i18nKey = 'commands.project.subcommands.logs';
+class _ProjectLogsManager {
+    projectName;
+    projectId;
+    accountId;
+    functions;
+    selectedFunction;
+    functionName;
+    appId;
+    isPublicFunction;
+    endpointName;
+    reset() {
+        this.projectName = undefined;
+        this.projectId = undefined;
+        this.accountId = undefined;
+        this.functions = [];
+        this.selectedFunction = undefined;
+        this.functionName = undefined;
+        this.appId = undefined;
+        this.isPublicFunction = undefined;
+        this.endpointName = undefined;
+    }
+    constructor() {
+        this.functions = [];
+    }
+    async init(accountId) {
+        const { projectConfig } = await (0, index_1.getProjectConfig)();
+        if (!projectConfig || !projectConfig.name) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+        }
+        const { name: projectName } = projectConfig;
+        this.projectName = projectName;
+        this.accountId = accountId;
+        this.functions = [];
+        const { project } = await (0, index_1.ensureProjectExists)(this.accountId, this.projectName, {
+            allowCreate: false,
+        });
+        if (!project ||
+            !project.deployedBuild ||
+            !project.deployedBuild.subbuildStatuses) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.failedToFetchProjectDetails`));
+        }
+        this.projectId = project.id;
+        await this.fetchFunctionDetails();
+    }
+    async fetchFunctionDetails() {
+        if (!this.projectId) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noProjectConfig`));
+        }
+        if (!this.accountId) {
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.errors.projectLogsManagerNotInitialized`));
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.generic`));
+        }
+        const { data: { topLevelComponentMetadata }, } = await (0, projects_1.fetchProjectComponentsMetadata)(this.accountId, this.projectId);
+        const apps = topLevelComponentMetadata.filter(componentMetadata => {
+            const { type } = componentMetadata;
+            return type && type.name === 'PRIVATE_APP';
+        });
+        apps.forEach(app => {
+            this.functions.push(
+            // If component type is APP_FUNCTION, we can safely cast as AppFunctionComponentMetadata
+            ...app.featureComponents.filter(component => component.type.name === 'APP_FUNCTION'));
+        });
+        if (this.functions.length === 0) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
+                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
+            }));
+        }
+    }
+    getFunctionNames() {
+        return this.functions.map(serverlessFunction => serverlessFunction.componentName);
+    }
+    setFunction(functionName) {
+        if (!(this.functions.length > 0)) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsInProject`, {
+                link: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionsLinkText`), 'https://developers.hubspot.com/docs/platform/serverless-functions'),
+            }));
+        }
+        this.selectedFunction = this.functions.find(serverlessFunction => serverlessFunction.componentName === functionName);
+        if (!this.selectedFunction) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.noFunctionWithName`, { name: functionName }));
+        }
+        this.functionName = functionName;
+        if (!this.selectedFunction.deployOutput) {
+            throw new Error((0, lang_1.i18n)(`${i18nKey}.errors.functionNotDeployed`, { name: functionName }));
+        }
+        this.appId = this.selectedFunction.deployOutput.appId;
+        if (this.selectedFunction.deployOutput.endpoint) {
+            this.endpointName = this.selectedFunction.deployOutput.endpoint.path;
+            this.isPublicFunction = true;
+        }
+        else {
+            this.isPublicFunction = false;
+        }
+    }
+}
+exports.ProjectLogsManager = new _ProjectLogsManager();

package/lib/projects/buildAndDeploy.d.ts

@@ -0,0 +1,16 @@
+import { FileResult } from 'tmp';
+import { Build } from '@hubspot/local-dev-lib/types/Build';
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+import { ProjectConfig, ProjectTask } from '../../types/Projects';
+type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs: boolean) => Promise<T>;
+export declare const pollBuildStatus: PollTaskStatusFunction<Build>;
+export declare const pollDeployStatus: PollTaskStatusFunction<Deploy>;
+type ProjectPollResult = {
+    succeeded: boolean;
+    buildId: number;
+    buildResult: Build;
+    deployResult: Deploy | null;
+};
+export declare function displayWarnLogs(accountId: number, projectName: string, taskId: number, isDeploy?: boolean): Promise<void>;
+export declare function pollProjectBuildAndDeploy(accountId: number, projectConfig: ProjectConfig, tempFile: FileResult, buildId: number, silenceLogs?: boolean): Promise<ProjectPollResult>;
+export {};

package/lib/projects/buildAndDeploy.js

@@ -0,0 +1,342 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pollDeployStatus = exports.pollBuildStatus = void 0;
+exports.displayWarnLogs = displayWarnLogs;
+exports.pollProjectBuildAndDeploy = pollProjectBuildAndDeploy;
+const chalk_1 = __importDefault(require("chalk"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const projects_1 = require("@hubspot/local-dev-lib/api/projects");
+const constants_1 = require("../constants");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const lang_1 = require("../lang");
+const errorHandlers_1 = require("../errorHandlers");
+const ui_1 = require("../ui");
+const urls_1 = require("./urls");
+const i18nKey = 'lib.projectBuildAndDeploy';
+const SPINNER_STATUS = {
+    SPINNING: 'spinning',
+};
+function getSubtasks(task) {
+    if ('subbuildStatuses' in task) {
+        return task.subbuildStatuses;
+    }
+    return task.subdeployStatuses;
+}
+function getSubtaskName(task) {
+    if ('buildName' in task) {
+        return task.buildName;
+    }
+    return task.deployName;
+}
+function getSubtaskType(task) {
+    if ('buildType' in task) {
+        return task.buildType;
+    }
+    return task.deployType;
+}
+function makePollTaskStatusFunc({ statusFn, structureFn, statusText, statusStrings, linkToHubSpot, }) {
+    return async function (accountId, taskName, taskId, deployedBuildId = null, silenceLogs = false) {
+        const displayId = deployedBuildId || taskId;
+        if (linkToHubSpot && !silenceLogs) {
+            logger_1.logger.log(`\n${linkToHubSpot(accountId, taskName, taskId, deployedBuildId)}\n`);
+        }
+        SpinniesManager_1.default.init();
+        const overallTaskSpinniesKey = `overallTaskStatus-${statusText.STATUS_TEXT}`;
+        SpinniesManager_1.default.add(overallTaskSpinniesKey, {
+            text: 'Beginning',
+            succeedColor: 'white',
+            failColor: 'white',
+            failPrefix: chalk_1.default.bold('!'),
+        });
+        const [{ data: initialTaskStatus }, { data: { topLevelComponentsWithChildren: taskStructure }, },] = await Promise.all([
+            statusFn(accountId, taskName, taskId),
+            structureFn(accountId, taskName, taskId),
+        ]);
+        const subtasks = getSubtasks(initialTaskStatus);
+        const tasksById = subtasks.reduce((acc, subtask) => {
+            const { id, visible } = subtask;
+            if (visible) {
+                acc[id] = subtask;
+            }
+            return acc;
+        }, {});
+        const structuredTasks = Object.keys(taskStructure).map(key => {
+            return {
+                ...tasksById[key],
+                subtasks: taskStructure[key]
+                    .filter(taskId => Boolean(tasksById[taskId]))
+                    .map(taskId => tasksById[taskId]),
+            };
+        });
+        const numComponents = structuredTasks.length;
+        const componentCountText = silenceLogs
+            ? ''
+            : (0, lang_1.i18n)(numComponents === 1
+                ? `${i18nKey}.makePollTaskStatusFunc.componentCountSingular`
+                : `${i18nKey}.makePollTaskStatusFunc.componentCount`, { numComponents }) + '\n';
+        SpinniesManager_1.default.update(overallTaskSpinniesKey, {
+            text: `${statusStrings.INITIALIZE(taskName, displayId)}\n${componentCountText}`,
+        });
+        if (!silenceLogs) {
+            function addTaskSpinner(subtask, indent, newline) {
+                const taskName = getSubtaskName(subtask);
+                const taskType = getSubtaskType(subtask);
+                const formattedTaskType = constants_1.PROJECT_TASK_TYPES[taskType]
+                    ? `[${constants_1.PROJECT_TASK_TYPES[taskType]}]`
+                    : '';
+                const text = `${indent <= 2 ? statusText.STATUS_TEXT : ''} ${chalk_1.default.bold(taskName)} ${formattedTaskType} ...${newline ? '\n' : ''}`;
+                SpinniesManager_1.default.add(subtask.id, {
+                    text,
+                    indent,
+                    succeedColor: 'white',
+                    failColor: 'white',
+                });
+            }
+            structuredTasks.forEach(task => {
+                addTaskSpinner(task, 2, !task.subtasks || task.subtasks.length === 0);
+                task.subtasks.forEach((subtask, i) => addTaskSpinner(subtask, 4, i === task.subtasks.length - 1));
+            });
+        }
+        return new Promise((resolve, reject) => {
+            const pollInterval = setInterval(async () => {
+                let taskStatus;
+                try {
+                    const { data } = await statusFn(accountId, taskName, taskId);
+                    taskStatus = data;
+                }
+                catch (e) {
+                    logger_1.logger.debug(e);
+                    (0, errorHandlers_1.logError)(e, new errorHandlers_1.ApiErrorContext({
+                        accountId,
+                        projectName: taskName,
+                    }));
+                    return reject(new Error((0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.errorFetchingTaskStatus`, {
+                        taskType: statusText.TYPE_KEY === constants_1.PROJECT_BUILD_TEXT.TYPE_KEY
+                            ? 'build'
+                            : 'deploy',
+                    })));
+                }
+                const subtasks = getSubtasks(taskStatus);
+                if (!taskStatus || !taskStatus.status || !subtasks) {
+                    return reject(new Error((0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.errorFetchingTaskStatus`, {
+                        taskType: statusText.TYPE_KEY === constants_1.PROJECT_BUILD_TEXT.TYPE_KEY
+                            ? 'build'
+                            : 'deploy',
+                    })));
+                }
+                const { status } = taskStatus;
+                if (SpinniesManager_1.default.hasActiveSpinners()) {
+                    subtasks.forEach(subtask => {
+                        const { id, status } = subtask;
+                        const spinner = SpinniesManager_1.default.pick(id);
+                        if (!spinner || spinner.status !== SPINNER_STATUS.SPINNING) {
+                            return;
+                        }
+                        const topLevelTask = structuredTasks.find(t => t.id == id);
+                        if (status === statusText.STATES.SUCCESS ||
+                            status === statusText.STATES.FAILURE) {
+                            const taskStatusText = subtask.status === statusText.STATES.SUCCESS
+                                ? (0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.successStatusText`)
+                                : (0, lang_1.i18n)(`${i18nKey}.makePollTaskStatusFunc.failedStatusText`);
+                            const hasNewline = spinner?.text?.includes('\n') || Boolean(topLevelTask);
+                            const updatedText = `${spinner?.text?.replace('\n', '')} ${taskStatusText}${hasNewline ? '\n' : ''}`;
+                            if (status === statusText.STATES.SUCCESS) {
+                                SpinniesManager_1.default.succeed(id, { text: updatedText });
+                            }
+                            else {
+                                SpinniesManager_1.default.fail(id, { text: updatedText });
+                            }
+                            if (topLevelTask) {
+                                topLevelTask.subtasks.forEach(currentSubtask => SpinniesManager_1.default.remove(currentSubtask.id));
+                            }
+                        }
+                    });
+                    if (status === statusText.STATES.SUCCESS) {
+                        SpinniesManager_1.default.succeed(overallTaskSpinniesKey, {
+                            text: statusStrings.SUCCESS(taskName, displayId),
+                        });
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                    else if (status === statusText.STATES.FAILURE) {
+                        SpinniesManager_1.default.fail(overallTaskSpinniesKey, {
+                            text: statusStrings.FAIL(taskName, displayId),
+                        });
+                        if (!silenceLogs) {
+                            const failedSubtasks = subtasks.filter(subtask => subtask.status === 'FAILURE');
+                            (0, ui_1.uiLine)();
+                            logger_1.logger.log(`${statusStrings.SUBTASK_FAIL(failedSubtasks.length === 1
+                                ? getSubtaskName(failedSubtasks[0])
+                                : failedSubtasks.length + ' components', displayId)}\n`);
+                            logger_1.logger.log('See below for a summary of errors.');
+                            (0, ui_1.uiLine)();
+                            const displayErrors = failedSubtasks.filter(subtask => subtask?.standardError?.subCategory !==
+                                constants_1.PROJECT_ERROR_TYPES.SUBBUILD_FAILED &&
+                                subtask?.standardError?.subCategory !==
+                                    constants_1.PROJECT_ERROR_TYPES.SUBDEPLOY_FAILED);
+                            displayErrors.forEach(subTask => {
+                                logger_1.logger.log(`\n--- ${chalk_1.default.bold(getSubtaskName(subTask))} failed with the following error ---`);
+                                logger_1.logger.error(subTask.errorMessage);
+                                // Log nested errors
+                                if (subTask.standardError && subTask.standardError.errors) {
+                                    logger_1.logger.log();
+                                    subTask.standardError.errors.forEach(error => {
+                                        logger_1.logger.log(error.message);
+                                    });
+                                }
+                            });
+                        }
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                    else if (!subtasks.length) {
+                        clearInterval(pollInterval);
+                        resolve(taskStatus);
+                    }
+                }
+            }, constants_1.POLLING_DELAY);
+        });
+    };
+}
+function pollBuildAutodeployStatus(accountId, taskName, buildId) {
+    return new Promise((resolve, reject) => {
+        let maxIntervals = (30 * 1000) / constants_1.POLLING_DELAY; // Num of intervals in ~30s
+        const pollInterval = setInterval(async () => {
+            let build;
+            try {
+                const response = await (0, projects_1.getBuildStatus)(accountId, taskName, buildId);
+                build = response.data;
+            }
+            catch (e) {
+                logger_1.logger.debug(e);
+                return reject(new Error((0, lang_1.i18n)(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })));
+            }
+            if (!build || !build.status) {
+                return reject(new Error((0, lang_1.i18n)(`${i18nKey}.pollBuildAutodeployStatusError`, { buildId })));
+            }
+            if (build.deployStatusTaskLocator || maxIntervals <= 0) {
+                clearInterval(pollInterval);
+                resolve(build);
+            }
+            else {
+                maxIntervals -= 1;
+            }
+        }, constants_1.POLLING_DELAY);
+    });
+}
+exports.pollBuildStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId) => (0, ui_1.uiLink)(`View build #${taskId} in HubSpot`, (0, urls_1.getProjectBuildDetailUrl)(taskName, taskId, accountId)),
+    statusFn: projects_1.getBuildStatus,
+    structureFn: projects_1.getBuildStructure,
+    statusText: constants_1.PROJECT_BUILD_TEXT,
+    statusStrings: {
+        INITIALIZE: (name, buildId) => `Building ${chalk_1.default.bold(name)} #${buildId}`,
+        SUCCESS: (name, buildId) => `Built ${chalk_1.default.bold(name)} #${buildId}`,
+        FAIL: (name, buildId) => `Failed to build ${chalk_1.default.bold(name)} #${buildId}`,
+        SUBTASK_FAIL: (buildId, name) => `Build #${buildId} failed because there was a problem\nbuilding ${chalk_1.default.bold(name)}`,
+    },
+});
+exports.pollDeployStatus = makePollTaskStatusFunc({
+    linkToHubSpot: (accountId, taskName, taskId, deployedBuildId) => (0, ui_1.uiLink)(`View deploy of build #${deployedBuildId} in HubSpot`, (0, urls_1.getProjectDeployDetailUrl)(taskName, taskId, accountId)),
+    statusFn: projects_1.getDeployStatus,
+    structureFn: projects_1.getDeployStructure,
+    statusText: constants_1.PROJECT_DEPLOY_TEXT,
+    statusStrings: {
+        INITIALIZE: (name, buildId) => `Deploying build #${buildId} in ${chalk_1.default.bold(name)}`,
+        SUCCESS: (name, buildId) => `Deployed build #${buildId} in ${chalk_1.default.bold(name)}`,
+        FAIL: (name, buildId) => `Failed to deploy build #${buildId} in ${chalk_1.default.bold(name)}`,
+        SUBTASK_FAIL: (deployedBuildId, name) => `Deploy for build #${deployedBuildId} failed because there was a\nproblem deploying ${chalk_1.default.bold(name)}`,
+    },
+});
+async function displayWarnLogs(accountId, projectName, taskId, isDeploy = false) {
+    let result;
+    if (isDeploy) {
+        try {
+            const { data } = await (0, projects_1.fetchDeployWarnLogs)(accountId, projectName, taskId);
+            result = data;
+        }
+        catch (e) {
+            (0, errorHandlers_1.logError)(e);
+        }
+    }
+    else {
+        try {
+            const { data } = await (0, projects_1.fetchBuildWarnLogs)(accountId, projectName, taskId);
+            result = data;
+        }
+        catch (e) {
+            (0, errorHandlers_1.logError)(e);
+        }
+    }
+    if (result && result.logs) {
+        const logLength = result.logs.length;
+        result.logs.forEach((log, i) => {
+            logger_1.logger.warn(log.message);
+            if (i < logLength - 1) {
+                logger_1.logger.log('');
+            }
+        });
+    }
+}
+async function pollProjectBuildAndDeploy(accountId, projectConfig, tempFile, buildId, silenceLogs = false) {
+    let buildStatus = await (0, exports.pollBuildStatus)(accountId, projectConfig.name, buildId, null, silenceLogs);
+    if (!silenceLogs) {
+        (0, ui_1.uiLine)();
+    }
+    const result = {
+        succeeded: true,
+        buildId,
+        buildResult: buildStatus,
+        deployResult: null,
+    };
+    if (buildStatus.status === 'FAILURE') {
+        result.succeeded = false;
+        return result;
+    }
+    else if (buildStatus.isAutoDeployEnabled) {
+        if (!silenceLogs) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.buildSucceededAutomaticallyDeploying`, {
+                accountIdentifier: (0, ui_1.uiAccountDescription)(accountId),
+                buildId,
+            }));
+            await displayWarnLogs(accountId, projectConfig.name, buildId);
+        }
+        // autoDeployId of 0 indicates a skipped deploy
+        const getIsDeploying = () => buildStatus.autoDeployId > 0 && buildStatus.deployStatusTaskLocator;
+        // Sometimes the deploys do not immediately initiate, give them a chance to kick off
+        if (!getIsDeploying()) {
+            buildStatus = await pollBuildAutodeployStatus(accountId, projectConfig.name, buildId);
+        }
+        if (getIsDeploying()) {
+            const deployStatus = await (0, exports.pollDeployStatus)(accountId, projectConfig.name, Number(buildStatus.deployStatusTaskLocator.id), buildId, silenceLogs);
+            result.deployResult = deployStatus;
+            if (deployStatus.status === 'FAILURE') {
+                result.succeeded = false;
+            }
+        }
+        else if (!silenceLogs) {
+            logger_1.logger.log((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.unableToFindAutodeployStatus`, {
+                buildId,
+                viewDeploysLink: (0, ui_1.uiLink)((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.viewDeploys`), (0, urls_1.getProjectActivityUrl)(projectConfig.name, accountId)),
+            }));
+        }
+    }
+    try {
+        if (tempFile) {
+            tempFile.removeCallback();
+            logger_1.logger.debug((0, lang_1.i18n)(`${i18nKey}.pollProjectBuildAndDeploy.cleanedUpTempFile`, {
+                path: tempFile.name,
+            }));
+        }
+    }
+    catch (e) {
+        logger_1.logger.error(e);
+    }
+    if (result && result.deployResult) {
+        await displayWarnLogs(accountId, projectConfig.name, result.deployResult.deployId, true);
+    }
+    return result;
+}

package/lib/projects/index.d.ts

@@ -0,0 +1,24 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { ProjectTemplate, ProjectConfig, ProjectAddComponentData, ComponentTemplate } from '../../types/Projects';
+export declare function writeProjectConfig(configPath: string, config: ProjectConfig): boolean;
+export declare function getIsInProject(dir?: string): boolean;
+export declare function getProjectConfig(dir?: string): Promise<{
+    projectDir: string | null;
+    projectConfig: ProjectConfig | null;
+}>;
+export declare function createProjectConfig(projectPath: string, projectName: string, template: ProjectTemplate, templateSource: RepoPath, githubRef: string): Promise<boolean>;
+export declare function validateProjectConfig(projectConfig: ProjectConfig, projectDir: string): void;
+export declare function ensureProjectExists(accountId: number, projectName: string, { forceCreate, allowCreate, noLogs, withPolling, uploadCommand, }?: {
+    forceCreate?: boolean | undefined;
+    allowCreate?: boolean | undefined;
+    noLogs?: boolean | undefined;
+    withPolling?: boolean | undefined;
+    uploadCommand?: boolean | undefined;
+}): Promise<{
+    projectExists: boolean;
+    project?: Project;
+}>;
+export declare function logFeedbackMessage(buildId: number): void;
+export declare function createProjectComponent(component: ProjectAddComponentData, name: string, projectComponentsVersion: string): Promise<void>;
+export declare function getProjectComponentsByVersion(projectComponentsVersion: string): Promise<ComponentTemplate[]>;