@hubspot/cli 8.10.0 → 8.12.0-beta.0

package/commands/project/dev/deprecatedFlow.js

@@ -1,180 +0,0 @@
-import { getConfigAccountById, getLinkedOrAllConfigAccounts, getConfigAccountEnvironment, } from '@hubspot/local-dev-lib/config';
-import { getHsSettingsFileIfExists, getHsSettingsFilePath, } from '@hubspot/local-dev-lib/config/hsSettings';
-import { findProjectComponents, getProjectComponentTypes, } from '../../../lib/projects/structure.js';
-import { ComponentTypes } from '../../../types/Projects.js';
-import { commands } from '../../../lang/en.js';
-import { uiLogger } from '../../../lib/ui/logger.js';
-import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import LocalDevManager_DEPRECATED from '../../../lib/projects/localDev/LocalDevManager_DEPRECATED.js';
-import { confirmDefaultAccountIsTarget, suggestRecommendedNestedAccount, checkIfAccountFlagIsSupported, checkIfDefaultAccountIsSupported, createSandboxForLocalDev, createDeveloperTestAccountForLocalDev, useExistingDevTestAccount, checkIfParentAccountIsAuthed, hasSandboxes, } from '../../../lib/projects/localDev/helpers/account.js';
-import { createInitialBuildForNewProject, createNewProjectForLocalDev, } from '../../../lib/projects/localDev/helpers/project.js';
-import { handleExit } from '../../../lib/process.js';
-import { getErrorMessage } from '../../../lib/errorHandlers/index.js';
-import { isSandbox, isDeveloperTestAccount, } from '../../../lib/accountTypes.js';
-import { ensureProjectExists } from '../../../lib/projects/ensureProjectExists.js';
-import { isDirectoryLinked, addAccountToLinkedSettings, } from '../../../lib/link/linkUtils.js';
-export async function deprecatedProjectDevFlow({ args, accountId, projectConfig, projectDir, }) {
-    const { userProvidedAccount, derivedAccountId, exit } = args;
-    const env = getConfigAccountEnvironment(derivedAccountId);
-    const components = await findProjectComponents(projectDir);
-    const runnableComponents = components.filter(component => component.runnable);
-    const componentTypes = getProjectComponentTypes(runnableComponents);
-    const hasPrivateApps = !!componentTypes[ComponentTypes.PrivateApp];
-    const hasPublicApps = !!componentTypes[ComponentTypes.PublicApp];
-    const accountConfig = getConfigAccountById(accountId);
-    if (!accountConfig) {
-        uiLogger.error(commands.project.dev.errors.noAccount(accountId));
-        return exit(EXIT_CODES.ERROR);
-    }
-    if (runnableComponents.length === 0) {
-        uiLogger.error(commands.project.dev.errors.noRunnableComponents);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-    else if (hasPrivateApps && hasPublicApps) {
-        uiLogger.error(commands.project.dev.errors.invalidProjectComponents);
-        return exit(EXIT_CODES.SUCCESS);
-    }
-    const hsSettings = getHsSettingsFileIfExists();
-    const directoryIsLinked = isDirectoryLinked(hsSettings);
-    const accounts = getLinkedOrAllConfigAccounts();
-    if (!accounts) {
-        uiLogger.error(commands.project.dev.errors.noAccountsInConfig);
-        return exit(EXIT_CODES.ERROR);
-    }
-    let bypassRecommendedAccountPrompt = false;
-    if (isDeveloperTestAccount(accountConfig)) {
-        bypassRecommendedAccountPrompt = true;
-    }
-    else if (!hasPublicApps && isSandbox(accountConfig)) {
-        bypassRecommendedAccountPrompt = true;
-    }
-    else if (!hasPublicApps) {
-        const defaultAccountHasSandboxes = await hasSandboxes(accountConfig);
-        bypassRecommendedAccountPrompt = !defaultAccountHasSandboxes;
-    }
-    // targetProjectAccountId and targetTestingAccountId are set to null if --account flag is not provided.
-    // By setting them to null, we can later check if they need to be assigned based on the default account configuration and the type of app.
-    let targetProjectAccountId = userProvidedAccount ? derivedAccountId : null;
-    // The account that we are locally testing against
-    let targetTestingAccountId = userProvidedAccount ? derivedAccountId : null;
-    // Check that the default account or flag option is valid for the type of app in this project
-    if (userProvidedAccount) {
-        try {
-            checkIfAccountFlagIsSupported(accountConfig, hasPublicApps);
-        }
-        catch (e) {
-            uiLogger.error(getErrorMessage(e));
-            return exit(EXIT_CODES.SUCCESS);
-        }
-        if (hasPublicApps) {
-            targetProjectAccountId = accountConfig.parentAccountId || null;
-        }
-    }
-    else {
-        await checkIfDefaultAccountIsSupported(accountConfig, hasPublicApps, exit);
-    }
-    if (directoryIsLinked) {
-        uiLogger.log('');
-        uiLogger.info(commands.account.subcommands.link.shared.usingLinkedAccounts(getHsSettingsFilePath()));
-    }
-    // The user is targeting an account type that we recommend developing on
-    if (!targetProjectAccountId && bypassRecommendedAccountPrompt) {
-        targetTestingAccountId = derivedAccountId;
-        await confirmDefaultAccountIsTarget(accountConfig, exit);
-        if (hasPublicApps) {
-            try {
-                checkIfParentAccountIsAuthed(accountConfig);
-            }
-            catch (e) {
-                uiLogger.error(getErrorMessage(e));
-                return exit(EXIT_CODES.SUCCESS);
-            }
-            targetProjectAccountId = accountConfig.parentAccountId || null;
-        }
-        else {
-            targetProjectAccountId = derivedAccountId;
-        }
-    }
-    let createNewSandbox = false;
-    let createNewDeveloperTestAccount = false;
-    if (!targetProjectAccountId) {
-        const { targetAccountId, parentAccountId, createNestedAccount, notInConfigAccount, } = await suggestRecommendedNestedAccount(accounts, accountConfig, hasPublicApps);
-        targetProjectAccountId = hasPublicApps
-            ? parentAccountId || null
-            : targetAccountId;
-        targetTestingAccountId = targetAccountId;
-        // Only used for developer test accounts that are not yet in the config
-        if (notInConfigAccount) {
-            const accountAdded = await useExistingDevTestAccount(env, notInConfigAccount);
-            if (!accountAdded) {
-                return exit(EXIT_CODES.SUCCESS);
-            }
-            if (directoryIsLinked) {
-                addAccountToLinkedSettings(notInConfigAccount.id);
-            }
-        }
-        createNewSandbox = hasPrivateApps && createNestedAccount;
-        createNewDeveloperTestAccount = hasPublicApps && createNestedAccount;
-    }
-    if (createNewSandbox) {
-        try {
-            targetProjectAccountId = await createSandboxForLocalDev(derivedAccountId, accountConfig, env);
-        }
-        catch {
-            return exit(EXIT_CODES.ERROR);
-        }
-        // We will be running our tests against this new sandbox account
-        targetTestingAccountId = targetProjectAccountId;
-        if (directoryIsLinked) {
-            addAccountToLinkedSettings(targetProjectAccountId);
-        }
-    }
-    if (createNewDeveloperTestAccount) {
-        try {
-            targetTestingAccountId = await createDeveloperTestAccountForLocalDev(derivedAccountId, accountConfig, env, false);
-        }
-        catch {
-            return exit(EXIT_CODES.ERROR);
-        }
-        targetProjectAccountId = derivedAccountId;
-        if (directoryIsLinked) {
-            addAccountToLinkedSettings(targetTestingAccountId);
-        }
-    }
-    if (!targetProjectAccountId || !targetTestingAccountId) {
-        uiLogger.error(commands.project.dev.errors.noAccount(accountId));
-        return exit(EXIT_CODES.ERROR);
-    }
-    // eslint-disable-next-line prefer-const
-    let { projectExists, project } = await ensureProjectExists(targetProjectAccountId, projectConfig.name, {
-        allowCreate: false,
-        noLogs: true,
-        withPolling: createNewSandbox,
-    });
-    let deployedBuild;
-    let isGithubLinked = false;
-    if (projectExists && project) {
-        deployedBuild = project.deployedBuild;
-        isGithubLinked = Boolean(project.sourceIntegration && project.sourceIntegration.source === 'GITHUB');
-    }
-    else {
-        project = await createNewProjectForLocalDev(projectConfig, targetProjectAccountId, createNewSandbox, hasPublicApps, exit);
-        deployedBuild = await createInitialBuildForNewProject(projectConfig, projectDir, targetProjectAccountId, exit);
-    }
-    const LocalDev = new LocalDevManager_DEPRECATED({
-        runnableComponents,
-        debug: args.debug,
-        deployedBuild,
-        isGithubLinked,
-        parentAccountId: targetProjectAccountId,
-        projectConfig,
-        projectDir,
-        projectId: project.id,
-        targetAccountId: targetTestingAccountId,
-        env,
-        exit,
-        port: args.port,
-    });
-    await LocalDev.start();
-    handleExit(({ isSIGHUP }) => LocalDev.stop(!isSIGHUP));
-}

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

@@ -1,43 +0,0 @@
-import { ProjectConfig, ComponentTypes, Component } from '../../../types/Projects.js';
-import { ExitFunction } from '../../../types/Yargs.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, exit, port, }: {
-        components: Component[];
-        onUploadRequired: () => void;
-        accountId: number;
-        setActiveApp: (appUid: string | undefined) => Promise<void>;
-        exit: ExitFunction;
-        port?: number;
-    }): 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, exit, port, }) {
-        this.componentsByType = this.arrangeComponentsByType(components);
-        let env;
-        const accountConfig = getConfigAccountById(accountId);
-        if (accountConfig) {
-            env = accountConfig.env;
-        }
-        try {
-            await startPortManagerServer(port);
-        }
-        catch (e) {
-            logError(e);
-            return 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/LocalDevManager_DEPRECATED.d.ts

@@ -1,64 +0,0 @@
-import { FSWatcher } from 'chokidar';
-import { Build } from '@hubspot/local-dev-lib/types/Build';
-import { PublicApp } from '@hubspot/local-dev-lib/types/Apps';
-import { Environment } from '@hubspot/local-dev-lib/types/Accounts';
-import { Component, ProjectConfig } from '../../../types/Projects.js';
-import { ExitFunction } from '../../../types/Yargs.js';
-type LocalDevManagerConstructorOptions = {
-    targetAccountId: number;
-    parentAccountId: number;
-    projectConfig: ProjectConfig;
-    projectDir: string;
-    projectId: number;
-    debug?: boolean;
-    deployedBuild?: Build;
-    isGithubLinked: boolean;
-    runnableComponents: Component[];
-    env: Environment;
-    exit: ExitFunction;
-    port?: number;
-};
-declare class LocalDevManager_DEPRECATED {
-    targetAccountId: number;
-    targetProjectAccountId: number;
-    projectConfig: ProjectConfig;
-    projectDir: string;
-    projectId: number;
-    debug: boolean;
-    deployedBuild?: Build;
-    isGithubLinked: boolean;
-    watcher: FSWatcher | null;
-    uploadWarnings: {
-        [key: string]: boolean;
-    };
-    runnableComponents: Component[];
-    activeApp: Component | null;
-    activePublicAppData: PublicApp | null;
-    env: Environment;
-    publicAppActiveInstalls: number | null;
-    projectSourceDir: string;
-    mostRecentUploadWarning: string | null;
-    private devSessionManager;
-    private exit;
-    private port?;
-    constructor(options: LocalDevManagerConstructorOptions);
-    setActiveApp(appUid?: string): Promise<void>;
-    setActivePublicAppData(): Promise<void>;
-    checkActivePublicAppInstalls(): Promise<void>;
-    start(): Promise<void>;
-    stop(showProgress?: boolean): Promise<void>;
-    checkPublicAppInstallation(): Promise<void>;
-    updateKeypressListeners(): void;
-    getUploadCommand(): string;
-    logUploadWarning(reason?: string): void;
-    monitorConsoleOutput(): void;
-    compareLocalProjectToDeployed(): void;
-    startWatching(): void;
-    stopWatching(): Promise<void>;
-    handleWatchEvent(filePath: string, event: string, configPaths: string[]): void;
-    devServerSetup(): Promise<boolean>;
-    devServerStart(): Promise<void>;
-    devServerFileChange(filePath: string, event: string): void;
-    devServerCleanup(): Promise<boolean>;
-}
-export default LocalDevManager_DEPRECATED;