@hubspot/cli 6.3.0 → 6.4.0-beta.0

package/lib/doctor/DiagnosticInfoBuilder.d.ts

@@ -0,0 +1,61 @@
+import { getProjectConfig } from '../projects';
+import { Environment } from '@hubspot/local-dev-lib/types/Config';
+import { AccessToken, AccountType, AuthType } from '@hubspot/local-dev-lib/types/Accounts';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import process from 'process';
+export type ProjectConfig = Awaited<ReturnType<typeof getProjectConfig>>;
+declare const hubspotCli = "@hubspot/cli";
+interface FilesInfo {
+    files: string[];
+    configFiles: string[];
+    packageFiles: string[];
+    packageLockFiles: string[];
+    envFiles: string[];
+    jsonFiles: string[];
+}
+export interface DiagnosticInfo extends FilesInfo {
+    path?: string;
+    versions: {
+        [hubspotCli]: string;
+        node: string;
+        npm: string | null;
+    };
+    config: string | null;
+    project: {
+        details?: Project;
+        config?: ProjectConfig;
+    };
+    arch: typeof process.arch;
+    platform: typeof process.platform;
+    account: {
+        name?: string;
+        accountId?: number | null;
+        scopeGroups?: AccessToken['scopeGroups'];
+        enabledFeatures?: AccessToken['enabledFeatures'];
+        accountType?: AccessToken['accountType'];
+        authType?: AuthType;
+    };
+    diagnosis?: string;
+    errorCount?: number;
+    warningCount?: number;
+}
+export declare class DiagnosticInfoBuilder {
+    accountId: number | null;
+    readonly env?: Environment;
+    readonly authType?: AuthType;
+    readonly accountType?: AccountType;
+    readonly personalAccessKey?: string;
+    private _projectConfig?;
+    private accessToken?;
+    private projectDetails?;
+    private files?;
+    readonly processInfo: NodeJS.Process;
+    constructor(processInfo: NodeJS.Process);
+    generateDiagnosticInfo(): Promise<DiagnosticInfo>;
+    private fetchProjectDetails;
+    fetchAccessToken(): Promise<AccessToken | undefined>;
+    private fetchProjectFilenames;
+    private getNpmVersion;
+    private generateFilesArrays;
+}
+export {};

package/lib/doctor/DiagnosticInfoBuilder.js

@@ -0,0 +1,158 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiagnosticInfoBuilder = void 0;
+const projects_1 = require("../projects");
+const projects_2 = require("@hubspot/local-dev-lib/api/projects");
+const path_1 = __importDefault(require("path"));
+const package_json_1 = __importDefault(require("../../package.json"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const config_2 = require("@hubspot/local-dev-lib/config");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const fs_1 = require("@hubspot/local-dev-lib/fs");
+const util_1 = __importDefault(require("util"));
+const child_process_1 = require("child_process");
+// This needs to be hardcoded since we are using it in the TS type
+const hubspotCli = '@hubspot/cli';
+const configFiles = [
+    'serverless.json',
+    'hsproject.json',
+    'app.json',
+    'public-app.json',
+    'theme.json',
+    'cms-assets.json',
+];
+class DiagnosticInfoBuilder {
+    accountId;
+    env;
+    authType;
+    accountType;
+    personalAccessKey;
+    _projectConfig;
+    accessToken;
+    projectDetails;
+    files;
+    processInfo;
+    constructor(processInfo) {
+        this.accountId = (0, config_1.getAccountId)();
+        const accountConfig = (0, config_2.getAccountConfig)(this.accountId);
+        this.env = accountConfig?.env;
+        this.authType = accountConfig?.authType;
+        this.accountType = accountConfig?.accountType;
+        this.personalAccessKey = accountConfig?.personalAccessKey;
+        this.processInfo = processInfo;
+    }
+    async generateDiagnosticInfo() {
+        // @ts-expect-error getProjectConfig not typed yet
+        this._projectConfig = await (0, projects_1.getProjectConfig)();
+        if (this._projectConfig?.projectConfig) {
+            await this.fetchProjectDetails();
+            await this.fetchAccessToken();
+            await this.fetchProjectFilenames();
+        }
+        const { platform, arch, versions: { node }, mainModule, } = this.processInfo;
+        return {
+            platform,
+            arch,
+            path: mainModule?.path,
+            config: (0, config_2.getConfigPath)(),
+            versions: {
+                [hubspotCli]: package_json_1.default.version,
+                node,
+                npm: await this.getNpmVersion(),
+            },
+            account: {
+                accountId: this.accountId,
+                accountType: this.accountType,
+                authType: this.authType,
+                name: this.accessToken?.hubName,
+                scopeGroups: this.accessToken?.scopeGroups,
+                enabledFeatures: this.accessToken?.enabledFeatures,
+            },
+            project: {
+                config: this._projectConfig,
+                details: this.projectDetails,
+            },
+            ...this.generateFilesArrays(),
+            files: this.files || [],
+        };
+    }
+    async fetchProjectDetails() {
+        try {
+            const { data } = await (0, projects_2.fetchProject)(this.accountId, this._projectConfig?.projectConfig?.name);
+            this.projectDetails = data;
+        }
+        catch (e) {
+            logger_1.logger.debug(e);
+        }
+    }
+    async fetchAccessToken() {
+        try {
+            this.accessToken = await (0, personalAccessKey_1.getAccessToken)(this.personalAccessKey, this.env, this.accountId);
+        }
+        catch (e) {
+            logger_1.logger.debug(e);
+        }
+        return this.accessToken;
+    }
+    async fetchProjectFilenames() {
+        try {
+            this.files = (await (0, fs_1.walk)(this._projectConfig?.projectDir))
+                .filter(file => !path_1.default.dirname(file).includes('node_modules'))
+                .map(filename => path_1.default.relative(this._projectConfig?.projectDir, filename));
+        }
+        catch (e) {
+            logger_1.logger.debug(e);
+        }
+    }
+    async getNpmVersion() {
+        const exec = util_1.default.promisify(child_process_1.exec);
+        try {
+            const { stdout } = await exec('npm --version');
+            return stdout.toString().trim();
+        }
+        catch (e) {
+            logger_1.logger.debug(e);
+            return null;
+        }
+    }
+    generateFilesArrays() {
+        const output = {
+            files: this.files || [],
+            configFiles: [],
+            packageFiles: [],
+            packageLockFiles: [],
+            envFiles: [],
+            jsonFiles: [],
+        };
+        if (!this.files) {
+            return output;
+        }
+        return this.files.reduce((acc, file) => {
+            const { base } = path_1.default.parse(file);
+            if (base === 'package.json') {
+                acc.packageFiles.push(file);
+            }
+            else if (configFiles.includes(base)) {
+                acc.configFiles.push(file);
+                if (file.endsWith('.json')) {
+                    acc.jsonFiles.push(file);
+                }
+            }
+            else if (base === 'package-lock.json') {
+                acc.packageLockFiles.push(file);
+            }
+            else if (file.endsWith('.env')) {
+                acc.envFiles.push(file);
+            }
+            else if (file.endsWith('.json')) {
+                acc.jsonFiles.push(file);
+            }
+            return acc;
+        }, output);
+    }
+}
+exports.DiagnosticInfoBuilder = DiagnosticInfoBuilder;

package/lib/doctor/Doctor.d.ts

@@ -0,0 +1,21 @@
+import { DiagnosticInfoBuilder, DiagnosticInfo } from './DiagnosticInfoBuilder';
+export declare class Doctor {
+    accountId: number | null;
+    private diagnosis?;
+    private projectConfig?;
+    private diagnosticInfo?;
+    readonly diagnosticInfoBuilder: DiagnosticInfoBuilder;
+    constructor(diagnosticInfoBuilder?: DiagnosticInfoBuilder);
+    diagnose(): Promise<DiagnosticInfo>;
+    private performCliChecks;
+    private performProjectChecks;
+    private performCliConfigChecks;
+    private checkIfAccessTokenValid;
+    private checkIfNodeIsInstalled;
+    private checkIfNpmIsInstalled;
+    private checkCLIVersion;
+    private checkIfNpmInstallRequired;
+    private isValidJsonFile;
+    private checkProjectConfigJsonFiles;
+    private checkIfPortsAreAvailable;
+}

package/lib/doctor/Doctor.js

@@ -0,0 +1,328 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Doctor = void 0;
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const config_1 = require("@hubspot/local-dev-lib/config");
+const SpinniesManager_1 = __importDefault(require("../ui/SpinniesManager"));
+const dependencyManagement_1 = require("../dependencyManagement");
+const util_1 = __importDefault(require("util"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const Diagnosis_1 = require("./Diagnosis");
+const DiagnosticInfoBuilder_1 = require("./DiagnosticInfoBuilder");
+const portManager_1 = require("@hubspot/local-dev-lib/portManager");
+const ports_1 = require("@hubspot/local-dev-lib/constants/ports");
+const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
+const index_1 = require("@hubspot/local-dev-lib/errors/index");
+const urls_1 = require("@hubspot/local-dev-lib/urls");
+const ui_1 = require("../ui");
+const package_json_1 = __importDefault(require("../../package.json"));
+const { i18n } = require('../lang');
+const { uiLink } = require('../ui');
+const minMajorNodeVersion = 18;
+const i18nKey = `lib.doctor`;
+class Doctor {
+    accountId;
+    diagnosis;
+    projectConfig;
+    diagnosticInfo;
+    diagnosticInfoBuilder;
+    constructor(diagnosticInfoBuilder = new DiagnosticInfoBuilder_1.DiagnosticInfoBuilder(process)) {
+        SpinniesManager_1.default.init();
+        this.accountId = (0, config_1.getAccountId)();
+        this.diagnosticInfoBuilder = diagnosticInfoBuilder;
+    }
+    async diagnose() {
+        SpinniesManager_1.default.add('runningDiagnostics', {
+            text: i18n(`${i18nKey}.runningDiagnostics`),
+        });
+        this.diagnosticInfo = await this.diagnosticInfoBuilder.generateDiagnosticInfo();
+        this.projectConfig = this.diagnosticInfo?.project.config;
+        this.diagnosis = new Diagnosis_1.Diagnosis({
+            diagnosticInfo: this.diagnosticInfo,
+            accountId: this.accountId,
+        });
+        await Promise.all([
+            ...this.performCliChecks(),
+            ...this.performCliConfigChecks(),
+            ...(this.projectConfig?.projectConfig ? this.performProjectChecks() : []),
+        ]);
+        SpinniesManager_1.default.succeed('runningDiagnostics', {
+            text: i18n(`${i18nKey}.diagnosticsComplete`),
+            succeedColor: 'white',
+        });
+        this.diagnosticInfo.diagnosis = this.diagnosis.toString();
+        this.diagnosticInfo.errorCount = this.diagnosis.getErrorCount();
+        this.diagnosticInfo.warningCount = this.diagnosis.getWarningCount();
+        return this.diagnosticInfo;
+    }
+    performCliChecks() {
+        return [
+            this.checkIfNodeIsInstalled(),
+            this.checkIfNpmIsInstalled(),
+            this.checkCLIVersion(),
+        ];
+    }
+    performProjectChecks() {
+        return [
+            this.checkIfNpmInstallRequired(),
+            this.checkProjectConfigJsonFiles(),
+            this.checkIfPortsAreAvailable(),
+        ];
+    }
+    performCliConfigChecks() {
+        if (!this.diagnosticInfo?.config) {
+            this.diagnosis?.addCLIConfigSection({
+                type: 'error',
+                message: i18n(`${i18nKey}.diagnosis.cliConfig.noConfigFile`),
+                secondaryMessaging: i18n(`${i18nKey}.diagnosis.cliConfig.noConfigFileSecondary`, {
+                    command: (0, ui_1.uiCommandReference)('hs init'),
+                }),
+            });
+            return [];
+        }
+        return [this.checkIfAccessTokenValid()];
+    }
+    async checkIfAccessTokenValid() {
+        const localI18nKey = `${i18nKey}.accountChecks`;
+        try {
+            await (0, personalAccessKey_1.accessTokenForPersonalAccessKey)(this.accountId, true);
+            this.diagnosis?.addCLIConfigSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.active`),
+            });
+            this.diagnosis?.addCLIConfigSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.pak.valid`, {
+                    link: uiLink(i18n(`${localI18nKey}.pak.viewScopes`), `${(0, urls_1.getHubSpotWebsiteOrigin)(this.diagnosticInfoBuilder?.env || 'PROD')}/personal-access-key/${this.diagnosticInfo?.account.accountId}`),
+                }),
+            });
+        }
+        catch (error) {
+            const portalNotActive = (0, index_1.isSpecifiedError)(error, {
+                statusCode: 401,
+                category: 'INVALID_AUTHENTICATION',
+                subCategory: 'LocalDevAuthErrorType.PORTAL_NOT_ACTIVE',
+            }) ||
+                (0, index_1.isSpecifiedError)(error, {
+                    statusCode: 404,
+                    category: 'INVALID_AUTHENTICATION',
+                    subCategory: 'LocalDevAuthErrorType.INVALID_PORTAL_ID',
+                });
+            if (portalNotActive) {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.inactive`),
+                    secondaryMessaging: i18n(`${localI18nKey}.inactiveSecondary`, {
+                        command: (0, ui_1.uiCommandReference)(`hs accounts clean`),
+                    }),
+                });
+            }
+            else if ((0, index_1.isSpecifiedError)(error, {
+                statusCode: 401,
+                category: 'INVALID_AUTHENTICATION',
+                subCategory: 'LocalDevAuthErrorType.FAILED_TO_SIGN_REFRESH_TOKEN_DECODE',
+            })) {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'success',
+                    message: i18n(`${localI18nKey}.active`),
+                });
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.pak.invalid`),
+                    secondaryMessaging: i18n(`${localI18nKey}.pak.invalidSecondary`, {
+                        command: (0, ui_1.uiCommandReference)(`hs auth`),
+                    }),
+                });
+            }
+            else {
+                this.diagnosis?.addCLIConfigSection({
+                    type: 'error',
+                    message: i18n(`${localI18nKey}.unableToDetermine`),
+                });
+            }
+        }
+    }
+    async checkIfNodeIsInstalled() {
+        const localI18nKey = `${i18nKey}.nodeChecks`;
+        if (!this.diagnosticInfo?.versions.node) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${localI18nKey}.unableToDetermine`),
+            });
+        }
+        const nodeVersion = this.diagnosticInfo?.versions.node?.split('.');
+        const currentNodeMajor = nodeVersion?.[0];
+        if (!currentNodeMajor || parseInt(currentNodeMajor) < minMajorNodeVersion) {
+            return this.diagnosis?.addCliSection({
+                type: 'warning',
+                message: i18n(`${localI18nKey}.minimumNotMet`, {
+                    nodeVersion: this.diagnosticInfo?.versions.node,
+                }),
+            });
+        }
+        this.diagnosis?.addCliSection({
+            type: 'success',
+            message: i18n(`${localI18nKey}.success`, {
+                nodeVersion: this.diagnosticInfo?.versions.node,
+            }),
+        });
+    }
+    async checkIfNpmIsInstalled() {
+        const localI18nKey = `${i18nKey}.npmChecks`;
+        const npmVersion = this.diagnosticInfo?.versions?.npm;
+        if (!npmVersion) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${localI18nKey}.notInstalled`),
+            });
+        }
+        this.diagnosis?.addCliSection({
+            type: 'success',
+            message: i18n(`${localI18nKey}.installed`, {
+                npmVersion,
+            }),
+        });
+    }
+    async checkCLIVersion() {
+        let latestCLIVersion;
+        try {
+            latestCLIVersion = await (0, dependencyManagement_1.getLatestCliVersion)();
+        }
+        catch (e) {
+            return this.diagnosis?.addCliSection({
+                type: 'error',
+                message: i18n(`${i18nKey}.hsChecks.unableToDetermine`),
+                secondaryMessaging: i18n(`${i18nKey}.hsChecks.unableToDetermineSecondary`, {
+                    command: (0, ui_1.uiCommandReference)(`hs --version`),
+                    link: uiLink(i18n(`${i18nKey}.hsChecks.unableToDetermineSecondaryLink`), `https://www.npmjs.com/package/${package_json_1.default.name}?activeTab=versions`),
+                }),
+            });
+        }
+        if (latestCLIVersion !== package_json_1.default.version) {
+            this.diagnosis?.addCliSection({
+                type: 'warning',
+                message: i18n(`${i18nKey}.hsChecks.notLatest`, {
+                    hsVersion: package_json_1.default.version,
+                }),
+                secondaryMessaging: i18n(`${i18nKey}.hsChecks.notLatestSecondary`, {
+                    hsVersion: package_json_1.default.version,
+                    command: (0, ui_1.uiCommandReference)(`npm install -g ${package_json_1.default.name}`),
+                }),
+            });
+        }
+        else {
+            this.diagnosis?.addCliSection({
+                type: 'success',
+                message: i18n(`${i18nKey}.hsChecks.latest`, {
+                    hsVersion: latestCLIVersion,
+                }),
+            });
+        }
+    }
+    async checkIfNpmInstallRequired() {
+        let foundError = false;
+        const localI18nKey = `${i18nKey}.projectDependenciesChecks`;
+        for (const packageFile of this.diagnosticInfo?.packageFiles || []) {
+            const packageDirName = path_1.default.dirname(packageFile);
+            try {
+                const needsInstall = await (0, dependencyManagement_1.hasMissingPackages)(path_1.default.join(this.projectConfig?.projectDir, packageDirName));
+                if (needsInstall) {
+                    foundError = true;
+                    this.diagnosis?.addProjectSection({
+                        type: 'warning',
+                        message: i18n(`${localI18nKey}.missingDependencies`, {
+                            dir: packageDirName,
+                        }),
+                        secondaryMessaging: i18n(`${localI18nKey}.missingDependenciesSecondary`, {
+                            command: (0, ui_1.uiCommandReference)('hs project install-deps'),
+                        }),
+                    });
+                }
+            }
+            catch (e) {
+                foundError = true;
+                if (!(await this.isValidJsonFile(packageFile))) {
+                    this.diagnosis?.addProjectSection({
+                        type: 'error',
+                        message: i18n(`${i18nKey}.files.invalidJson`, {
+                            filename: packageFile,
+                        }),
+                    });
+                }
+                else {
+                    this.diagnosis?.addProjectSection({
+                        type: 'error',
+                        message: i18n(`${localI18nKey}.unableToDetermine`, {
+                            dir: packageDirName,
+                        }),
+                    });
+                }
+                logger_1.logger.debug(e);
+            }
+        }
+        if (!foundError) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.success`),
+            });
+        }
+    }
+    async isValidJsonFile(filename) {
+        try {
+            const readFile = util_1.default.promisify(fs_1.default.readFile);
+            const fileContents = await readFile(filename);
+            JSON.parse(fileContents.toString());
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    async checkProjectConfigJsonFiles() {
+        let foundError = false;
+        for (const jsonFile of this.diagnosticInfo?.jsonFiles || []) {
+            const fileToCheck = path_1.default.join(this.projectConfig?.projectDir, jsonFile);
+            if (!(await this.isValidJsonFile(fileToCheck))) {
+                foundError = true;
+                this.diagnosis?.addProjectSection({
+                    type: 'error',
+                    message: i18n(`${i18nKey}.files.invalidJson`, {
+                        filename: jsonFile,
+                    }),
+                });
+            }
+        }
+        if (!foundError) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${i18nKey}.files.validJson`),
+            });
+        }
+    }
+    async checkIfPortsAreAvailable() {
+        const localI18nKey = `${i18nKey}.port`;
+        if (await (0, portManager_1.isPortManagerPortAvailable)()) {
+            this.diagnosis?.addProjectSection({
+                type: 'success',
+                message: i18n(`${localI18nKey}.available`, {
+                    port: ports_1.PORT_MANAGER_SERVER_PORT,
+                }),
+            });
+            return;
+        }
+        this.diagnosis?.addProjectSection({
+            type: 'warning',
+            message: i18n(`${localI18nKey}.inUse`, {
+                port: ports_1.PORT_MANAGER_SERVER_PORT,
+            }),
+            secondaryMessaging: i18n(`${localI18nKey}.inUseSecondary`, {
+                command: (0, ui_1.uiCommandReference)('hs project dev'),
+            }),
+        });
+    }
+}
+exports.Doctor = Doctor;

package/lib/errorHandlers/index.d.ts

@@ -1 +1,14 @@
-export {};
+export declare function logError(error: unknown, context?: ApiErrorContext): void;
+export declare function debugError(error: unknown, context?: ApiErrorContext): void;
+export declare class ApiErrorContext {
+    accountId?: number;
+    request?: string;
+    payload?: string;
+    projectName?: string;
+    constructor(props?: {
+        accountId?: number;
+        request?: string;
+        payload?: string;
+        projectName?: string;
+    });
+}