@hubspot/cli 7.7.0-experimental.3 → 7.7.2-experimental.0

package/lib/projects/create/v3.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.PROJECT_WITH_APP = exports.EMPTY_PROJECT = void 0;
+exports.createV3App = createV3App;
+exports.calculateComponentTemplateChoices = calculateComponentTemplateChoices;
+exports.v3ComponentFlow = v3ComponentFlow;
+exports.generateComponentPaths = generateComponentPaths;
+const constants_1 = require("../../constants");
+const en_1 = require("../../../lang/en");
+const promptUtils_1 = require("../../prompts/promptUtils");
+const chalk_1 = __importDefault(require("chalk"));
+const buildAndDeploy_1 = require("../buildAndDeploy");
+const path_1 = __importDefault(require("path"));
+const legacy_1 = require("./legacy");
+const errorHandlers_1 = require("../../errorHandlers");
+const exitCodes_1 = require("../../enums/exitCodes");
+const inquirer = require('inquirer');
+exports.EMPTY_PROJECT = 'empty';
+exports.PROJECT_WITH_APP = 'app';
+async function createV3App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === constants_1.marketplaceDistribution &&
+        providedAuth !== constants_1.oAuth) {
+        throw new Error(en_1.lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: en_1.lib.projects.create.prompt.marketPlaceDistribution,
+                    value: constants_1.marketplaceDistribution,
+                },
+                {
+                    name: en_1.lib.projects.create.prompt.privateDistribution,
+                    value: constants_1.privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === constants_1.marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = constants_1.oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: en_1.lib.projects.create.prompt.staticAuth, value: constants_1.staticAuth },
+                        { name: en_1.lib.projects.create.prompt.oauth, value: constants_1.oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution,
+        authType,
+    };
+}
+function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    components.forEach(template => {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const { count, maxCount } = projectMetadata.components[template.type];
+            if (count >= maxCount) {
+                disabledReasons.push(en_1.commands.project.add.error.maxExceeded(maxCount));
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType)) {
+            disabledReasons.push(en_1.commands.project.add.error.authTypeNotAllowed(authType));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution)) {
+            disabledReasons.push(en_1.commands.project.add.error.distributionNotAllowed(distribution));
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `[${chalk_1.default.yellow('DISABLED')}] ${template.label}`,
+                value: template,
+                disabled: disabledReasons.join(' '),
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: template.label,
+                value: template,
+            });
+        }
+    });
+    return disabledComponents.length
+        ? [...enabledComponents, new inquirer.Separator(), ...disabledComponents]
+        : [...enabledComponents];
+}
+async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    try {
+        repoConfig = await (0, legacy_1.getConfigForPlatformVersion)(platformVersion);
+    }
+    catch (error) {
+        (0, errorHandlers_1.logError)(error);
+        return process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+    }
+    const projectContentsChoice = projectBase ||
+        (await (0, promptUtils_1.listPrompt)(en_1.commands.project.create.prompts.parentComponents, {
+            choices: [
+                {
+                    name: en_1.commands.project.create.prompts.emptyProject,
+                    value: exports.EMPTY_PROJECT,
+                },
+                { name: en_1.commands.project.create.prompts.app, value: exports.PROJECT_WITH_APP },
+            ],
+        }));
+    if (projectContentsChoice === exports.PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!(0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+        return [];
+    }
+    const components = createProjectPromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path_1.default.join(platformVersion, componentTemplate.path);
+    }) || [];
+    if (projectContents && projectContents !== exports.EMPTY_PROJECT) {
+        const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
+            return (possibleParent.type === projectContents &&
+                possibleParent.authType === authType &&
+                possibleParent.distribution === distribution);
+        });
+        if (parentComponent) {
+            components.push(path_1.default.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path_1.default.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

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

@@ -1,4 +1,3 @@
-import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
 import { AppIRNode } from '../../../types/ProjectComponents';
 import LocalDevState from './LocalDevState';
 import LocalDevLogger from './LocalDevLogger';
@@ -10,14 +9,16 @@ declare class AppDevModeInterface {
     localDevState: LocalDevState;
     localDevLogger: LocalDevLogger;
     _appNode?: AppIRNode | null;
-    appData?: PublicApp;
     marketplaceAppInstalls?: number;
     constructor(options: AppDevModeInterfaceConstructorOptions);
     private get appNode();
+    private get appData();
+    private set appData(value);
     private getAppInstallUrl;
     private fetchAppData;
     private checkMarketplaceAppInstalls;
     private checkTestAccountAppInstallation;
+    private setUpLocalDevServerMessageListeners;
     setup(args: any): Promise<void>;
     start(): Promise<void>;
     fileChange(filePath: string, event: string): Promise<void>;

package/lib/projects/localDev/AppDevModeInterface.js

@@ -18,7 +18,6 @@ class AppDevModeInterface {
     localDevState;
     localDevLogger;
     _appNode;
-    appData;
     marketplaceAppInstalls;
     constructor(options) {
         this.localDevState = options.localDevState;
@@ -48,6 +47,18 @@ class AppDevModeInterface {
         }
         return this._appNode;
     }
+    get appData() {
+        if (!this.appNode) {
+            return undefined;
+        }
+        return this.localDevState.getAppDataByUid(this.appNode.uid);
+    }
+    set appData(appData) {
+        if (!this.appNode) {
+            return;
+        }
+        this.localDevState.setAppDataForUid(this.appNode.uid, appData);
+    }
     async getAppInstallUrl() {
         if (this.appNode?.config.auth.type === constants_1.APP_AUTH_TYPES.OAUTH) {
             return (0, urls_1.getOauthAppInstallUrl)({
@@ -77,7 +88,12 @@ class AppDevModeInterface {
             return;
         }
         const { data: { uniquePortalInstallCount }, } = await (0, appsDev_1.fetchPublicAppProductionInstallCounts)(appData.id, this.localDevState.targetProjectAccountId);
-        this.appData = appData;
+        this.appData = {
+            id: appData.id,
+            clientId: appData.clientId,
+            name: appData.name,
+            installationState: constants_1.APP_INSTALLATION_STATES.NOT_INSTALLED,
+        };
         this.marketplaceAppInstalls = uniquePortalInstallCount;
     }
     async checkMarketplaceAppInstalls() {
@@ -98,19 +114,32 @@ class AppDevModeInterface {
         if (!this.appNode || !this.appData) {
             return;
         }
-        // If the app is static auth, always prompt the user to install the app.
-        // We are currently going this because we have no method to determine if the static auth app
-        // is already installed in the portal
-        if (this.appNode.config.auth.type === constants_1.APP_AUTH_TYPES.STATIC) {
-            return (0, installAppPrompt_1.installAppPrompt)(await this.getAppInstallUrl(), false);
-        }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await (0, localDevAuth_1.fetchAppInstallationData)(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
         const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
+        if (isInstalledWithScopeGroups) {
+            this.appData = {
+                ...this.appData,
+                installationState: constants_1.APP_INSTALLATION_STATES.INSTALLED,
+            };
+        }
+        else if (isReinstall) {
+            this.appData = {
+                ...this.appData,
+                installationState: constants_1.APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
+            };
+        }
         if (!isInstalledWithScopeGroups) {
             const installUrl = await this.getAppInstallUrl();
             await (0, installAppPrompt_1.installAppPrompt)(installUrl, isReinstall);
         }
     }
+    setUpLocalDevServerMessageListeners() {
+        this.localDevState.addListener('devServerMessage', message => {
+            if (message === constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
+                this.checkTestAccountAppInstallation();
+            }
+        });
+    }
     // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
     // In the future, update UIE Dev Server to use LocalDevState
     async setup(args) {
@@ -127,6 +156,7 @@ class AppDevModeInterface {
         catch (e) {
             (0, index_1.logError)(e);
         }
+        this.setUpLocalDevServerMessageListeners();
         return ui_extensions_dev_server_1.DevModeUnifiedInterface.setup(args);
     }
     async start() {

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

@@ -1,27 +1,34 @@
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
 import LocalDevState from './LocalDevState';
 import LocalDevLogger from './LocalDevLogger';
-import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, LocalDevServerMessage } from '../../../types/LocalDev';
 declare class LocalDevProcess {
     private state;
     private _logger;
     private devServerManager;
     constructor(options: LocalDevStateConstructorOptions);
     get projectDir(): string;
+    get projectId(): number;
+    get projectName(): string;
+    get targetProjectAccountId(): number;
+    get targetTestingAccountId(): number;
     get projectNodes(): {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     };
     get logger(): LocalDevLogger;
+    get configFilesUpdatedSinceLastUpload(): Set<string>;
     private setupDevServers;
     private startDevServers;
     private cleanupDevServers;
     private compareLocalProjectToDeployed;
     private projectConfigValidForUpload;
-    handleFileChange(filePath: string, event: string): void;
+    private updateProjectNodes;
+    handleFileChange(filePath: string, event: string): Promise<void>;
+    handleConfigFileChange(filePath: string, event: string): Promise<void>;
     start(): Promise<void>;
     stop(showProgress?: boolean): Promise<void>;
-    updateProjectNodes(): Promise<void>;
-    uploadProject(): Promise<void>;
-    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    uploadProject(): Promise<boolean>;
+    addStateListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
+    sendDevServerMessage(message: LocalDevServerMessage): void;
 }
 export default LocalDevProcess;

package/lib/projects/localDev/LocalDevProcess.js

@@ -28,12 +28,27 @@ class LocalDevProcess {
     get projectDir() {
         return this.state.projectDir;
     }
+    get projectId() {
+        return this.state.projectId;
+    }
+    get projectName() {
+        return this.state.projectName;
+    }
+    get targetProjectAccountId() {
+        return this.state.targetProjectAccountId;
+    }
+    get targetTestingAccountId() {
+        return this.state.targetTestingAccountId;
+    }
     get projectNodes() {
         return this.state.projectNodes;
     }
     get logger() {
         return this._logger;
     }
+    get configFilesUpdatedSinceLastUpload() {
+        return this.state.configFilesUpdatedSinceLastUpload;
+    }
     async setupDevServers() {
         try {
             await this.devServerManager.setup();
@@ -90,7 +105,19 @@ class LocalDevProcess {
         });
         return true;
     }
-    handleFileChange(filePath, event) {
+    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,
+        }, {
+            configFilesUpdatedSinceLastUpload: this.state.configFilesUpdatedSinceLastUpload,
+        });
+        this.state.projectNodes =
+            intermediateRepresentation.intermediateNodesIndexedByUid;
+    }
+    async handleFileChange(filePath, event) {
+        await this.updateProjectNodes();
         try {
             this.devServerManager.fileChange({ filePath, event });
         }
@@ -98,6 +125,13 @@ class LocalDevProcess {
             this.logger.fileChangeError(e);
         }
     }
+    async handleConfigFileChange(filePath, event) {
+        if (event === 'add' || event === 'change') {
+            this.state.addUpdatedConfigFileUpdatedSinceLastUpload(filePath);
+        }
+        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
@@ -132,21 +166,12 @@ class LocalDevProcess {
         }
         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;
-    }
     async uploadProject() {
         this.logger.uploadInitiated();
         const isUploadable = await this.projectConfigValidForUpload();
         if (!isUploadable) {
             this.logger.projectConfigMismatch();
-            return;
+            return false;
         }
         const { uploadError } = await (0, upload_1.handleProjectUpload)({
             accountId: this.state.targetProjectAccountId,
@@ -158,14 +183,19 @@ class LocalDevProcess {
         });
         if (uploadError) {
             this.logger.uploadError(uploadError);
+            return false;
         }
-        else {
-            this.logger.uploadSuccess();
-            this.logger.clearUploadWarnings();
-        }
+        this.state.resetConfigFilesUpdatedSinceLastUpload();
+        this.updateProjectNodes();
+        this.logger.uploadSuccess();
+        this.logger.clearUploadWarnings();
+        return true;
+    }
+    addStateListener(key, listener, callOnInit = false) {
+        this.state.addListener(key, listener, callOnInit);
     }
-    addStateListener(key, listener) {
-        this.state.addListener(key, listener);
+    sendDevServerMessage(message) {
+        this.state.devServerMessage = message;
     }
 }
 exports.default = LocalDevProcess;

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

@@ -2,26 +2,31 @@ import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { IntermediateRepresentationNodeLocalDev } from '@hubspot/project-parsing-lib/src/lib/types';
 import { Environment } from '@hubspot/local-dev-lib/types/Config';
 import { ProjectConfig } from '../../../types/Projects';
-import { LocalDevStateConstructorOptions, LocalDevStateListener } from '../../../types/LocalDev';
+import { LocalDevStateConstructorOptions, LocalDevStateListener, AppLocalDevData, LocalDevServerMessage } from '../../../types/LocalDev';
 declare class LocalDevState {
     private _targetProjectAccountId;
     private _targetTestingAccountId;
     private _projectConfig;
     private _projectDir;
     private _projectId;
+    private _projectName;
     private _debug;
     private _deployedBuild?;
     private _isGithubLinked;
     private _projectNodes;
     private _env;
     private _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
+    private _configFilesUpdatedSinceLastUpload;
+    private _appData;
+    private _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }: LocalDevStateConstructorOptions);
     private runListeners;
     get targetProjectAccountId(): number;
     get targetTestingAccountId(): number;
     get projectConfig(): ProjectConfig;
     get projectDir(): string;
     get projectId(): number;
+    get projectName(): string;
     get debug(): boolean;
     get deployedBuild(): Build | undefined;
     get isGithubLinked(): boolean;
@@ -32,6 +37,14 @@ declare class LocalDevState {
         [key: string]: IntermediateRepresentationNodeLocalDev;
     });
     get env(): Environment;
-    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>): void;
+    get configFilesUpdatedSinceLastUpload(): Set<string>;
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath: string): void;
+    resetConfigFilesUpdatedSinceLastUpload(): void;
+    get appData(): Record<string, AppLocalDevData>;
+    getAppDataByUid(uid: string): AppLocalDevData | undefined;
+    setAppDataForUid(uid: string, appData: AppLocalDevData): void;
+    get devServerMessage(): string;
+    set devServerMessage(message: LocalDevServerMessage);
+    addListener<K extends keyof LocalDevState>(key: K, listener: LocalDevStateListener<K>, callOnInit?: boolean): void;
 }
 export default LocalDevState;

package/lib/projects/localDev/LocalDevState.js

@@ -1,28 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const constants_1 = require("../../constants");
 class LocalDevState {
     _targetProjectAccountId;
     _targetTestingAccountId;
     _projectConfig;
     _projectDir;
     _projectId;
+    _projectName;
     _debug;
     _deployedBuild;
     _isGithubLinked;
     _projectNodes;
     _env;
     _listeners;
-    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
+    _configFilesUpdatedSinceLastUpload;
+    _appData;
+    _devServerMessage;
+    constructor({ targetProjectAccountId, targetTestingAccountId, projectConfig, projectDir, projectId, projectName, debug, deployedBuild, isGithubLinked, initialProjectNodes, env, }) {
         this._targetProjectAccountId = targetProjectAccountId;
         this._targetTestingAccountId = targetTestingAccountId;
         this._projectConfig = projectConfig;
         this._projectDir = projectDir;
         this._projectId = projectId;
+        this._projectName = projectName;
         this._debug = debug || false;
         this._deployedBuild = deployedBuild;
         this._isGithubLinked = isGithubLinked;
         this._projectNodes = initialProjectNodes;
         this._env = env;
+        this._configFilesUpdatedSinceLastUpload = new Set();
+        this._appData = {};
+        this._devServerMessage = constants_1.LOCAL_DEV_SERVER_MESSAGE_TYPES.INITIAL;
         this._listeners = {};
     }
     runListeners(key) {
@@ -47,6 +56,9 @@ class LocalDevState {
     get projectId() {
         return this._projectId;
     }
+    get projectName() {
+        return this._projectName;
+    }
     get debug() {
         return this._debug;
     }
@@ -68,11 +80,40 @@ class LocalDevState {
     get env() {
         return this._env;
     }
-    addListener(key, listener) {
+    get configFilesUpdatedSinceLastUpload() {
+        return this._configFilesUpdatedSinceLastUpload;
+    }
+    addUpdatedConfigFileUpdatedSinceLastUpload(filePath) {
+        this._configFilesUpdatedSinceLastUpload.add(filePath);
+    }
+    resetConfigFilesUpdatedSinceLastUpload() {
+        this._configFilesUpdatedSinceLastUpload.clear();
+    }
+    get appData() {
+        return { ...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');
+    }
+    addListener(key, listener, callOnInit = false) {
         if (!this._listeners[key]) {
             this._listeners[key] = [];
         }
         this._listeners[key].push(listener);
+        if (callOnInit) {
+            listener(this[key]);
+        }
     }
 }
 exports.default = LocalDevState;

package/lib/projects/localDev/LocalDevWatcher.js

@@ -19,14 +19,11 @@ 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(filePath, event);
         }
+        return this.localDevProcess.handleFileChange(filePath, event);
     }
     start() {
         this.watcher = chokidar_1.default.watch(this.localDevProcess.projectDir, {

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

@@ -4,12 +4,15 @@ declare class LocalDevWebsocketServer {
     private _websocket?;
     private debug?;
     private localDevProcess;
+    private ALLOWED_ORIGINS;
     constructor(localDevProcess: LocalDevProcess, debug?: boolean);
     private websocket;
     private log;
     private logError;
     private sendMessage;
+    private handleUpload;
     private setupMessageHandlers;
+    private sendProjectData;
     private setupStateListeners;
     start(): Promise<void>;
     shutdown(): void;