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

package/commands/app/install.js

@@ -1,122 +0,0 @@
-import { fetchDeveloperTestAccountOauthAppInstallStatus, installOauthAppIntoDeveloperTestAccount, } from '@hubspot/local-dev-lib/api/developerTestAccounts';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { commands } from '../../lang/en.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { APP_AUTH_TYPES } from '../../lib/constants.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-import { poll } from '../../lib/polling.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
-import { handleTranslate } from '../../lib/projects/upload.js';
-import { isAppIRNode } from '../../lib/projects/structure.js';
-import { logError } from '../../lib/errorHandlers/index.js';
-const command = 'install <test-account-id>';
-const describe = undefined; // commands.app.subcommands.install.describe;
-async function handler(args) {
-    const { derivedAccountId, appUid, projectName, testAccountId, formatOutputAsJson, } = args;
-    trackCommandUsage('app-install', {}, derivedAccountId);
-    const jsonOutput = {};
-    let targetProjectName = projectName;
-    let targetAppUid = appUid;
-    const { projectConfig, projectDir } = await getProjectConfig();
-    if (!targetProjectName) {
-        validateProjectConfig(projectConfig, projectDir);
-        targetProjectName = projectConfig?.name;
-    }
-    if (!targetProjectName) {
-        uiLogger.error(commands.app.subcommands.install.errors.mustSpecifyProjectName);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    let isAppOauth = true;
-    if (!targetAppUid) {
-        const intermediateRepresentation = await handleTranslate(projectDir, projectConfig, derivedAccountId, true, undefined);
-        if (intermediateRepresentation) {
-            Object.values(intermediateRepresentation.intermediateNodesIndexedByUid).forEach(node => {
-                if (isAppIRNode(node)) {
-                    targetAppUid = node.uid;
-                    isAppOauth = node.config.auth.type === APP_AUTH_TYPES.OAUTH;
-                }
-            });
-        }
-    }
-    if (!targetAppUid) {
-        uiLogger.error(commands.app.subcommands.install.errors.noAppUidFound);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!isAppOauth) {
-        uiLogger.error(commands.app.subcommands.install.errors.appMustBeOauth);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        const { data } = await installOauthAppIntoDeveloperTestAccount(derivedAccountId, testAccountId, targetProjectName, targetAppUid);
-        if (data?.authCodes.length > 0) {
-            jsonOutput.authCode = data.authCodes[0].authCode;
-        }
-    }
-    catch (err) {
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    SpinniesManager.init({
-        succeedColor: 'white',
-    });
-    SpinniesManager.add('installApp', {
-        text: commands.app.subcommands.install.polling.start,
-    });
-    let appInstallSucceeded = false;
-    try {
-        await poll(() => fetchDeveloperTestAccountOauthAppInstallStatus(derivedAccountId, targetProjectName, targetAppUid), {
-            successStates: ['SUCCESS'],
-            errorStates: [],
-        });
-        appInstallSucceeded = true;
-    }
-    catch (err) {
-        SpinniesManager.fail('installApp');
-        logError(err);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!appInstallSucceeded) {
-        SpinniesManager.fail('installApp');
-        process.exit(EXIT_CODES.ERROR);
-    }
-    SpinniesManager.succeed('installApp', {
-        text: commands.app.subcommands.install.polling.success,
-    });
-    if (formatOutputAsJson) {
-        uiLogger.json(jsonOutput);
-    }
-    process.exit(EXIT_CODES.SUCCESS);
-}
-function installAppBuilder(yargs) {
-    yargs.positional('test-account-id', {
-        describe: commands.app.subcommands.install.positionals.testAccountId,
-        required: true,
-        type: 'number',
-    });
-    yargs.option('app-uid', {
-        describe: commands.app.subcommands.install.options.appUid,
-        type: 'string',
-    });
-    yargs.option('project-name', {
-        describe: commands.app.subcommands.install.options.projectName,
-        type: 'string',
-    });
-    yargs.example('install 1234567890 --app-uid=my-app-uid --project-name=my-project', commands.app.subcommands.install.example);
-    return yargs;
-}
-const builder = makeYargsBuilder(installAppBuilder, command, commands.app.subcommands.install.describe, {
-    useGlobalOptions: true,
-    useAccountOptions: true,
-    useConfigOptions: true,
-    useEnvironmentOptions: true,
-    useJSONOutputOptions: true,
-});
-const installAppCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default installAppCommand;

package/lib/middleware/__test__/utils.test.js

@@ -1,51 +0,0 @@
-import { isTargetedCommand } from '../utils.js';
-const targetCommandMap = {
-    init: { target: true },
-    account: {
-        target: true,
-        subCommands: {
-            use: { target: true },
-        },
-    },
-    project: {
-        subCommands: {
-            deploy: { target: true },
-        },
-    },
-};
-describe('lib/middleware/utils', () => {
-    describe('isTargetedCommand()', () => {
-        it('should return true for a direct target command', () => {
-            const result = isTargetedCommand(['init'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return true for a command with a subcommand', () => {
-            const result = isTargetedCommand(['account'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return true for a nested target command', () => {
-            const result = isTargetedCommand(['project', 'deploy'], targetCommandMap);
-            expect(result).toBe(true);
-        });
-        it('should return false for a non-existent command', () => {
-            const result = isTargetedCommand(['nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-targeted command', () => {
-            const result = isTargetedCommand(['auth'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a command with a targeted subcommand', () => {
-            const result = isTargetedCommand(['project'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for a non-existent subcommand', () => {
-            const result = isTargetedCommand(['auth', 'nonexistent'], targetCommandMap);
-            expect(result).toBe(false);
-        });
-        it('should return false for an empty command array', () => {
-            const result = isTargetedCommand([], targetCommandMap);
-            expect(result).toBe(false);
-        });
-    });
-});

package/lib/middleware/utils.d.ts

@@ -1,8 +0,0 @@
-type TargetCommandMap = {
-    [key: string]: {
-        target?: boolean;
-        subCommands?: TargetCommandMap;
-    };
-};
-export declare function isTargetedCommand(commandParts: (string | number)[], targetCommandMap: TargetCommandMap): boolean;
-export {};

package/lib/middleware/utils.js

@@ -1,14 +0,0 @@
-export function isTargetedCommand(commandParts, targetCommandMap) {
-    const currentCommand = commandParts[0];
-    if (!targetCommandMap[currentCommand]) {
-        return false;
-    }
-    if (targetCommandMap[currentCommand].target) {
-        return true;
-    }
-    const subCommands = targetCommandMap[currentCommand].subCommands || {};
-    if (commandParts.length > 1) {
-        return isTargetedCommand(commandParts.slice(1), subCommands);
-    }
-    return false;
-}

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

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

package/lib/projects/localDev/DevServerManagerV2.js

@@ -1,81 +0,0 @@
-import { logger } from '@hubspot/local-dev-lib/logger';
-import { startPortManagerServer, stopPortManagerServer, } from '@hubspot/local-dev-lib/portManager';
-import { getHubSpotApiOrigin, getHubSpotWebsiteOrigin, } from '@hubspot/local-dev-lib/urls';
-import { getAccountConfig } from '@hubspot/local-dev-lib/config';
-import AppDevModeInterface from './AppDevModeInterface.js';
-import { lib } from '../../../lang/en.js';
-class DevServerManagerV2 {
-    initialized;
-    started;
-    devServers;
-    localDevState;
-    constructor(options) {
-        this.initialized = false;
-        this.started = false;
-        this.localDevState = options.localDevState;
-        const AppsDevServer = new AppDevModeInterface({
-            localDevState: options.localDevState,
-            localDevLogger: options.logger,
-        });
-        this.devServers = [AppsDevServer];
-    }
-    async iterateDevServers(callback) {
-        await Promise.all(this.devServers.map(devServer => callback(devServer)));
-    }
-    async setup() {
-        let env;
-        const accountConfig = getAccountConfig(this.localDevState.targetTestingAccountId);
-        if (accountConfig) {
-            env = accountConfig.env;
-        }
-        await startPortManagerServer();
-        await this.iterateDevServers(async (serverInterface) => {
-            if (serverInterface.setup) {
-                // @TODO: In the future, update UIE Dev Server to use LocalDevState
-                await serverInterface.setup({
-                    components: this.localDevState.projectNodes,
-                    profileData: this.localDevState.projectProfileData,
-                    logger,
-                    urls: {
-                        api: getHubSpotApiOrigin(env),
-                        web: getHubSpotWebsiteOrigin(env),
-                    },
-                });
-            }
-        });
-        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();
-                }
-            });
-            await stopPortManagerServer();
-        }
-    }
-}
-export default DevServerManagerV2;