@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/dependencyManagement.js

@@ -0,0 +1,243 @@
+import fs from 'fs';
+import util from 'util';
+import path from 'path';
+import { exec as execAsync } from 'node:child_process';
+import { getProjectConfig } from './projects/config.js';
+import { commands } from '../lang/en.js';
+import SpinniesManager from './ui/SpinniesManager.js';
+import { isGloballyInstalled, executeInstall, executeUpdate, DEFAULT_PACKAGE_MANAGER, } from './npm/npmCli.js';
+import { findAllPackageJsonFilesInProjectCached, safeGetPackageJsonCached, } from './npm/packageJson.js';
+import { getNpmWorkspaceDirectoryForPackageAtLocationCached } from './npm/workspaces.js';
+class NoPackageJsonFilesError extends Error {
+    constructor(projectName, isUpdate = false) {
+        super(isUpdate
+            ? commands.project.updateDeps.noPackageJsonInProject(projectName)
+            : commands.project.installDeps.noPackageJsonInProject(projectName));
+    }
+}
+/**
+ * Installs dependencies in multiple package directories, handling npm workspace configuration.
+ * Also supports adding new packages as dependencies in specific package directories.
+ * Shows progress spinners and manages npm install execution with appropriate flags.
+ *
+ * @param packages - Optional array of package names to install
+ * @param installLocations - Optional array of installation locations (defaults to all package locations in the project)
+ * @param dev - Whether to add --save-dev flag (only when packages are specified)
+ */
+export async function installPackages({ packages, installLocations, dev = false, }) {
+    const installDirs = installLocations || (await getProjectPackageJsonLocations());
+    const hasPackages = packages && packages.length > 0;
+    // Used to collect all of the npm install locations with de-duplication.
+    const npmInstallLocationsSet = new Set();
+    // Used to collect all of the package install tasks.
+    const packageInstallTasks = [];
+    for (const dir of installDirs) {
+        const npmWorkspaceDirectory = await getNpmWorkspaceDirectoryForPackageAtLocationCached(dir);
+        if (hasPackages) {
+            // Package installation tasks (installing specific packages). No de-duplication needed here.
+            packageInstallTasks.push({
+                directory: dir,
+                packages,
+                dev,
+                npmWorkspaceDirectory,
+            });
+        }
+        else {
+            if (npmWorkspaceDirectory) {
+                // If we are not installing specific packages and we are in an npm workspace then we only need to run
+                // `npm install` in the workspace root directory to install the package dependencies for a package that
+                // is part of the workspace. Therefore, we add the workspace root for installation instead of the package.
+                npmInstallLocationsSet.add(npmWorkspaceDirectory);
+            }
+            else {
+                npmInstallLocationsSet.add(dir);
+            }
+        }
+    }
+    const npmInstallLocations = Array.from(npmInstallLocationsSet).sort();
+    // Create tasks for each of the npm install locations to run `npm install` (no specific packages)
+    const npmInstallTasks = npmInstallLocations.map(npmInstallLocation => ({
+        directory: npmInstallLocation,
+        packages: undefined,
+        dev: false,
+        npmWorkspaceDirectory: null,
+    }));
+    // Run all tasks in parallel
+    await Promise.all([...npmInstallTasks, ...packageInstallTasks].map(task => installPackagesInDirectory(task)));
+}
+/**
+ * Installs packages in a specific directory, handling npm workspace configuration.
+ * Shows progress spinners and manages npm install execution with appropriate flags.
+ *
+ * @param directory - The target directory for package installation
+ * @param packages - Optional array of package names to install
+ * @param dev - Whether to add --save-dev flag (only when packages are specified)
+ * @param npmWorkspaceDirectory - The workspace root directory if this is a workspace package, null otherwise
+ */
+async function installPackagesInDirectory({ directory, packages, dev = false, npmWorkspaceDirectory, }) {
+    const spinner = `installingDependencies-${directory}`;
+    const relativeDir = path.relative(process.cwd(), directory) || '.';
+    const hasPackages = packages && packages.length > 0;
+    SpinniesManager.add(spinner, {
+        text: packages && packages.length
+            ? commands.project.installDeps.addingDependenciesToLocation(`[${packages.join(', ')}]`, relativeDir)
+            : commands.project.installDeps.installingDependencies(relativeDir),
+    });
+    try {
+        const flags = [];
+        if (hasPackages && dev) {
+            flags.push('--save-dev');
+        }
+        if (hasPackages && npmWorkspaceDirectory) {
+            // If we are installing packages in an npm workspace, we will run `npm install` in the workspace root directory
+            // and we will use the --workspace flag to install the packages in the target package directory.
+            flags.push(`--workspace=${path.relative(npmWorkspaceDirectory, directory)}`);
+        }
+        await executeInstall(packages, flags.length > 0 ? flags.join(' ') : null, {
+            // Execute the install in the workspace root directory if this package is part of an npm workspace, otherwise
+            // in the package directory.
+            cwd: npmWorkspaceDirectory || directory,
+        });
+        SpinniesManager.succeed(spinner, {
+            text: commands.project.installDeps.installationSuccessful(relativeDir),
+        });
+    }
+    catch (e) {
+        SpinniesManager.fail(spinner, {
+            text: commands.project.installDeps.installingDependenciesFailed(relativeDir),
+        });
+        throw new Error(commands.project.installDeps.installingDependenciesFailed(relativeDir), {
+            cause: e,
+        });
+    }
+}
+export async function updatePackages({ packages, installLocations, }) {
+    const updateDirs = installLocations || (await getProjectPackageJsonLocations(undefined, true));
+    const hasPackages = packages && packages.length > 0;
+    // Used to collect all of the npm update locations with de-duplication.
+    const npmUpdateLocationsSet = new Set();
+    // Used to collect all of the package update tasks.
+    const packageUpdateTasks = [];
+    for (const dir of updateDirs) {
+        const npmWorkspaceDirectory = await getNpmWorkspaceDirectoryForPackageAtLocationCached(dir);
+        if (hasPackages) {
+            packageUpdateTasks.push({
+                directory: dir,
+                packages,
+                npmWorkspaceDirectory,
+            });
+        }
+        else {
+            if (npmWorkspaceDirectory) {
+                // If we are not updating specific packages and we are in an npm workspace then we only need to run
+                // `npm update` in the workspace root directory to update the package dependencies for a package that
+                // is part of the workspace. Therefore, we add the workspace root for update instead of the package.
+                npmUpdateLocationsSet.add(npmWorkspaceDirectory);
+            }
+            else {
+                npmUpdateLocationsSet.add(dir);
+            }
+        }
+    }
+    const npmUpdateLocations = Array.from(npmUpdateLocationsSet).sort();
+    // Create tasks for each of the npm update locations to run `npm update` (no specific packages)
+    const npmUpdateTasks = npmUpdateLocations.map(npmUpdateLocation => ({
+        directory: npmUpdateLocation,
+        packages: undefined,
+        npmWorkspaceDirectory: null,
+    }));
+    // Run all tasks in parallel
+    await Promise.all([...npmUpdateTasks, ...packageUpdateTasks].map(task => updatePackagesInDirectory(task)));
+}
+async function updatePackagesInDirectory({ directory, packages, npmWorkspaceDirectory, }) {
+    const spinner = `updatingDependencies-${directory}`;
+    const relativeDir = path.relative(process.cwd(), directory) || '.';
+    const hasPackages = packages && packages.length > 0;
+    SpinniesManager.add(spinner, {
+        text: packages && packages.length
+            ? commands.project.updateDeps.updatingDependenciesToLocation(`[${packages.join(', ')}]`, relativeDir)
+            : commands.project.updateDeps.updatingDependencies(relativeDir),
+    });
+    try {
+        const flags = [];
+        if (hasPackages && npmWorkspaceDirectory) {
+            // If we are updating packages in an npm workspace, we will run `npm update` in the workspace root directory
+            // and we will use the --workspace flag to update the packages in the target package directory.
+            flags.push(`--workspace=${path.relative(npmWorkspaceDirectory, directory)}`);
+        }
+        await executeUpdate(packages, flags.length > 0 ? flags.join(' ') : null, {
+            cwd: npmWorkspaceDirectory || directory,
+        });
+        SpinniesManager.succeed(spinner, {
+            text: commands.project.updateDeps.updateSuccessful(relativeDir),
+        });
+    }
+    catch (e) {
+        SpinniesManager.fail(spinner, {
+            text: commands.project.updateDeps.updatingDependenciesFailed(relativeDir),
+        });
+        throw new Error(commands.project.updateDeps.updatingDependenciesFailed(relativeDir), {
+            cause: e,
+        });
+    }
+}
+export async function getProjectPackageJsonLocations(dir, isUpdate = false) {
+    const projectConfig = await getProjectConfig(dir);
+    if (!projectConfig ||
+        !projectConfig.projectDir ||
+        !projectConfig.projectConfig) {
+        throw new Error(isUpdate
+            ? commands.project.updateDeps.noProjectConfig
+            : commands.project.installDeps.noProjectConfig);
+    }
+    const { projectDir, projectConfig: { srcDir, name }, } = projectConfig;
+    if (!(await isGloballyInstalled(DEFAULT_PACKAGE_MANAGER))) {
+        throw new Error(isUpdate
+            ? commands.project.updateDeps.packageManagerNotInstalled(DEFAULT_PACKAGE_MANAGER)
+            : commands.project.installDeps.packageManagerNotInstalled(DEFAULT_PACKAGE_MANAGER));
+    }
+    if (!fs.existsSync(projectConfig.projectDir) ||
+        !fs.existsSync(path.join(projectDir, srcDir))) {
+        throw new NoPackageJsonFilesError(name, isUpdate);
+    }
+    const packageJsonFiles = await findAllPackageJsonFilesInProjectCached();
+    if (packageJsonFiles.length === 0) {
+        throw new NoPackageJsonFilesError(name, isUpdate);
+    }
+    const packageParentDirs = [];
+    packageJsonFiles.forEach(packageJsonFile => {
+        const parentDir = path.dirname(packageJsonFile);
+        packageParentDirs.push(parentDir);
+    });
+    return packageParentDirs;
+}
+function isPackageInPackageJson(directory, packageName) {
+    const packageJsonPath = path.join(directory, 'package.json');
+    const packageJson = safeGetPackageJsonCached(packageJsonPath);
+    if (!packageJson) {
+        return false;
+    }
+    return !!((packageJson.dependencies && packageJson.dependencies[packageName]) ||
+        (packageJson.devDependencies && packageJson.devDependencies[packageName]));
+}
+function isPackageInNodeModules(directory, packageName) {
+    const packagePath = path.join(directory, 'node_modules', packageName);
+    try {
+        return fs.existsSync(packagePath);
+    }
+    catch (error) {
+        return false;
+    }
+}
+export function isPackageInstalled(directory, packageName) {
+    const inPackageJson = isPackageInPackageJson(directory, packageName);
+    const actuallyInstalled = isPackageInNodeModules(directory, packageName);
+    return inPackageJson && actuallyInstalled;
+}
+export async function hasMissingPackages(directory) {
+    const exec = util.promisify(execAsync);
+    const { stdout } = await exec(`npm install --ignore-scripts --dry-run`, {
+        cwd: directory,
+    });
+    return !stdout?.includes('up to date in');
+}

package/lib/developerTestAccounts.d.ts

@@ -0,0 +1,6 @@
+import { HubSpotConfigAccount } from '@hubspot/local-dev-lib/types/Accounts';
+import { FetchDeveloperTestAccountsResponse } from '@hubspot/local-dev-lib/types/developerTestAccounts.js';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+export declare function getHasDevTestAccounts(appDeveloperAccountConfig: HubSpotConfigAccount): boolean;
+export declare function validateDevTestAccountUsageLimits(accountConfig: HubSpotConfigAccount): Promise<FetchDeveloperTestAccountsResponse | null>;
+export declare function handleDeveloperTestAccountCreateError(err: unknown, accountId: number, env: Environment, portalLimit: number): never;

package/lib/developerTestAccounts.js

@@ -0,0 +1,66 @@
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { getAllConfigAccounts } from '@hubspot/local-dev-lib/config';
+import { fetchDeveloperTestAccounts } from '@hubspot/local-dev-lib/api/developerTestAccounts';
+import { isMissingScopeError, isSpecifiedError, } from '@hubspot/local-dev-lib/errors/index';
+import { uiLogger } from './ui/logger.js';
+import { getHubSpotWebsiteOrigin } from '@hubspot/local-dev-lib/urls';
+import { lib } from '../lang/en.js';
+import { uiAccountDescription } from './ui/index.js';
+import { logError } from './errorHandlers/index.js';
+export function getHasDevTestAccounts(appDeveloperAccountConfig) {
+    const parentPortalId = appDeveloperAccountConfig.accountId;
+    const accountsList = getAllConfigAccounts();
+    if (!accountsList) {
+        return false;
+    }
+    for (const portal of accountsList) {
+        if (Boolean(portal.parentAccountId) &&
+            portal.parentAccountId === parentPortalId &&
+            portal.accountType === HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function validateDevTestAccountUsageLimits(accountConfig) {
+    const accountId = accountConfig.accountId;
+    if (!accountId) {
+        return null;
+    }
+    const { data } = await fetchDeveloperTestAccounts(accountId);
+    if (!data) {
+        return null;
+    }
+    const limit = data.maxTestPortals;
+    const count = data.results.length;
+    if (count >= limit) {
+        const hasDevTestAccounts = getHasDevTestAccounts(accountConfig);
+        if (hasDevTestAccounts) {
+            throw new Error(lib.developerTestAccount.create.failure.alreadyInConfig(accountConfig.name || accountId, limit));
+        }
+        else {
+            throw new Error(lib.developerTestAccount.create.failure.limit(accountConfig.name || accountId, limit));
+        }
+    }
+    return data;
+}
+export function handleDeveloperTestAccountCreateError(err, accountId, env, portalLimit) {
+    if (isMissingScopeError(err)) {
+        uiLogger.error(lib.developerTestAccount.create.failure.scopes.message);
+        const websiteOrigin = getHubSpotWebsiteOrigin(env);
+        const url = `${websiteOrigin}/personal-access-key/${accountId}`;
+        uiLogger.info(lib.developerTestAccount.create.failure.scopes.instructions(uiAccountDescription(accountId), url));
+    }
+    else if (isSpecifiedError(err, {
+        statusCode: 400,
+        errorType: 'TEST_PORTAL_LIMIT_REACHED',
+    })) {
+        uiLogger.log('');
+        uiLogger.error(lib.developerTestAccount.create.failure.limit(uiAccountDescription(accountId), portalLimit));
+        uiLogger.log('');
+    }
+    else {
+        logError(err);
+    }
+    throw err;
+}

package/lib/doctor/Diagnosis.d.ts

@@ -0,0 +1,27 @@
+import { DiagnosticInfo } from './DiagnosticInfoBuilder.js';
+interface DiagnosisOptions {
+    diagnosticInfo: DiagnosticInfo;
+    accountId: number | null;
+}
+interface Section {
+    type: 'error' | 'warning' | 'success';
+    message: string;
+    secondaryMessaging?: string;
+}
+export declare class Diagnosis {
+    private readonly prefixes;
+    private readonly diagnosis;
+    private errorCount;
+    private warningCount;
+    constructor({ diagnosticInfo, accountId }: DiagnosisOptions);
+    getErrorCount(): number;
+    getWarningCount(): number;
+    addCliSection(section: Section): void;
+    addProjectSection(section: Section): void;
+    addCLIConfigSection(section: Section): void;
+    addNetworkingSection(section: Section): void;
+    addDefaultAccountOverrideFileSection(section: Section): void;
+    toString(): string;
+    private generateSections;
+}
+export {};

package/lib/doctor/Diagnosis.js

@@ -0,0 +1,113 @@
+import { prefixOptions } from '../ui/spinniesUtils.js';
+import chalk from 'chalk';
+import { helpers } from '../interpolation.js';
+import { uiAccountDescription } from '../ui/index.js';
+import { indent } from '../ui/index.js';
+import { lib } from '../../lang/en.js';
+export class Diagnosis {
+    prefixes;
+    diagnosis;
+    errorCount = 0;
+    warningCount = 0;
+    constructor({ diagnosticInfo, accountId }) {
+        const { succeedPrefix, failPrefix } = prefixOptions({});
+        this.prefixes = {
+            success: chalk.green(succeedPrefix),
+            error: chalk.red(failPrefix),
+            warning: helpers.orange('!'),
+        };
+        this.diagnosis = {
+            cli: {
+                header: lib.doctor.diagnosis.cli.header,
+                sections: [],
+            },
+            cliConfig: {
+                header: lib.doctor.diagnosis.cliConfig.header,
+                sections: [],
+            },
+            networking: {
+                header: lib.doctor.networkChecks.header,
+                sections: [],
+            },
+            defaultAccountOverrideFile: {
+                header: lib.doctor.diagnosis.defaultAccountOverrideFile.header,
+                sections: [],
+            },
+            project: {
+                header: lib.doctor.diagnosis.projectConfig.header,
+                subheaders: [
+                    lib.doctor.diagnosis.projectConfig.projectDirSubHeader(diagnosticInfo.project?.config?.projectDir || ''),
+                    lib.doctor.diagnosis.projectConfig.projectNameSubHeader(diagnosticInfo.project?.config?.projectConfig?.name || ''),
+                ],
+                sections: [],
+            },
+        };
+        if (diagnosticInfo.config) {
+            this.diagnosis.cliConfig.subheaders = [
+                lib.doctor.diagnosis.cliConfig.configFileSubHeader(diagnosticInfo.config),
+                lib.doctor.diagnosis.cliConfig.defaultAccountSubHeader(uiAccountDescription(accountId)),
+            ];
+        }
+    }
+    getErrorCount() {
+        return this.errorCount;
+    }
+    getWarningCount() {
+        return this.warningCount;
+    }
+    addCliSection(section) {
+        this.diagnosis.cli.sections.push(section);
+    }
+    addProjectSection(section) {
+        this.diagnosis.project.sections.push(section);
+    }
+    addCLIConfigSection(section) {
+        this.diagnosis.cliConfig.sections.push(section);
+    }
+    addNetworkingSection(section) {
+        this.diagnosis.networking.sections.push(section);
+    }
+    addDefaultAccountOverrideFileSection(section) {
+        this.diagnosis.defaultAccountOverrideFile.sections.push(section);
+    }
+    toString() {
+        const output = [];
+        for (const value of Object.values(this.diagnosis)) {
+            const section = this.generateSections(value);
+            if (section) {
+                output.push(section);
+            }
+        }
+        if (output.length === 0) {
+            return '';
+        }
+        output.push('');
+        output.push(lib.doctor.diagnosis.counts.errors(this.errorCount));
+        output.push(lib.doctor.diagnosis.counts.warnings(this.warningCount));
+        output.push('');
+        return output.join('\n');
+    }
+    generateSections(category) {
+        const output = [];
+        if (category.sections && category.sections.length === 0) {
+            return '';
+        }
+        output.push(`\n${chalk.bold(category.header)}`);
+        (category.subheaders || []).forEach(subheader => {
+            output.push(`${subheader}`);
+        });
+        category.sections.forEach(section => {
+            if (section.type === 'error') {
+                this.errorCount++;
+            }
+            else if (section.type === 'warning') {
+                this.warningCount++;
+            }
+            output.push(`${indent(1)}${this.prefixes[section.type]} ${section.message}`);
+            if (section.secondaryMessaging) {
+                output.push(`${indent(2)}- ${section.secondaryMessaging}`);
+            }
+        });
+        return output.join('\n');
+    }
+}

package/lib/doctor/DiagnosticInfoBuilder.d.ts

@@ -0,0 +1,69 @@
+import { getProjectConfig } from '../projects/config.js';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+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[];
+    hsMetaFiles: 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;
+    defaultAccountOverrideFile: string | null | undefined;
+    configSettings: {
+        [key: string]: unknown;
+    };
+    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 | undefined;
+    readonly configSettings: {
+        [key: string]: unknown;
+    };
+    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 {};