@hubspot/cli 7.8.12-experimental.0 → 7.9.0-beta.0

package/lib/projects/localDev/AppDevModeInterface.js

@@ -1,27 +1,24 @@
 import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchPublicAppsForPortal, fetchPublicAppProductionInstallCounts,
-// installStaticAuthAppOnTestAccount,
- } from '@hubspot/local-dev-lib/api/appsDev';
-import { DevModeUnifiedInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
-import { requestPorts } from '@hubspot/local-dev-lib/portManager';
+import { fetchAppMetadataByUid, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
+import { getAccountConfig } from '@hubspot/local-dev-lib/config';
 import { APP_AUTH_TYPES, APP_DISTRIBUTION_TYPES, APP_INSTALLATION_STATES, LOCAL_DEV_SERVER_MESSAGE_TYPES, } from '../../constants.js';
 import { EXIT_CODES } from '../../enums/exitCodes.js';
 import { isAppIRNode } from '../../projects/structure.js';
 import { uiLine } from '../../ui/index.js';
 import { logError } from '../../errorHandlers/index.js';
-import { 
-// installAppAutoPrompt,
-installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
+import { installAppAutoPrompt, installAppBrowserPrompt, } from '../../prompts/installAppPrompt.js';
 import { confirmPrompt } from '../../prompts/promptUtils.js';
 import { lib } from '../../../lang/en.js';
 import { uiLogger } from '../../ui/logger.js';
 import { getOauthAppInstallUrl, getStaticAuthAppInstallUrl, } from '../../app/urls.js';
+import { isDeveloperTestAccount, isSandbox } from '../../accountTypes.js';
 import SpinniesManager from '../../ui/SpinniesManager.js';
 class AppDevModeInterface {
     localDevState;
     localDevLogger;
     _appNode;
     marketplaceAppInstalls;
+    appInstallResolve;
     constructor(options) {
         this.localDevState = options.localDevState;
         this.localDevLogger = options.localDevLogger;
@@ -43,10 +40,18 @@ class AppDevModeInterface {
         return this._appNode;
     }
     get appData() {
+        // These checks are primarily for type safety
+        // App data will never be accessed before being set
         if (!this.appNode) {
-            return undefined;
+            uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
+            process.exit(EXIT_CODES.ERROR);
+        }
+        const data = this.localDevState.getAppDataByUid(this.appNode.uid);
+        if (!data) {
+            uiLogger.log(lib.AppDevModeInterface.appDataNotFound);
+            process.exit(EXIT_CODES.ERROR);
         }
-        return this.localDevState.getAppDataByUid(this.appNode.uid);
+        return data;
     }
     set appData(appData) {
         if (!this.appNode) {
@@ -54,56 +59,47 @@ class AppDevModeInterface {
         }
         this.localDevState.setAppDataForUid(this.appNode.uid, appData);
     }
-    // @TODO: Restore test account auto install functionality
-    // private isAutomaticallyInstallable(): boolean {
-    //   const targetTestingAccount = getAccountConfig(
-    //     this.localDevState.targetTestingAccountId
-    //   );
-    //   if (!targetTestingAccount) {
-    //     return false;
-    //   }
-    //   const isTestAccount =
-    //     isDeveloperTestAccount(targetTestingAccount) ||
-    //     isSandbox(targetTestingAccount);
-    //   const hasCorrectParent =
-    //     targetTestingAccount.parentAccountId ===
-    //     this.localDevState.targetProjectAccountId;
-    //   return (
-    //     isTestAccount &&
-    //     hasCorrectParent &&
-    //     this.appNode?.config.auth.type === APP_AUTH_TYPES.STATIC
-    //   );
-    // }
+    isStaticAuthApp() {
+        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.STATIC);
+    }
+    isOAuthApp() {
+        return (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH);
+    }
+    isAutomaticallyInstallable() {
+        const targetTestingAccount = getAccountConfig(this.localDevState.targetTestingAccountId);
+        if (!targetTestingAccount) {
+            return false;
+        }
+        const isTestAccount = isDeveloperTestAccount(targetTestingAccount) ||
+            isSandbox(targetTestingAccount);
+        const hasCorrectParent = targetTestingAccount.parentAccountId ===
+            this.localDevState.targetProjectAccountId;
+        return isTestAccount && hasCorrectParent && this.isStaticAuthApp();
+    }
     async getAppInstallUrl() {
-        if (this.appNode?.config.auth.type.toLowerCase() === APP_AUTH_TYPES.OAUTH) {
+        if (this.appNode && this.isOAuthApp()) {
             return getOauthAppInstallUrl({
                 targetAccountId: this.localDevState.targetTestingAccountId,
                 env: this.localDevState.env,
-                clientId: this.appData.clientId, // This is only called after checking that appData exists
+                clientId: this.appData.clientId,
                 scopes: this.appNode.config.auth.requiredScopes,
                 redirectUrls: this.appNode.config.auth.redirectUrls,
             });
         }
-        const { data: { results }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
-        const app = results.find(app => app.sourceId === this.appNode?.uid);
-        if (!app) {
-            uiLogger.error(lib.LocalDevManager.appNotFound(this.localDevState.targetProjectAccountId, this.appNode?.uid));
-            process.exit(EXIT_CODES.ERROR);
-        }
         return getStaticAuthAppInstallUrl({
             targetAccountId: this.localDevState.targetTestingAccountId,
             env: this.localDevState.env,
-            appId: app.id,
+            appId: this.appData.id,
         });
     }
     async fetchAppData() {
         SpinniesManager.add('fetchAppData', {
             text: lib.AppDevModeInterface.fetchAppData.checking(this.appNode?.config.name || ''),
         });
-        let portalApps = [];
+        let appData;
         try {
-            const { data: { results }, } = await fetchPublicAppsForPortal(this.localDevState.targetProjectAccountId);
-            portalApps = results;
+            const { data } = await fetchAppMetadataByUid(this.appNode.uid, this.localDevState.targetProjectAccountId);
+            appData = data;
         }
         catch (e) {
             SpinniesManager.fail('fetchAppData', {
@@ -112,7 +108,6 @@ class AppDevModeInterface {
             logError(e);
             process.exit(EXIT_CODES.ERROR);
         }
-        const appData = portalApps.find(({ sourceId }) => sourceId === this.appNode?.uid);
         if (!appData) {
             return;
         }
@@ -121,13 +116,13 @@ class AppDevModeInterface {
             id: appData.id,
             clientId: appData.clientId,
             name: appData.name,
-            installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
+            installationState: APP_INSTALLATION_STATES.UNKNOWN,
             scopeGroupIds: appData.scopeGroupIds,
         };
         this.marketplaceAppInstalls = uniquePortalInstallCount;
     }
     async checkMarketplaceAppInstalls() {
-        if (!this.appData || !this.marketplaceAppInstalls) {
+        if (!this.marketplaceAppInstalls) {
             return;
         }
         SpinniesManager.fail('fetchAppData', {
@@ -143,50 +138,58 @@ class AppDevModeInterface {
         }
         this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
     }
-    // @TODO: Restore test account auto install functionality
-    // private async autoInstallStaticAuthApp(): Promise<void> {
-    //   const shouldInstall = await installAppAutoPrompt();
-    //   if (!shouldInstall) {
-    //     uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
-    //     process.exit(EXIT_CODES.SUCCESS);
-    //   }
-    //   await installStaticAuthAppOnTestAccount(
-    //     this.appData!.id,
-    //     this.localDevState.targetTestingAccountId,
-    //     this.appData!.scopeGroupIds
-    //   );
-    // }
+    async waitUntilAppIsInstalled(installUrl) {
+        uiLogger.log(lib.AppDevModeInterface.waitUntilAppIsInstalled.link(installUrl));
+        SpinniesManager.add('waitUntilAppIsInstalled', {
+            text: lib.AppDevModeInterface.waitUntilAppIsInstalled.waiting,
+        });
+        await new Promise(resolve => {
+            this.appInstallResolve = resolve;
+        });
+        SpinniesManager.succeed('waitUntilAppIsInstalled', {
+            text: lib.AppDevModeInterface.waitUntilAppIsInstalled.success(this.appNode?.config.name || '', this.localDevState.targetTestingAccountId),
+        });
+    }
+    async autoInstallStaticAuthApp() {
+        const shouldInstall = await installAppAutoPrompt();
+        if (!shouldInstall) {
+            uiLogger.log(lib.AppDevModeInterface.autoInstallDeclined);
+            process.exit(EXIT_CODES.SUCCESS);
+        }
+        uiLogger.log('');
+        SpinniesManager.add('autoInstallStaticAuthApp', {
+            text: lib.AppDevModeInterface.autoInstallStaticAuthApp.installing(this.appData.name, this.localDevState.targetTestingAccountId),
+        });
+        try {
+            await installStaticAuthAppOnTestAccount(this.appData.id, this.localDevState.targetTestingAccountId, this.appData.scopeGroupIds);
+            SpinniesManager.succeed('autoInstallStaticAuthApp', {
+                text: lib.AppDevModeInterface.autoInstallStaticAuthApp.success(this.appData.name, this.localDevState.targetTestingAccountId),
+            });
+            return true;
+        }
+        catch (e) {
+            SpinniesManager.fail('autoInstallStaticAuthApp', {
+                text: lib.AppDevModeInterface.autoInstallStaticAuthApp.error(this.appData.name, this.localDevState.targetTestingAccountId),
+                failColor: 'white',
+            });
+            return false;
+        }
+    }
     async installAppOrOpenInstallUrl(isReinstall) {
-        // @TODO: Restore test account auto install functionality
-        // if (this.isAutomaticallyInstallable()) {
-        //   try {
-        //     await this.autoInstallStaticAuthApp();
-        //     uiLogger.success(
-        //       lib.AppDevModeInterface.autoInstallSuccess(
-        //         this.appData!.name,
-        //         this.localDevState.targetTestingAccountId
-        //       )
-        //     );
-        //     return;
-        //   } catch (e) {
-        //     uiLogger.error(
-        //       lib.AppDevModeInterface.autoInstallError(
-        //         this.appData!.name,
-        //         this.localDevState.targetTestingAccountId
-        //       )
-        //     );
-        //   }
-        // }
+        if (this.isAutomaticallyInstallable()) {
+            const installSuccess = await this.autoInstallStaticAuthApp();
+            if (installSuccess) {
+                return;
+            }
+        }
         const installUrl = await this.getAppInstallUrl();
-        await installAppBrowserPrompt(installUrl, isReinstall, {
-            testingAccountId: this.localDevState.targetTestingAccountId,
-            projectAccountId: this.localDevState.targetProjectAccountId,
-            projectName: this.localDevState.projectConfig.name,
-            appUid: this.appNode.uid,
-        });
+        await installAppBrowserPrompt(installUrl, isReinstall);
+        if (!isReinstall) {
+            await this.waitUntilAppIsInstalled(installUrl);
+        }
     }
     async checkTestAccountAppInstallation() {
-        if (!this.appNode || !this.appData) {
+        if (!this.appNode) {
             return {};
         }
         const { data: { isInstalledWithScopeGroups, previouslyAuthorizedScopeGroups }, } = await fetchAppInstallationData(this.localDevState.targetTestingAccountId, this.localDevState.projectId, this.appNode.uid, this.appNode.config.auth.requiredScopes, this.appNode.config.auth.optionalScopes);
@@ -203,11 +206,46 @@ class AppDevModeInterface {
                 installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
             };
         }
+        else {
+            this.appData = {
+                ...this.appData,
+                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
+            };
+        }
         return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
     }
-    onDevServerMessage = (message) => {
+    resolveAppInstallPromise() {
+        if (this.appInstallResolve) {
+            this.appInstallResolve();
+            this.appInstallResolve = undefined;
+        }
+    }
+    handleAppInstallSuccessDevServerMessage() {
+        this.resolveAppInstallPromise();
+        this.appData = {
+            ...this.appData,
+            installationState: APP_INSTALLATION_STATES.INSTALLED,
+        };
+    }
+    handleAppInstallInitiatedDevServerMessage() {
+        this.resolveAppInstallPromise();
+    }
+    handleAppInstallFailureDevServerMessage() {
+        uiLogger.error(lib.AppDevModeInterface.installationFailed);
+        process.exit(EXIT_CODES.ERROR);
+    }
+    onDevServerMessage = async (message) => {
         if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.WEBSOCKET_SERVER_CONNECTED) {
-            this.checkTestAccountAppInstallation();
+            await this.checkTestAccountAppInstallation();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_SUCCESS) {
+            this.handleAppInstallSuccessDevServerMessage();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.STATIC_AUTH_APP_INSTALL_FAILURE) {
+            this.handleAppInstallFailureDevServerMessage();
+        }
+        else if (message === LOCAL_DEV_SERVER_MESSAGE_TYPES.OAUTH_APP_INSTALL_INITIATED) {
+            this.handleAppInstallInitiatedDevServerMessage();
         }
     };
     onChangeProjectNodes = (nodes) => {
@@ -225,17 +263,11 @@ class AppDevModeInterface {
             this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
         }
     };
-    setUpStateListeners() {
-        this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
-        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
-    }
     removeStateListeners() {
         this.localDevState.removeListener('devServerMessage', this.onDevServerMessage);
         this.localDevState.removeListener('projectNodes', this.onChangeProjectNodes);
     }
-    // @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) {
+    async setup() {
         if (!this.appNode) {
             return;
         }
@@ -252,6 +284,7 @@ class AppDevModeInterface {
                         failColor: 'white',
                     });
                 }
+                this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
                 await this.installAppOrOpenInstallUrl(isReinstall || false);
             }
             else {
@@ -266,32 +299,12 @@ class AppDevModeInterface {
         catch (e) {
             logError(e);
         }
-        this.setUpStateListeners();
-        return UIEDevModeInterface.setup(args);
     }
     async start() {
-        if (!this.appNode) {
-            return;
-        }
-        return UIEDevModeInterface.start({
-            accountId: this.localDevState.targetTestingAccountId,
-            // @ts-expect-error TODO: reconcile types between CLI and UIE Dev Server
-            projectConfig: this.localDevState.projectConfig,
-            requestPorts,
-        });
-    }
-    async fileChange(filePath, event) {
-        if (!this.appNode) {
-            return;
-        }
-        return UIEDevModeInterface.fileChange(filePath, event);
+        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
     }
     async cleanup() {
-        if (!this.appNode) {
-            return;
-        }
         this.removeStateListeners();
-        return UIEDevModeInterface.cleanup();
     }
 }
 export default AppDevModeInterface;

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

@@ -1,40 +1,21 @@
-import { ProjectConfig, ComponentTypes, Component } from '../../../types/Projects.js';
-type DevServerInterface = {
-    setup?: Function;
-    start?: (options: object) => Promise<void>;
-    fileChange?: (filePath: string, event: string) => Promise<void>;
-    cleanup?: () => Promise<void>;
-};
-type ComponentsByType = {
-    [key in ComponentTypes]?: {
-        [key: string]: Component;
-    };
+import LocalDevState from './LocalDevState.js';
+import LocalDevLogger from './LocalDevLogger.js';
+type DevServerManagerConstructorOptions = {
+    localDevState: LocalDevState;
+    logger: LocalDevLogger;
 };
 declare class DevServerManager {
     private initialized;
     private started;
-    private componentsByType;
     private devServers;
-    constructor();
-    iterateDevServers(callback: (serverInterface: DevServerInterface, compatibleComponents: {
-        [key: string]: Component;
-    }) => Promise<void>): Promise<void>;
-    arrangeComponentsByType(components: Component[]): ComponentsByType;
-    setup({ components, onUploadRequired, accountId, setActiveApp, }: {
-        components: Component[];
-        onUploadRequired: () => void;
-        accountId: number;
-        setActiveApp: (appUid: string | undefined) => Promise<void>;
-    }): Promise<void>;
-    start({ accountId, projectConfig, }: {
-        accountId: number;
-        projectConfig: ProjectConfig;
-    }): Promise<void>;
+    constructor(options: DevServerManagerConstructorOptions);
+    private iterateDevServers;
+    setup(): Promise<void>;
+    start(): Promise<void>;
     fileChange({ filePath, event, }: {
         filePath: string;
         event: string;
     }): Promise<void>;
     cleanup(): Promise<void>;
 }
-declare const Manager: DevServerManager;
-export default Manager;
+export default DevServerManager;

package/lib/projects/localDev/DevServerManager.js

@@ -1,93 +1,39 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { DevModeInterface as UIEDevModeInterface } from '@hubspot/ui-extensions-dev-server';
-import { startPortManagerServer, stopPortManagerServer, requestPorts, } from '@hubspot/local-dev-lib/portManager';
-import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import { ComponentTypes, } from '../../../types/Projects.js';
+import AppDevModeInterface from './AppDevModeInterface.js';
 import { lib } from '../../../lang/en.js';
-import { uiLogger } from '../../ui/logger.js';
-const SERVER_KEYS = {
-    privateApp: 'privateApp',
-    publicApp: 'publicApp',
-};
+import UIExtensionsDevModeInterface from './UIExtensionsDevModeInterface.js';
 class DevServerManager {
     initialized;
     started;
-    componentsByType;
     devServers;
-    constructor() {
+    constructor(options) {
         this.initialized = false;
         this.started = false;
-        this.componentsByType = {};
-        this.devServers = {
-            [SERVER_KEYS.privateApp]: {
-                componentType: ComponentTypes.PrivateApp,
-                serverInterface: UIEDevModeInterface,
-            },
-            [SERVER_KEYS.publicApp]: {
-                componentType: ComponentTypes.PublicApp,
-                serverInterface: UIEDevModeInterface,
-            },
-        };
+        const AppsDevServer = new AppDevModeInterface({
+            localDevState: options.localDevState,
+            localDevLogger: options.logger,
+        });
+        const UIExtensionsDevServer = new UIExtensionsDevModeInterface({
+            localDevState: options.localDevState,
+        });
+        this.devServers = [AppsDevServer, UIExtensionsDevServer];
     }
     async iterateDevServers(callback) {
-        const serverKeys = Object.keys(this.devServers);
-        for (let i = 0; i < serverKeys.length; i++) {
-            const serverKey = serverKeys[i];
-            const devServer = this.devServers[serverKey];
-            const compatibleComponents = this.componentsByType[devServer.componentType] || {};
-            if (Object.keys(compatibleComponents).length) {
-                await callback(devServer.serverInterface, compatibleComponents);
-            }
-            else {
-                uiLogger.debug(lib.DevServerManager.noCompatibleComponents(serverKey));
-            }
-        }
+        await Promise.all(this.devServers.map(devServer => callback(devServer)));
     }
-    arrangeComponentsByType(components) {
-        return components.reduce((acc, component) => {
-            if (!acc[component.type]) {
-                acc[component.type] = {};
+    async setup() {
+        for (const devServer of this.devServers) {
+            if (devServer.setup) {
+                // Run setup functions in order
+                await devServer.setup();
             }
-            if ('name' in component.config && component.config.name) {
-                acc[component.type][component.config.name] = component;
-            }
-            return acc;
-        }, {});
-    }
-    async setup({ components, onUploadRequired, accountId, setActiveApp, }) {
-        this.componentsByType = this.arrangeComponentsByType(components);
-        let env;
-        const accountConfig = getAccountConfig(accountId);
-        if (accountConfig) {
-            env = accountConfig.env;
         }
-        await startPortManagerServer();
-        await this.iterateDevServers(async (serverInterface, compatibleComponents) => {
-            if (serverInterface.setup) {
-                await serverInterface.setup({
-                    components: compatibleComponents,
-                    onUploadRequired,
-                    logger,
-                    urls: {
-                        api: getHubSpotApiOrigin(env),
-                        web: getHubSpotWebsiteOrigin(env),
-                    },
-                    setActiveApp,
-                });
-            }
-        });
         this.initialized = true;
     }
-    async start({ accountId, projectConfig, }) {
+    async start() {
         if (this.initialized) {
             await this.iterateDevServers(async (serverInterface) => {
                 if (serverInterface.start) {
-                    await serverInterface.start({
-                        accountId,
-                        projectConfig,
-                        requestPorts,
-                    });
+                    await serverInterface.start();
                 }
             });
         }
@@ -112,9 +58,7 @@ class DevServerManager {
                     await serverInterface.cleanup();
                 }
             });
-            await stopPortManagerServer();
         }
     }
 }
-const Manager = new DevServerManager();
-export default Manager;
+export default DevServerManager;

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

@@ -0,0 +1,40 @@
+import { ProjectConfig, ComponentTypes, Component } from '../../../types/Projects.js';
+type DevServerInterface = {
+    setup?: Function;
+    start?: (options: object) => Promise<void>;
+    fileChange?: (filePath: string, event: string) => Promise<void>;
+    cleanup?: () => Promise<void>;
+};
+type ComponentsByType = {
+    [key in ComponentTypes]?: {
+        [key: string]: Component;
+    };
+};
+declare class DevServerManager_DEPRECATED {
+    private initialized;
+    private started;
+    private componentsByType;
+    private devServers;
+    constructor();
+    iterateDevServers(callback: (serverInterface: DevServerInterface, compatibleComponents: {
+        [key: string]: Component;
+    }) => Promise<void>): Promise<void>;
+    arrangeComponentsByType(components: Component[]): ComponentsByType;
+    setup({ components, onUploadRequired, accountId, setActiveApp, }: {
+        components: Component[];
+        onUploadRequired: () => void;
+        accountId: number;
+        setActiveApp: (appUid: string | undefined) => Promise<void>;
+    }): Promise<void>;
+    start({ accountId, projectConfig, }: {
+        accountId: number;
+        projectConfig: ProjectConfig;
+    }): Promise<void>;
+    fileChange({ filePath, event, }: {
+        filePath: string;
+        event: string;
+    }): Promise<void>;
+    cleanup(): Promise<void>;
+}
+declare const Manager: DevServerManager_DEPRECATED;
+export default Manager;