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

package/lib/projects/localDev/LocalDevProcess.js

@@ -0,0 +1,277 @@
+import path from 'path';
+import open from 'open';
+import { translateForLocalDev, } from '@hubspot/project-parsing-lib/translate';
+import { hasLocalStateFlag, isConfigFlagEnabled, } from '@hubspot/local-dev-lib/config';
+import { CONFIG_FLAGS } from '@hubspot/local-dev-lib/constants/config';
+import { fetchProject } from '@hubspot/local-dev-lib/api/projects';
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+import DevServerManager from './DevServerManager.js';
+import DevSessionManager from './DevSessionManager.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 { lib } from '../../../lang/en.js';
+import { debugError } from '../../errorHandlers/index.js';
+class LocalDevProcess {
+    state;
+    _logger;
+    devServerManager;
+    devSessionManager;
+    constructor(options) {
+        this.state = new LocalDevState(options);
+        this._logger = new LocalDevLogger(this.state);
+        this.devServerManager = new DevServerManager({
+            localDevState: this.state,
+            logger: this._logger,
+        });
+        this.devSessionManager = new DevSessionManager({
+            targetTestingAccountId: this.state.targetTestingAccountId,
+            localDevLogger: this._logger,
+        });
+    }
+    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;
+    }
+    get logger() {
+        return this._logger;
+    }
+    async setupDevServers() {
+        try {
+            await this.devServerManager.setup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerSetupError(e);
+            return false;
+        }
+    }
+    async startDevServers() {
+        try {
+            await this.devServerManager.start();
+        }
+        catch (e) {
+            this.logger.devServerStartError(e);
+            process.exit(EXIT_CODES.ERROR);
+        }
+    }
+    async cleanupDevServers() {
+        try {
+            await this.devServerManager.cleanup();
+            return true;
+        }
+        catch (e) {
+            this.logger.devServerCleanupError(e);
+            return false;
+        }
+    }
+    async projectConfigValidForUpload() {
+        const { projectConfig } = await getProjectConfig();
+        if (!projectConfig) {
+            return false;
+        }
+        Object.keys(projectConfig).forEach(key => {
+            const field = key;
+            if (projectConfig[field] !== this.state.projectConfig[field]) {
+                return false;
+            }
+        });
+        return true;
+    }
+    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 });
+        }
+        catch (e) {
+            this.logger.fileChangeError(e);
+        }
+    }
+    async handleConfigFileChange() {
+        await this.updateProjectNodes();
+        this.logger.uploadWarning();
+    }
+    async start() {
+        this.logger.resetSpinnies();
+        const setupSucceeded = await this.setupDevServers();
+        if (!setupSucceeded) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        this.logger.startupMessage();
+        if (isConfigFlagEnabled(CONFIG_FLAGS.AUTO_OPEN_BROWSER, true)) {
+            this.openLocalDevUi();
+        }
+        await this.startDevServers();
+        const devSessionRegistered = await this.devSessionManager.registerSession();
+        if (!devSessionRegistered) {
+            process.exit(EXIT_CODES.ERROR);
+        }
+        this.state.devServersStarted = true;
+        this.logger.monitorConsoleOutput();
+    }
+    async stop(showProgress = true) {
+        if (showProgress) {
+            this.logger.cleanupStart();
+        }
+        const cleanupServersSucceeded = await this.cleanupDevServers();
+        const cleanupSessionSucceeded = await this.devSessionManager.deleteDevSession();
+        if (!cleanupServersSucceeded || !cleanupSessionSucceeded) {
+            if (showProgress) {
+                this.logger.cleanupError();
+            }
+            process.exit(EXIT_CODES.ERROR);
+        }
+        if (showProgress) {
+            this.logger.cleanupSuccess();
+        }
+        process.exit(EXIT_CODES.SUCCESS);
+    }
+    async uploadProject() {
+        this.logger.uploadInitiated();
+        const isUploadable = await this.projectConfigValidForUpload();
+        if (!isUploadable) {
+            this.logger.projectConfigMismatch();
+            return {
+                uploadSuccess: false,
+                buildSuccess: false,
+                deploySuccess: false,
+            };
+        }
+        const { uploadError, result } = await handleProjectUpload({
+            accountId: this.state.targetProjectAccountId,
+            projectConfig: this.state.projectConfig,
+            projectDir: this.state.projectDir,
+            callbackFunc: pollProjectBuildAndDeploy,
+            sendIR: 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();
+        }
+        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);
+    }
+}
+export default LocalDevProcess;

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

@@ -0,0 +1,63 @@
+import type { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/translate';
+import type { HSProfileVariables } from '@hubspot/project-parsing-lib/profiles';
+import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
+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 _projectData;
+    private _debug;
+    private _projectNodes;
+    private _projectProfileData;
+    private _projectNodesAtLastDeploy;
+    private _env;
+    private _listeners;
+    private _appData;
+    private _devServerMessage;
+    private _uploadWarnings;
+    private _devServersStarted;
+    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 debug(): 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>;
+    get devServersStarted(): boolean;
+    set devServersStarted(started: boolean);
+    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

@@ -0,0 +1,139 @@
+import { LOCAL_DEV_SERVER_MESSAGE_TYPES } from '../../constants.js';
+class LocalDevState {
+    _targetProjectAccountId;
+    _targetTestingAccountId;
+    _profile;
+    _projectConfig;
+    _projectDir;
+    _projectData;
+    _debug;
+    _projectNodes;
+    _projectProfileData;
+    _projectNodesAtLastDeploy;
+    _env;
+    _listeners;
+    _appData;
+    _devServerMessage;
+    _uploadWarnings;
+    _devServersStarted;
+    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._projectData = projectData;
+        this._debug = debug || false;
+        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._devServersStarted = false;
+        this._listeners = {};
+    }
+    runListeners(key) {
+        if (this._listeners[key] && this._listeners[key].length) {
+            this._listeners[key].forEach(listener => listener(this[key]));
+        }
+    }
+    get targetProjectAccountId() {
+        return this._targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this._targetTestingAccountId;
+    }
+    get profile() {
+        return this._profile;
+    }
+    get projectConfig() {
+        return structuredClone(this._projectConfig);
+    }
+    get projectDir() {
+        return this._projectDir;
+    }
+    get debug() {
+        return this._debug;
+    }
+    get 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;
+    }
+    get devServersStarted() {
+        return this._devServersStarted;
+    }
+    set devServersStarted(started) {
+        this._devServersStarted = started;
+        this.runListeners('devServersStarted');
+    }
+    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);
+        }
+    }
+}
+export default LocalDevState;

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

@@ -0,0 +1,10 @@
+import LocalDevProcess from './LocalDevProcess.js';
+declare class LocalDevWatcher {
+    private localDevProcess;
+    private watcher;
+    constructor(localDevProcess: LocalDevProcess);
+    private handleWatchEvent;
+    start(): void;
+    stop(): Promise<void>;
+}
+export default LocalDevWatcher;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -0,0 +1,48 @@
+import path from 'path';
+import chokidar from 'chokidar';
+import { PROJECT_CONFIG_FILE } from '../../constants.js';
+const WATCH_EVENTS = {
+    add: 'add',
+    change: 'change',
+    unlink: 'unlink',
+    unlinkDir: 'unlinkDir',
+};
+class LocalDevWatcher {
+    localDevProcess;
+    watcher;
+    constructor(localDevProcess) {
+        this.localDevProcess = localDevProcess;
+        this.watcher = null;
+    }
+    handleWatchEvent(filePath, event, configPaths) {
+        if (configPaths.includes(filePath)) {
+            return this.localDevProcess.handleConfigFileChange();
+        }
+        return this.localDevProcess.handleFileChange(filePath, event);
+    }
+    start() {
+        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.join(this.localDevProcess.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 stop() {
+        await this.watcher?.close();
+    }
+}
+export default LocalDevWatcher;

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

@@ -0,0 +1,21 @@
+import LocalDevProcess from './LocalDevProcess.js';
+declare class LocalDevWebsocketServer {
+    private cliWebSocketServer;
+    private localDevProcess;
+    constructor(localDevProcess: LocalDevProcess, debug?: boolean);
+    private handleUpload;
+    private handleDeploy;
+    private handleAppInstallSuccess;
+    private handleAppInstallFailure;
+    private handleAppInstallInitiated;
+    private handleMessage;
+    private sendProjectData;
+    private setupProjectNodesListener;
+    private setupAppDataListener;
+    private setupUploadWarningsListener;
+    private setupDevServersStartedListener;
+    private setupStateListeners;
+    start(): Promise<void>;
+    shutdown(): void;
+}
+export default LocalDevWebsocketServer;