@hubspot/cli 7.7.0-experimental.3 → 7.7.0

package/lib/projects/localDev/LocalDevProcess.js

@@ -1,26 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
-const path_1 = __importDefault(require("path"));
-const LocalDevState_1 = __importDefault(require("./LocalDevState"));
-const LocalDevLogger_1 = __importDefault(require("./LocalDevLogger"));
-const DevServerManagerV2_1 = __importDefault(require("./DevServerManagerV2"));
-const exitCodes_1 = require("../../enums/exitCodes");
-const transform_1 = require("@hubspot/project-parsing-lib/src/lib/transform");
-const config_1 = require("../config");
-const upload_1 = require("../upload");
-const buildAndDeploy_1 = require("../buildAndDeploy");
+import { translateForLocalDev } from '@hubspot/project-parsing-lib';
+import { hasLocalStateFlag } from '@hubspot/local-dev-lib/config';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import path from 'path';
+import open from 'open';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+import DevServerManagerV2 from './DevServerManagerV2.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { getProjectConfig } from '../config.js';
+import { handleProjectUpload } from '../upload.js';
+import { handleProjectDeploy } from '../deploy.js';
+import { pollProjectBuildAndDeploy } from '../pollProjectBuildAndDeploy.js';
+import { getLocalDevUiUrl } from '../urls.js';
+import { CONFIG_LOCAL_STATE_FLAGS, PROJECT_DEPLOY_STATES, } from '../../constants.js';
+import { isAutoOpenBrowserEnabled } from '../../configOptions.js';
+import { lib } from '../../../lang/en.js';
+import { debugError } from '../../errorHandlers/index.js';
 class LocalDevProcess {
     state;
     _logger;
     devServerManager;
     constructor(options) {
-        this.state = new LocalDevState_1.default(options);
-        this._logger = new LocalDevLogger_1.default(this.state);
-        this.devServerManager = new DevServerManagerV2_1.default({
+        this.state = new LocalDevState(options);
+        this._logger = new LocalDevLogger(this.state);
+        this.devServerManager = new DevServerManagerV2({
             localDevState: this.state,
             logger: this._logger,
         });
@@ -28,6 +31,15 @@ class LocalDevProcess {
     get projectDir() {
         return this.state.projectDir;
     }
+    get projectData() {
+        return this.state.projectData;
+    }
+    get targetProjectAccountId() {
+        return this.state.targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this.state.targetTestingAccountId;
+    }
     get projectNodes() {
         return this.state.projectNodes;
     }
@@ -50,7 +62,7 @@ class LocalDevProcess {
         }
         catch (e) {
             this.logger.devServerStartError(e);
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            process.exit(EXIT_CODES.ERROR);
         }
     }
     async cleanupDevServers() {
@@ -63,22 +75,8 @@ class LocalDevProcess {
             return false;
         }
     }
-    compareLocalProjectToDeployed() {
-        const deployedComponentNames = this.state.deployedBuild.subbuildStatuses.map(subbuildStatus => subbuildStatus.buildName);
-        const missingProjectNodes = [];
-        Object.values(this.projectNodes).forEach(node => {
-            if (!deployedComponentNames.includes(node.uid)) {
-                const userFriendlyName = (0, transform_1.mapToUserFriendlyName)(node.componentType);
-                const label = userFriendlyName ? `[${userFriendlyName}] ` : '';
-                missingProjectNodes.push(`${label}${node.uid}`);
-            }
-        });
-        if (missingProjectNodes.length) {
-            this.logger.missingComponentsWarning(missingProjectNodes);
-        }
-    }
     async projectConfigValidForUpload() {
-        const { projectConfig } = await (0, config_1.getProjectConfig)();
+        const { projectConfig } = await getProjectConfig();
         if (!projectConfig) {
             return false;
         }
@@ -90,7 +88,45 @@ class LocalDevProcess {
         });
         return true;
     }
-    handleFileChange(filePath, event) {
+    getIntermediateRepresentation(projectNodesAtLastDeploy) {
+        return translateForLocalDev({
+            projectSourceDir: path.join(this.state.projectDir, this.state.projectConfig.srcDir),
+            platformVersion: this.state.projectConfig.platformVersion,
+            accountId: this.state.targetProjectAccountId,
+        }, {
+            projectNodesAtLastUpload: projectNodesAtLastDeploy,
+            profile: this.state.profile,
+        });
+    }
+    async updateProjectNodes() {
+        const intermediateRepresentation = await this.getIntermediateRepresentation(this.state.projectNodesAtLastDeploy);
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+        this.state.projectProfileData = intermediateRepresentation.profileData;
+    }
+    async updateProjectNodesAfterDeploy() {
+        const intermediateRepresentation = await this.getIntermediateRepresentation();
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+        this.state.projectProfileData = intermediateRepresentation.profileData;
+        this.state.projectNodesAtLastDeploy =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+    }
+    openLocalDevUi() {
+        const showWelcomeScreen = !hasLocalStateFlag(CONFIG_LOCAL_STATE_FLAGS.LOCAL_DEV_UI_WELCOME);
+        open(getLocalDevUiUrl(this.state.targetTestingAccountId, showWelcomeScreen));
+    }
+    async updateProjectData() {
+        try {
+            const { data: projectData } = await fetchProject(this.state.targetProjectAccountId, this.state.projectConfig.name);
+            this.state.projectData = projectData;
+        }
+        catch (e) {
+            debugError(e);
+        }
+    }
+    async handleFileChange(filePath, event) {
+        await this.updateProjectNodes();
         try {
             this.devServerManager.fileChange({ filePath, event });
         }
@@ -98,23 +134,22 @@ class LocalDevProcess {
             this.logger.fileChangeError(e);
         }
     }
+    async handleConfigFileChange() {
+        await this.updateProjectNodes();
+        this.logger.uploadWarning();
+    }
     async start() {
         this.logger.resetSpinnies();
-        // Local dev currently relies on the existence of a deployed build in the target account
-        if (!this.state.deployedBuild) {
-            this.logger.noDeployedBuild();
-            process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
-        }
         const setupSucceeded = await this.setupDevServers();
         if (!setupSucceeded) {
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            process.exit(EXIT_CODES.ERROR);
         }
         this.logger.startupMessage();
+        if (isAutoOpenBrowserEnabled()) {
+            this.openLocalDevUi();
+        }
         await this.startDevServers();
         this.logger.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) {
@@ -125,47 +160,106 @@ class LocalDevProcess {
             if (showProgress) {
                 this.logger.cleanupError();
             }
-            process.exit(exitCodes_1.EXIT_CODES.ERROR);
+            process.exit(EXIT_CODES.ERROR);
         }
         if (showProgress) {
             this.logger.cleanupSuccess();
         }
-        process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
-    }
-    async updateProjectNodes() {
-        const intermediateRepresentation = await (0, project_parsing_lib_1.translateForLocalDev)({
-            projectSourceDir: path_1.default.join(this.state.projectDir, this.state.projectConfig.srcDir),
-            platformVersion: this.state.projectConfig.platformVersion,
-            accountId: this.state.targetProjectAccountId,
-        });
-        this.state.projectNodes =
-            intermediateRepresentation.intermediateNodesIndexedByUid;
+        process.exit(EXIT_CODES.SUCCESS);
     }
     async uploadProject() {
         this.logger.uploadInitiated();
         const isUploadable = await this.projectConfigValidForUpload();
         if (!isUploadable) {
             this.logger.projectConfigMismatch();
-            return;
+            return {
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+            };
         }
-        const { uploadError } = await (0, upload_1.handleProjectUpload)({
+        const { uploadError, result } = await handleProjectUpload({
             accountId: this.state.targetProjectAccountId,
             projectConfig: this.state.projectConfig,
             projectDir: this.state.projectDir,
-            callbackFunc: buildAndDeploy_1.pollProjectBuildAndDeploy,
+            callbackFunc: pollProjectBuildAndDeploy,
             sendIR: true,
-            skipValidation: true,
         });
+        const deploy = result?.deployResult;
         if (uploadError) {
             this.logger.uploadError(uploadError);
+            return {
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+                deployId: deploy?.deployId,
+            };
+        }
+        await this.updateProjectData();
+        if (deploy && deploy.status === PROJECT_DEPLOY_STATES.FAILURE) {
+            return {
+                uploadSuccess: false,
+                buildSuccess: true,
+                deploySuccess: false,
+                deployId: deploy.deployId,
+            };
+        }
+        else if (!deploy) {
+            this.logger.uploadSuccessAutoDeployDisabled();
         }
         else {
+            await this.updateProjectNodesAfterDeploy();
+            this.state.clearUploadWarnings();
             this.logger.uploadSuccess();
-            this.logger.clearUploadWarnings();
         }
+        return {
+            uploadSuccess: true,
+            buildSuccess: true,
+            deploySuccess: Boolean(deploy),
+            deployId: deploy?.deployId,
+        };
+    }
+    async deployLatestBuild(force = false) {
+        this.logger.deployInitiated();
+        if (!this.state.projectData.latestBuild) {
+            this.logger.deployError(lib.LocalDevProcess.noBuildToDeploy);
+            return {
+                success: false,
+            };
+        }
+        let deploy;
+        try {
+            deploy = await handleProjectDeploy(this.state.targetProjectAccountId, this.state.projectConfig.name, this.state.projectData.latestBuild.buildId, true, force);
+        }
+        catch (error) {
+            this.logger.deployError(error);
+            return {
+                success: false,
+            };
+        }
+        const success = deploy?.status === PROJECT_DEPLOY_STATES.SUCCESS;
+        if (success) {
+            await this.updateProjectData();
+            this.logger.deploySuccess();
+            await this.updateProjectNodesAfterDeploy();
+            this.state.clearUploadWarnings();
+        }
+        else {
+            this.logger.deployError();
+        }
+        return {
+            success,
+            deployId: deploy?.deployId,
+        };
     }
     addStateListener(key, listener) {
         this.state.addListener(key, listener);
     }
+    sendDevServerMessage(message) {
+        this.state.devServerMessage = message;
+    }
+    removeStateListener(key, listener) {
+        this.state.removeListener(key, listener);
+    }
 }
-exports.default = LocalDevProcess;
+export default LocalDevProcess;

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

@@ -1,37 +1,59 @@
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
+import { IntermediateRepresentationNodeLocalDev, HSProfileVariables } from '@hubspot/project-parsing-lib/src/lib/types.js';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
-import { ProjectConfig } from '../../../types/Projects';
-import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+import { Project } from '@hubspot/local-dev-lib/types/Project';
+import { ProjectConfig } from '../../../types/Projects.js';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev.js';
 declare class LocalDevState {
     private _targetProjectAccountId;
     private _targetTestingAccountId;
+    private _profile?;
     private _projectConfig;
     private _projectDir;
-    private _projectId;
+    private _projectData;
     private _debug;
-    private _deployedBuild?;
-    private _isGithubLinked;
     private _projectNodes;
+    private _projectProfileData;
+    private _projectNodesAtLastDeploy;
     private _env;
     private _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
+    private _appData;
+    private _devServerMessage;
+    private _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
+    get profile(): string | undefined;
     get projectConfig(): ProjectConfig;
     get projectDir(): string;
-    get projectId(): number;
     get debug(): boolean;
-    get deployedBuild(): Build | undefined;
-    get isGithubLinked(): boolean;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
     set projectNodes(nodes: {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     });
+    get projectProfileData(): HSProfileVariables;
+    set projectProfileData(profileData: HSProfileVariables);
+    get projectNodesAtLastDeploy(): {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    };
+    set projectNodesAtLastDeploy(nodes: {
+        [key: string]: IntermediateRepresentationNodeLocalDev;
+    });
+    get projectData(): Project;
+    get projectId(): number;
+    set projectData(projectData: Project);
     get env(): Environment;
+    get appData(): Record<string, AppLocalDevData>;
+    getAppDataByUid(uid: string): AppLocalDevData | undefined;
+    setAppDataForUid(uid: string, appData: AppLocalDevData): void;
+    get devServerMessage(): string;
+    set devServerMessage(message: LocalDevServerMessage);
+    get uploadWarnings(): Set<string>;
+    addUploadWarning(warning: string): void;
+    clearUploadWarnings(): void;
     addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    removeListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -1,28 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+import { LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../../constants.js';
 class LocalDevState {
     _targetProjectAccountId;
     _targetTestingAccountId;
+    _profile;
     _projectConfig;
     _projectDir;
-    _projectId;
+    _projectData;
     _debug;
-    _deployedBuild;
-    _isGithubLinked;
     _projectNodes;
+    _projectProfileData;
+    _projectNodesAtLastDeploy;
     _env;
     _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+    _appData;
+    _devServerMessage;
+    _uploadWarnings;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectData, debug, initialProjectNodes, initialProjectProfileData, profile, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
+        this._profile = profile;
         this._projectConfig = projectConfig;
         this._projectDir = projectDir;
-        this._projectId = projectId;
+        this._projectData = projectData;
         this._debug = debug || false;
-        this._deployedBuild = deployedBuild;
-        this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
+        this._projectNodesAtLastDeploy = initialProjectNodes;
+        this._projectProfileData = initialProjectProfileData;
         this._env = env;
+        this._appData = {};
+        this._devServerMessage = LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
+        this._uploadWarnings = new Set();
         this._listeners = {};
     }
     runListeners(key) {
@@ -36,43 +43,88 @@ class LocalDevState {
     get targetTestingAccountId() {
         return this._targetTestingAccountId;
     }
+    get profile() {
+        return this._profile;
+    }
     get projectConfig() {
-        return {
-            ...this._projectConfig,
-        };
+        return structuredClone(this._projectConfig);
     }
     get projectDir() {
         return this._projectDir;
     }
-    get projectId() {
-        return this._projectId;
-    }
     get debug() {
         return this._debug;
     }
-    get deployedBuild() {
-        return (this._deployedBuild && {
-            ...this._deployedBuild,
-        });
-    }
-    get isGithubLinked() {
-        return this._isGithubLinked;
-    }
     get projectNodes() {
-        return { ...this._projectNodes };
+        return structuredClone(this._projectNodes);
     }
     set projectNodes(nodes) {
         this._projectNodes = nodes;
         this.runListeners('projectNodes');
     }
+    get projectProfileData() {
+        return structuredClone(this._projectProfileData);
+    }
+    set projectProfileData(profileData) {
+        this._projectProfileData = profileData;
+    }
+    get projectNodesAtLastDeploy() {
+        return structuredClone(this._projectNodesAtLastDeploy);
+    }
+    set projectNodesAtLastDeploy(nodes) {
+        this._projectNodesAtLastDeploy = nodes;
+    }
+    get projectData() {
+        return structuredClone(this._projectData);
+    }
+    get projectId() {
+        return this.projectData.id;
+    }
+    set projectData(projectData) {
+        this._projectData = projectData;
+    }
     get env() {
         return this._env;
     }
+    get appData() {
+        return structuredClone(this._appData);
+    }
+    getAppDataByUid(uid) {
+        return { ...this._appData[uid] };
+    }
+    setAppDataForUid(uid, appData) {
+        this._appData[uid] = appData;
+        this.runListeners('appData');
+    }
+    get devServerMessage() {
+        return this._devServerMessage;
+    }
+    set devServerMessage(message) {
+        this._devServerMessage = message;
+        this.runListeners('devServerMessage');
+    }
+    get uploadWarnings() {
+        return this._uploadWarnings;
+    }
+    addUploadWarning(warning) {
+        this.uploadWarnings.add(warning);
+        this.runListeners('uploadWarnings');
+    }
+    clearUploadWarnings() {
+        this.uploadWarnings.clear();
+        this.runListeners('uploadWarnings');
+    }
     addListener(key, listener) {
         if (!this._listeners[key]) {
             this._listeners[key] = [];
         }
         this._listeners[key].push(listener);
+        listener(this[key]);
+    }
+    removeListener(key, listener) {
+        if (this._listeners[key]) {
+            this._listeners[key].splice(this._listeners[key].indexOf(listener), 1);
+        }
     }
 }
-exports.default = LocalDevState;
+export default LocalDevState;

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

@@ -1,4 +1,4 @@
-import LocalDevProcess from './LocalDevProcess';
+import LocalDevProcess from './LocalDevProcess.js';
 declare class LocalDevWatcher {
     private localDevProcess;
     private watcher;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -1,11 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = __importDefault(require("path"));
-const chokidar_1 = __importDefault(require("chokidar"));
-const constants_1 = require("../../constants");
+import path from 'path';
+import chokidar from 'chokidar';
+import { PROJECT_CONFIG_FILE } from '../../constants.js';
 const WATCH_EVENTS = {
     add: 'add',
     change: 'change',
@@ -19,22 +14,19 @@ class LocalDevWatcher {
         this.localDevProcess = localDevProcess;
         this.watcher = null;
     }
-    async handleWatchEvent(filePath, event, configPaths) {
-        await this.localDevProcess.updateProjectNodes();
+    handleWatchEvent(filePath, event, configPaths) {
         if (configPaths.includes(filePath)) {
-            this.localDevProcess.logger.uploadWarning();
-        }
-        else {
-            this.localDevProcess.handleFileChange(filePath, event);
+            return this.localDevProcess.handleConfigFileChange();
         }
+        return this.localDevProcess.handleFileChange(filePath, event);
     }
     start() {
-        this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {
+        this.watcher = chokidar.watch(this.localDevProcess.projectDir, {
             ignoreInitial: true,
             ignored: ['**/dist'],
         });
         const configPaths = Object.values(this.localDevProcess.projectNodes).map(component => component.localDev.componentConfigPath);
-        const projectConfigPath = path_1.default.join(this.localDevProcess.projectDir, constants_1.PROJECT_CONFIG_FILE);
+        const projectConfigPath = path.join(this.localDevProcess.projectDir, PROJECT_CONFIG_FILE);
         configPaths.push(projectConfigPath);
         this.watcher.on('add', filePath => {
             this.handleWatchEvent(filePath, WATCH_EVENTS.add, configPaths);
@@ -53,4 +45,4 @@ class LocalDevWatcher {
         await this.watcher?.close();
     }
 }
-exports.default = LocalDevWatcher;
+export default LocalDevWatcher;

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

@@ -1,15 +1,20 @@
-import LocalDevProcess from './LocalDevProcess';
+import LocalDevProcess from './LocalDevProcess.js';
 declare class LocalDevWebsocketServer {
     private server?;
-    private _websocket?;
     private debug?;
     private localDevProcess;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
-    private websocket;
     private log;
     private logError;
     private sendMessage;
+    private handleUpload;
+    private handleDeploy;
     private setupMessageHandlers;
+    private sendCliMetadata;
+    private sendProjectData;
+    private setupProjectNodesListener;
+    private setupAppDataListener;
+    private setupUploadWarningsListener;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;