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

package/lib/projects/localDev/LocalDevManager_DEPRECATED.js

@@ -0,0 +1,387 @@
+import path from 'path';
+import chokidar from 'chokidar';
+import chalk from 'chalk';
+import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
+import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts, } from '@hubspot/local-dev-lib/api/appsDev';
+import { getConfigDefaultAccountIfExists } from '@hubspot/local-dev-lib/config';
+import { PROJECT_CONFIG_FILE } from '../../constants.js';
+import SpinniesManager from '../../ui/SpinniesManager.js';
+import DevServerManager_DEPRECATED from './DevServerManager_DEPRECATED.js';
+import DevSessionManager from './DevSessionManager.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { getAccountHomeUrl } from '../urls.js';
+import { getErrorMessage } from '../../errorHandlers/index.js';
+import { componentIsApp, componentIsPublicApp, CONFIG_FILES, getAppCardConfigs, getComponentUid, } from '../structure.js';
+import { ComponentTypes, } from '../../../types/Projects.js';
+import { UI_COLORS, uiCommandReference, uiAccountDescription, uiLink, uiLine, } from '../../ui/index.js';
+import { logError } from '../../errorHandlers/index.js';
+import { PromptExitError } from '../../errors/PromptExitError.js';
+import { installAppBrowserPrompt } from '../../prompts/installAppPrompt.js';
+import { confirmPrompt } from '../../prompts/promptUtils.js';
+import { handleKeypress } from '../../process.js';
+import { lib } from '../../../lang/en.js';
+import { uiLogger } from '../../ui/logger.js';
+import { getOauthAppInstallUrl } from '../../app/urls.js';
+const WATCH_EVENTS = {
+    add: 'add',
+    change: 'change',
+    unlink: 'unlink',
+    unlinkDir: 'unlinkDir',
+};
+class LocalDevManager_DEPRECATED {
+    targetAccountId;
+    targetProjectAccountId;
+    projectConfig;
+    projectDir;
+    projectId;
+    debug;
+    deployedBuild;
+    isGithubLinked;
+    watcher;
+    uploadWarnings;
+    runnableComponents;
+    activeApp;
+    activePublicAppData;
+    env;
+    publicAppActiveInstalls;
+    projectSourceDir;
+    mostRecentUploadWarning;
+    devSessionManager;
+    constructor(options) {
+        this.targetAccountId = options.targetAccountId;
+        // The account that the project exists in. This is not always the targetAccountId
+        this.targetProjectAccountId = options.parentAccountId;
+        this.projectConfig = options.projectConfig;
+        this.projectDir = options.projectDir;
+        this.projectId = options.projectId;
+        this.debug = options.debug || false;
+        this.deployedBuild = options.deployedBuild;
+        this.isGithubLinked = options.isGithubLinked;
+        this.watcher = null;
+        this.uploadWarnings = {};
+        this.runnableComponents = options.runnableComponents;
+        this.activeApp = null;
+        this.activePublicAppData = null;
+        this.env = options.env;
+        this.publicAppActiveInstalls = null;
+        this.mostRecentUploadWarning = null;
+        this.projectSourceDir = path.join(this.projectDir, this.projectConfig.srcDir);
+        if (!this.targetAccountId || !this.projectConfig || !this.projectDir) {
+            uiLogger.log(lib.LocalDevManager.failedToInitialize);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        this.devSessionManager = new DevSessionManager({
+            targetTestingAccountId: this.targetAccountId,
+        });
+    }
+    async setActiveApp(appUid) {
+        if (!appUid) {
+            uiLogger.error(lib.LocalDevManager.missingUid);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        this.activeApp =
+            this.runnableComponents.find(component => {
+                return getComponentUid(component) === appUid;
+            }) || null;
+        if (componentIsPublicApp(this.activeApp)) {
+            try {
+                await this.setActivePublicAppData();
+                await this.checkActivePublicAppInstalls();
+                await this.checkPublicAppInstallation();
+            }
+            catch (e) {
+                if (e instanceof PromptExitError) {
+                    throw e;
+                }
+                logError(e);
+            }
+        }
+    }
+    async setActivePublicAppData() {
+        if (!this.activeApp) {
+            return;
+        }
+        const { data: { results: portalPublicApps }, } = await fetchPublicAppsForPortal(this.targetProjectAccountId);
+        const activePublicAppData = portalPublicApps.find(({ sourceId }) => sourceId === getComponentUid(this.activeApp));
+        if (!activePublicAppData) {
+            return;
+        }
+        const { data: { uniquePortalInstallCount }, } = await fetchPublicAppProductionInstallCounts(activePublicAppData.id, this.targetProjectAccountId);
+        this.activePublicAppData = activePublicAppData;
+        this.publicAppActiveInstalls = uniquePortalInstallCount;
+    }
+    async checkActivePublicAppInstalls() {
+        if (!this.activePublicAppData ||
+            !this.publicAppActiveInstalls ||
+            this.publicAppActiveInstalls < 1) {
+            return;
+        }
+        uiLine();
+        uiLogger.warn(lib.LocalDevManager.activeInstallWarning.installCount(this.activePublicAppData.name, this.publicAppActiveInstalls));
+        uiLogger.log(lib.LocalDevManager.activeInstallWarning.explanation);
+        uiLine();
+        const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
+        if (!proceed) {
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+    }
+    async start() {
+        SpinniesManager.stopAll();
+        SpinniesManager.init();
+        // Local dev currently relies on the existence of a deployed build in the target account
+        if (!this.deployedBuild) {
+            uiLogger.error(lib.LocalDevManager.noDeployedBuild(this.projectConfig.name, uiAccountDescription(this.targetProjectAccountId), this.getUploadCommand()));
+            uiLogger.log('');
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        const setupSucceeded = await this.devServerSetup();
+        if (!setupSucceeded) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        else if (!this.debug) {
+            console.clear();
+        }
+        uiLogger.log(lib.LocalDevManager.headerMessage);
+        uiLogger.log(uiLink(lib.LocalDevManager.learnMoreLocalDevServer, 'https://developers.hubspot.com/docs/developer-tooling/local-development/hubspot-cli/project-commands'));
+        uiLogger.log('');
+        uiLogger.log(chalk.hex(UI_COLORS.SORBET)(lib.LocalDevManager.running(this.projectConfig.name, uiAccountDescription(this.targetAccountId))));
+        uiLogger.log(lib.LocalDevManager.viewProjectLink(this.projectConfig.name, this.targetProjectAccountId));
+        if (this.activeApp?.type === ComponentTypes.PublicApp) {
+            uiLogger.log(uiLink(lib.LocalDevManager.viewTestAccountLink, getAccountHomeUrl(this.targetAccountId)));
+        }
+        uiLogger.log('');
+        uiLogger.log(lib.LocalDevManager.quitHelper);
+        uiLine();
+        uiLogger.log('');
+        await this.devServerStart();
+        const devSessionRegistered = await this.devSessionManager.registerSession();
+        if (!devSessionRegistered) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        // Initialize project file watcher to detect configuration file changes
+        this.startWatching();
+        this.updateKeypressListeners();
+        this.monitorConsoleOutput();
+        // Verify that there are no mismatches between components in the local project
+        // and components in the deployed build of the project.
+        this.compareLocalProjectToDeployed();
+    }
+    async stop(showProgress = true) {
+        if (showProgress) {
+            SpinniesManager.add('cleanupMessage', {
+                text: lib.LocalDevManager.exitingStart,
+            });
+        }
+        await this.stopWatching();
+        const cleanupServersSucceeded = await this.devServerCleanup();
+        const cleanupSessionSucceeded = await this.devSessionManager.deleteDevSession();
+        if (!cleanupServersSucceeded || !cleanupSessionSucceeded) {
+            if (showProgress) {
+                SpinniesManager.fail('cleanupMessage', {
+                    text: lib.LocalDevManager.exitingFail,
+                });
+            }
+            process.exit(EXIT_CODES.ERROR);
+        }
+        if (showProgress) {
+            SpinniesManager.succeed('cleanupMessage', {
+                text: lib.LocalDevManager.exitingSucceed,
+            });
+        }
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    async checkPublicAppInstallation() {
+        if (!componentIsPublicApp(this.activeApp) || !this.activePublicAppData) {
+            return;
+        }
+        const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.targetAccountId, this.projectId, this.activeApp.config.uid, this.activeApp.config.auth.requiredScopes, this.activeApp.config.auth.optionalScopes);
+        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
+        if (!isInstalledWithScopeGroups) {
+            const installUrl = getOauthAppInstallUrl({
+                targetAccountId: this.targetAccountId,
+                env: this.env,
+                clientId: this.activePublicAppData.clientId,
+                scopes: this.activeApp.config.auth.requiredScopes,
+                redirectUrls: this.activeApp.config.auth.redirectUrls,
+            });
+            await installAppBrowserPrompt(installUrl, isReinstall);
+        }
+    }
+    updateKeypressListeners() {
+        handleKeypress(async (key) => {
+            if ((key.ctrl && key.name === 'c') || key.name === 'q') {
+                this.stop();
+            }
+        });
+    }
+    getUploadCommand() {
+        const currentDefaultAccount = getConfigDefaultAccountIfExists();
+        return this.targetProjectAccountId !== currentDefaultAccount?.accountId
+            ? uiCommandReference(`hs project upload --account=${this.targetProjectAccountId}`)
+            : uiCommandReference('hs project upload');
+    }
+    logUploadWarning(reason) {
+        let warning;
+        if (reason) {
+            warning = reason;
+        }
+        else {
+            warning =
+                componentIsPublicApp(this.activeApp) &&
+                    this.publicAppActiveInstalls &&
+                    this.publicAppActiveInstalls > 0
+                    ? lib.LocalDevManager.uploadWarning.defaultPublicAppWarning(this.publicAppActiveInstalls, this.publicAppActiveInstalls === 1 ? 'install' : 'installs')
+                    : lib.LocalDevManager.uploadWarning.defaultWarning;
+        }
+        // Avoid logging the warning to the console if it is currently the most
+        // recently logged warning. We do not want to spam the console with the same message.
+        if (!this.uploadWarnings[warning]) {
+            uiLogger.log('');
+            uiLogger.warn(lib.LocalDevManager.uploadWarning.header(warning));
+            uiLogger.log(lib.LocalDevManager.uploadWarning.stopDev);
+            if (this.isGithubLinked) {
+                uiLogger.log(lib.LocalDevManager.uploadWarning.pushToGithub);
+            }
+            else {
+                uiLogger.log(lib.LocalDevManager.uploadWarning.runUpload(this.getUploadCommand()));
+            }
+            uiLogger.log(lib.LocalDevManager.uploadWarning.restartDev);
+            this.mostRecentUploadWarning = warning;
+            this.uploadWarnings[warning] = true;
+        }
+    }
+    monitorConsoleOutput() {
+        const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+        function customStdoutWrite(chunk, encoding, callback) {
+            // Reset the most recently logged warning
+            if (this.mostRecentUploadWarning &&
+                this.uploadWarnings[this.mostRecentUploadWarning]) {
+                delete this.uploadWarnings[this.mostRecentUploadWarning];
+            }
+            if (typeof encoding === 'function') {
+                return originalStdoutWrite(chunk, callback);
+            }
+            return originalStdoutWrite(chunk, encoding, callback);
+        }
+        customStdoutWrite.bind(this);
+        process.stdout.write = customStdoutWrite;
+    }
+    compareLocalProjectToDeployed() {
+        const deployedComponentNames = this.deployedBuild.subbuildStatuses.map(subbuildStatus => subbuildStatus.buildName);
+        const missingComponents = [];
+        this.runnableComponents
+            .filter(componentIsApp)
+            .forEach(({ type, config, path }) => {
+            if (Object.values(ComponentTypes).includes(type)) {
+                const cardConfigs = getAppCardConfigs(config, path);
+                if (!deployedComponentNames.includes(config.name)) {
+                    missingComponents.push(`${lib.LocalDevManager.uploadWarning.appLabel} ${config.name}`);
+                }
+                cardConfigs.forEach(cardConfig => {
+                    if (cardConfig.data &&
+                        cardConfig.data.title &&
+                        !deployedComponentNames.includes(cardConfig.data.title)) {
+                        missingComponents.push(`${lib.LocalDevManager.uploadWarning.uiExtensionLabel} ${cardConfig.data.title}`);
+                    }
+                });
+            }
+        });
+        if (missingComponents.length) {
+            this.logUploadWarning(lib.LocalDevManager.uploadWarning.missingComponents(missingComponents.join(', ')));
+        }
+    }
+    startWatching() {
+        this.watcher = chokidar.watch(this.projectDir, {
+            ignoreInitial: true,
+        });
+        const configPaths = this.runnableComponents
+            .filter(({ type }) => Object.values(ComponentTypes).includes(type))
+            .map(component => {
+            const appConfigPath = path.join(component.path, CONFIG_FILES[component.type]);
+            return appConfigPath;
+        });
+        const projectConfigPath = path.join(this.projectDir, PROJECT_CONFIG_FILE);
+        configPaths.push(projectConfigPath);
+        this.watcher.on('add', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.add, configPaths);
+        });
+        this.watcher.on('change', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.change, configPaths);
+        });
+        this.watcher.on('unlink', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlink, configPaths);
+        });
+        this.watcher.on('unlinkDir', filePath => {
+            this.handleWatchEvent(filePath, WATCH_EVENTS.unlinkDir, configPaths);
+        });
+    }
+    async stopWatching() {
+        await this.watcher?.close();
+    }
+    handleWatchEvent(filePath, event, configPaths) {
+        if (configPaths.includes(filePath)) {
+            this.logUploadWarning();
+        }
+        else {
+            this.devServerFileChange(filePath, event);
+        }
+    }
+    async devServerSetup() {
+        try {
+            await DevServerManager_DEPRECATED.setup({
+                components: this.runnableComponents,
+                onUploadRequired: this.logUploadWarning.bind(this),
+                accountId: this.targetAccountId,
+                setActiveApp: this.setActiveApp.bind(this),
+            });
+            return true;
+        }
+        catch (e) {
+            if (this.debug) {
+                uiLogger.error(getErrorMessage(e));
+            }
+            uiLogger.error(lib.LocalDevManager.devServer.setupError(getErrorMessage(e)));
+            return false;
+        }
+    }
+    async devServerStart() {
+        try {
+            await DevServerManager_DEPRECATED.start({
+                accountId: this.targetAccountId,
+                projectConfig: this.projectConfig,
+            });
+        }
+        catch (e) {
+            if (this.debug) {
+                uiLogger.error(getErrorMessage(e));
+            }
+            uiLogger.error(lib.LocalDevManager.devServer.startError(getErrorMessage(e)));
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    devServerFileChange(filePath, event) {
+        try {
+            DevServerManager_DEPRECATED.fileChange({ filePath, event });
+        }
+        catch (e) {
+            if (this.debug) {
+                uiLogger.error(getErrorMessage(e));
+            }
+            uiLogger.error(lib.LocalDevManager.devServer.fileChangeError(getErrorMessage(e)));
+        }
+    }
+    async devServerCleanup() {
+        try {
+            await DevServerManager_DEPRECATED.cleanup();
+            return true;
+        }
+        catch (e) {
+            if (this.debug) {
+                uiLogger.error(getErrorMessage(e));
+            }
+            uiLogger.error(lib.LocalDevManager.devServer.cleanupError(getErrorMessage(e)));
+            return false;
+        }
+    }
+}
+export default LocalDevManager_DEPRECATED;

package/lib/projects/localDev/LocalDevProcess.d.ts

@@ -0,0 +1,39 @@
+import { type IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage, LocalDevProjectUploadResult, LocalDevProjectDeployResult } from '../../../types/LocalDev.js';
+declare class LocalDevProcess {
+    private state;
+    private _logger;
+    private devServerManager;
+    private devSessionManager;
+    constructor(options: LocalDevStateConstructorOptions);
+    get projectDir(): string;
+    get projectData(): Project;
+    get targetProjectAccountId(): number;
+    get targetTestingAccountId(): number;
+    get projectNodes(): {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    get logger(): LocalDevLogger;
+    private setupDevServers;
+    private startDevServers;
+    private cleanupDevServers;
+    private projectConfigValidForUpload;
+    private getIntermediateRepresentation;
+    private updateProjectNodes;
+    private updateProjectNodesAfterDeploy;
+    private openLocalDevUi;
+    private updateProjectData;
+    handleFileChange(filePath: string, event: string): Promise<void>;
+    handleConfigFileChange(): Promise<void>;
+    start(): Promise<void>;
+    stop(showProgress?: boolean): Promise<void>;
+    uploadProject(): Promise<LocalDevProjectUploadResult>;
+    deployLatestBuild(force?: boolean): Promise<LocalDevProjectDeployResult>;
+    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    sendDevServerMessage(message: LocalDevServerMessage): void;
+    removeStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+}
+export default LocalDevProcess;