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

package/lib/projects/localDev/AppDevModeInterface.js

@@ -1,333 +0,0 @@
-import { fetchAppInstallationData } from '@hubspot/local-dev-lib/api/localDevAuth';
-import { fetchAppMetadataBySourceId, fetchPublicAppProductionInstallCounts, installStaticAuthAppOnTestAccount, } from '@hubspot/local-dev-lib/api/appsDev';
-import { getConfigAccountById } 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 { 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';
-import { isServerRunningAtUrl } from '../../http.js';
-class AppDevModeInterface {
-    localDevState;
-    localDevLogger;
-    _appNode;
-    marketplaceAppInstalls;
-    appInstallResolve;
-    constructor(options) {
-        this.localDevState = options.localDevState;
-        this.localDevLogger = options.localDevLogger;
-        if (!this.localDevState.targetProjectAccountId ||
-            !this.localDevState.projectConfig ||
-            !this.localDevState.projectDir) {
-            uiLogger.error(lib.LocalDevManager.failedToInitialize);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    getAppNodeFromProjectNodes(projectNodes) {
-        return Object.values(projectNodes).find(isAppIRNode) || null;
-    }
-    // Assumes only one app per project
-    get appNode() {
-        if (this._appNode === undefined) {
-            this._appNode = this.getAppNodeFromProjectNodes(this.localDevState.projectNodes);
-        }
-        return this._appNode;
-    }
-    get appData() {
-        // These checks are primarily for type safety
-        // App data will never be accessed before being set
-        if (!this.appNode) {
-            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 data;
-    }
-    set appData(appData) {
-        if (!this.appNode) {
-            return;
-        }
-        this.localDevState.setAppDataForUid(this.appNode.uid, appData);
-    }
-    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 = getConfigAccountById(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 && this.isOAuthApp()) {
-            return getOauthAppInstallUrl({
-                targetAccountId: this.localDevState.targetTestingAccountId,
-                env: this.localDevState.env,
-                clientId: this.appData.clientId,
-                scopes: this.appNode.config.auth.requiredScopes,
-                redirectUrls: this.appNode.config.auth.redirectUrls,
-            });
-        }
-        return getStaticAuthAppInstallUrl({
-            targetAccountId: this.localDevState.targetTestingAccountId,
-            env: this.localDevState.env,
-            appId: this.appData.id,
-        });
-    }
-    async fetchAppData() {
-        SpinniesManager.add('fetchAppData', {
-            text: lib.AppDevModeInterface.fetchAppData.checking(this.appNode?.config.name || ''),
-        });
-        let appData;
-        try {
-            const { data } = await fetchAppMetadataBySourceId(this.localDevState.projectData.id, this.appNode.uid, this.localDevState.targetProjectAccountId);
-            appData = data;
-        }
-        catch (e) {
-            SpinniesManager.fail('fetchAppData', {
-                text: lib.AppDevModeInterface.fetchAppData.error,
-            });
-            logError(e);
-            process.exit(EXIT_CODES.ERROR);
-        }
-        if (!appData) {
-            return;
-        }
-        const { data: { uniquePortalInstallCount }, } = await fetchPublicAppProductionInstallCounts(appData.id, this.localDevState.targetProjectAccountId);
-        this.appData = {
-            id: appData.id,
-            clientId: appData.clientId,
-            name: appData.name,
-            installationState: APP_INSTALLATION_STATES.UNKNOWN,
-            scopeGroupIds: appData.scopeGroupIds,
-        };
-        this.marketplaceAppInstalls = uniquePortalInstallCount;
-    }
-    async checkMarketplaceAppInstalls() {
-        if (!this.marketplaceAppInstalls) {
-            return;
-        }
-        SpinniesManager.fail('fetchAppData', {
-            text: lib.AppDevModeInterface.fetchAppData.activeInstallations(this.appNode?.config.name || '', this.marketplaceAppInstalls),
-            failColor: 'yellow',
-        });
-        uiLine();
-        uiLogger.log(lib.LocalDevManager.activeInstallWarning.explanation);
-        uiLine();
-        const proceed = await confirmPrompt(lib.LocalDevManager.activeInstallWarning.confirmationPrompt, { defaultAnswer: false });
-        if (!proceed) {
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-        this.localDevState.addUploadWarning(lib.AppDevModeInterface.defaultMarketplaceAppWarning(this.marketplaceAppInstalls));
-    }
-    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) {
-        if (this.isAutomaticallyInstallable()) {
-            const installSuccess = await this.autoInstallStaticAuthApp();
-            if (installSuccess) {
-                return;
-            }
-        }
-        const installUrl = await this.getAppInstallUrl();
-        await installAppBrowserPrompt(installUrl, isReinstall);
-        if (!isReinstall) {
-            await this.waitUntilAppIsInstalled(installUrl);
-        }
-    }
-    async checkTestAccountAppInstallation() {
-        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);
-        const isReinstall = previouslyAuthorizedScopeGroups.length > 0;
-        if (isInstalledWithScopeGroups) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED,
-            };
-        }
-        else if (isReinstall) {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.INSTALLED_WITH_OUTDATED_SCOPES,
-            };
-        }
-        else {
-            this.appData = {
-                ...this.appData,
-                installationState: APP_INSTALLATION_STATES.NOT_INSTALLED,
-            };
-        }
-        return { needsInstall: !isInstalledWithScopeGroups, isReinstall };
-    }
-    async validateOauthAppRedirectUrl() {
-        const redirectUrl = this.appNode?.config.auth.redirectUrls[0];
-        if (!redirectUrl) {
-            return;
-        }
-        const serverIsRunningAtRedirectUrl = await isServerRunningAtUrl(redirectUrl);
-        if (!serverIsRunningAtRedirectUrl) {
-            uiLogger.log('');
-            uiLogger.error(lib.AppDevModeInterface.oauthAppRedirectUrlError(redirectUrl));
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    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) {
-            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) => {
-        const newAppNode = this.getAppNodeFromProjectNodes(nodes);
-        const oldDistribution = this.appNode?.config.distribution;
-        const newDistribution = newAppNode?.config.distribution;
-        const oldAuthType = this.appNode?.config.auth.type;
-        const newAuthType = newAppNode?.config.auth.type;
-        if (newDistribution?.toLowerCase() === APP_DISTRIBUTION_TYPES.MARKETPLACE &&
-            oldDistribution?.toLowerCase() !== APP_DISTRIBUTION_TYPES.MARKETPLACE) {
-            this.localDevState.addUploadWarning(lib.AppDevModeInterface.distributionChanged);
-        }
-        else if (newAuthType?.toLowerCase() === APP_AUTH_TYPES.OAUTH &&
-            oldAuthType?.toLowerCase() !== APP_AUTH_TYPES.OAUTH) {
-            this.localDevState.addUploadWarning(lib.AppDevModeInterface.authTypeChanged);
-        }
-    };
-    removeStateListeners() {
-        this.localDevState.removeListener('devServerMessage', this.onDevServerMessage);
-        this.localDevState.removeListener('projectNodes', this.onChangeProjectNodes);
-    }
-    async setup() {
-        if (!this.appNode) {
-            return;
-        }
-        try {
-            await this.fetchAppData();
-            if (this.appNode.config.distribution === APP_DISTRIBUTION_TYPES.MARKETPLACE) {
-                await this.checkMarketplaceAppInstalls();
-            }
-            const { needsInstall, isReinstall } = await this.checkTestAccountAppInstallation();
-            if (needsInstall) {
-                if (SpinniesManager.pick('fetchAppData')) {
-                    SpinniesManager.fail('fetchAppData', {
-                        text: lib.AppDevModeInterface.fetchAppData.notInstalled(this.appNode.config.name, this.localDevState.targetTestingAccountId),
-                        failColor: 'white',
-                    });
-                }
-                if (this.isOAuthApp()) {
-                    await this.validateOauthAppRedirectUrl();
-                }
-                this.localDevState.addListener('devServerMessage', this.onDevServerMessage);
-                await this.installAppOrOpenInstallUrl(isReinstall || false);
-            }
-            else {
-                if (SpinniesManager.pick('fetchAppData')) {
-                    SpinniesManager.succeed('fetchAppData', {
-                        text: lib.AppDevModeInterface.fetchAppData.success(this.appNode.config.name, this.localDevState.targetTestingAccountId),
-                    });
-                }
-                uiLogger.log('');
-            }
-        }
-        catch (e) {
-            if (SpinniesManager.pick('fetchAppData')) {
-                SpinniesManager.fail('fetchAppData', {
-                    text: lib.AppDevModeInterface.fetchAppData.error,
-                    failColor: 'white',
-                });
-            }
-            logError(e);
-            process.exit(EXIT_CODES.ERROR);
-        }
-    }
-    async start() {
-        this.localDevState.addListener('projectNodes', this.onChangeProjectNodes);
-    }
-    async cleanup() {
-        this.removeStateListeners();
-    }
-}
-export default AppDevModeInterface;

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

@@ -1,21 +0,0 @@
-import LocalDevState from './LocalDevState.js';
-import LocalDevLogger from './LocalDevLogger.js';
-type DevServerManagerConstructorOptions = {
-    localDevState: LocalDevState;
-    logger: LocalDevLogger;
-};
-declare class DevServerManager {
-    private initialized;
-    private started;
-    private devServers;
-    constructor(options: DevServerManagerConstructorOptions);
-    private iterateDevServers;
-    setup(): Promise<void>;
-    start(): Promise<void>;
-    fileChange({ filePath, event, }: {
-        filePath: string;
-        event: string;
-    }): Promise<void>;
-    cleanup(): Promise<void>;
-}
-export default DevServerManager;

package/lib/projects/localDev/DevServerManager.js

@@ -1,64 +0,0 @@
-import AppDevModeInterface from './AppDevModeInterface.js';
-import { lib } from '../../../lang/en.js';
-import UIExtensionsDevModeInterface from './UIExtensionsDevModeInterface.js';
-class DevServerManager {
-    initialized;
-    started;
-    devServers;
-    constructor(options) {
-        this.initialized = false;
-        this.started = false;
-        const AppsDevServer = new AppDevModeInterface({
-            localDevState: options.localDevState,
-            localDevLogger: options.logger,
-        });
-        const UIExtensionsDevServer = new UIExtensionsDevModeInterface({
-            localDevState: options.localDevState,
-        });
-        this.devServers = [AppsDevServer, UIExtensionsDevServer];
-    }
-    async iterateDevServers(callback) {
-        await Promise.all(this.devServers.map(devServer => callback(devServer)));
-    }
-    async setup() {
-        for (const devServer of this.devServers) {
-            if (devServer.setup) {
-                // Run setup functions in order
-                await devServer.setup();
-            }
-        }
-        this.initialized = true;
-    }
-    async start() {
-        if (this.initialized) {
-            await this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.start) {
-                    await serverInterface.start();
-                }
-            });
-        }
-        else {
-            throw new Error(lib.DevServerManager.notInitialized);
-        }
-        this.started = true;
-    }
-    async fileChange({ filePath, event, }) {
-        if (this.started) {
-            this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.fileChange) {
-                    await serverInterface.fileChange(filePath, event);
-                }
-            });
-        }
-    }
-    async cleanup() {
-        if (this.started) {
-            await this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.cleanup) {
-                    await serverInterface.cleanup();
-                }
-            });
-        }
-    }
-}
-export default DevServerManager;

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

@@ -1,40 +0,0 @@
-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;

package/lib/projects/localDev/DevServerManager_DEPRECATED.js

@@ -1,128 +0,0 @@
-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 { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { ComponentTypes, } from '../../../types/Projects.js';
-import { lib } from '../../../lang/en.js';
-import { uiLogger } from '../../ui/logger.js';
-import { logError } from '../../errorHandlers/index.js';
-import { EXIT_CODES } from '../../enums/exitCodes.js';
-const SERVER_KEYS = {
-    privateApp: 'privateApp',
-    publicApp: 'publicApp',
-};
-class DevServerManager_DEPRECATED {
-    initialized;
-    started;
-    componentsByType;
-    devServers;
-    constructor() {
-        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,
-            },
-        };
-    }
-    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));
-            }
-        }
-    }
-    arrangeComponentsByType(components) {
-        return components.reduce((acc, component) => {
-            if (!acc[component.type]) {
-                acc[component.type] = {};
-            }
-            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 = getConfigAccountById(accountId);
-        if (accountConfig) {
-            env = accountConfig.env;
-        }
-        try {
-            await startPortManagerServer();
-        }
-        catch (e) {
-            logError(e);
-            process.exit(EXIT_CODES.ERROR);
-        }
-        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, }) {
-        if (this.initialized) {
-            await this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.start) {
-                    await serverInterface.start({
-                        accountId,
-                        projectConfig,
-                        requestPorts,
-                    });
-                }
-            });
-        }
-        else {
-            throw new Error(lib.DevServerManager.notInitialized);
-        }
-        this.started = true;
-    }
-    async fileChange({ filePath, event, }) {
-        if (this.started) {
-            this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.fileChange) {
-                    await serverInterface.fileChange(filePath, event);
-                }
-            });
-        }
-    }
-    async cleanup() {
-        if (this.started) {
-            await this.iterateDevServers(async (serverInterface) => {
-                if (serverInterface.cleanup) {
-                    await serverInterface.cleanup();
-                }
-            });
-            await stopPortManagerServer();
-        }
-    }
-}
-const Manager = new DevServerManager_DEPRECATED();
-export default Manager;

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

@@ -1,18 +0,0 @@
-import LocalDevLogger from './LocalDevLogger.js';
-type DevSessionManagerConstructorOptions = {
-    targetTestingAccountId: number;
-    localDevLogger?: LocalDevLogger;
-};
-declare class DevSessionManager {
-    localDevLogger?: LocalDevLogger;
-    targetTestingAccountId: number;
-    protected _devSessionId: number | undefined;
-    private _heartbeatInterval;
-    private _heartbeatRetries;
-    constructor(options: DevSessionManagerConstructorOptions);
-    private validateSessionIdExists;
-    registerSession(): Promise<boolean>;
-    private initializeHeartbeat;
-    deleteDevSession(): Promise<boolean>;
-}
-export default DevSessionManager;