@hubspot/cli 7.7.19-experimental.3 → 7.7.21-experimental.0

package/commands/__tests__/getStarted.test.js

@@ -0,0 +1,165 @@
+import getStartedCommand from '../getStarted.js';
+import { trackCommandUsage } from '../../lib/usageTracking.js';
+import { promptUser } from '../../lib/prompts/promptUtils.js';
+import { projectNameAndDestPrompt } from '../../lib/prompts/projectNameAndDestPrompt.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { getProjectConfig, writeProjectConfig, } from '../../lib/projects/config.js';
+import { getProjectPackageJsonLocations, installPackages, } from '../../lib/dependencyManagement.js';
+import { GET_STARTED_OPTIONS } from '../../lib/constants.js';
+import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
+import open from 'open';
+vi.mock('../../lib/usageTracking');
+vi.mock('../../lib/prompts/promptUtils');
+vi.mock('../../lib/prompts/projectNameAndDestPrompt');
+vi.mock('../../lib/projects/config');
+vi.mock('../../lib/ui/logger');
+vi.mock('../../lib/errorHandlers');
+vi.mock('@hubspot/local-dev-lib/github');
+vi.mock('../../lib/dependencyManagement');
+vi.mock('open');
+vi.mock('fs-extra', () => ({
+    default: {
+        readFileSync: vi.fn().mockReturnValue('{"name": "test-project"}'),
+        existsSync: vi.fn().mockReturnValue(false),
+        readdirSync: vi.fn().mockReturnValue(['file1.js', 'file2.js']),
+    },
+}));
+describe('commands/get-started', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(getStartedCommand.command).toEqual('get-started');
+        });
+    });
+    describe('describe', () => {
+        it('should have undefined describe property', () => {
+            expect(getStartedCommand.describe).toBeUndefined();
+        });
+    });
+    describe('command structure', () => {
+        it('should have handler function', () => {
+            expect(getStartedCommand.handler).toBeDefined();
+            expect(typeof getStartedCommand.handler).toBe('function');
+        });
+        it('should have builder function', () => {
+            expect(getStartedCommand.builder).toBeDefined();
+            expect(typeof getStartedCommand.builder).toBe('function');
+        });
+    });
+    describe('handler', () => {
+        const mockArgs = {
+            derivedAccountId: 12345,
+            templateSource: undefined,
+            name: 'test-project',
+            dest: 'test-destination',
+            d: false,
+            debug: false,
+            c: undefined,
+            config: undefined,
+            a: undefined,
+            account: undefined,
+            'use-env': undefined,
+            useEnv: undefined,
+            _: [],
+            $0: 'hs',
+        };
+        beforeEach(() => {
+            vi.clearAllMocks();
+            trackCommandUsage.mockResolvedValue(undefined);
+            projectNameAndDestPrompt.mockResolvedValue({
+                dest: 'test-destination',
+                name: 'test-project',
+            });
+            cloneGithubRepo.mockResolvedValue(true);
+            getProjectConfig.mockResolvedValue({
+                projectConfig: null,
+                projectDir: null,
+            });
+            writeProjectConfig.mockResolvedValue(true);
+            getProjectPackageJsonLocations.mockResolvedValue(['/path/to/package/dir']);
+            installPackages.mockResolvedValue(undefined);
+            process.exit = vi.fn();
+        });
+        describe('CMS flow', () => {
+            it('should handle CMS option selection', async () => {
+                promptUser.mockResolvedValue({
+                    default: GET_STARTED_OPTIONS.CMS,
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            });
+            it('should open Design Manager when user confirms and browser is available', async () => {
+                promptUser
+                    .mockResolvedValueOnce({ default: GET_STARTED_OPTIONS.CMS })
+                    .mockResolvedValueOnce({ shouldOpen: true });
+                await getStartedCommand.handler(mockArgs);
+                expect(open).toHaveBeenCalledWith(expect.stringContaining('design-manager'), { url: true });
+            });
+        });
+        describe('App flow', () => {
+            beforeEach(() => {
+                promptUser
+                    .mockResolvedValueOnce({
+                    default: GET_STARTED_OPTIONS.APP,
+                })
+                    .mockResolvedValueOnce({
+                    shouldInstallDependencies: true,
+                })
+                    .mockResolvedValueOnce({
+                    shouldUpload: true,
+                });
+            });
+            it('should handle App option selection', async () => {
+                await getStartedCommand.handler(mockArgs);
+                expect(projectNameAndDestPrompt).toHaveBeenCalledWith(mockArgs);
+                expect(cloneGithubRepo).toHaveBeenCalled();
+            });
+            it('should handle upload flow when user confirms', async () => {
+                promptUser
+                    .mockResolvedValueOnce({ default: GET_STARTED_OPTIONS.APP })
+                    .mockResolvedValueOnce({ shouldUpload: true });
+                const mockProjectConfig = {
+                    name: 'test-project',
+                    srcDir: 'src',
+                    platformVersion: '1.0.0',
+                };
+                getProjectConfig
+                    .mockResolvedValueOnce({
+                    projectConfig: null,
+                    projectDir: null,
+                })
+                    .mockResolvedValueOnce({
+                    projectConfig: mockProjectConfig,
+                    projectDir: '/path/to/project',
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(promptUser).toHaveBeenCalledWith([
+                    expect.objectContaining({
+                        type: 'confirm',
+                        name: 'shouldUpload',
+                        message: expect.any(String),
+                        default: true,
+                    }),
+                ]);
+            });
+            it('should skip upload when user declines', async () => {
+                promptUser
+                    .mockResolvedValueOnce({ shouldInstallDependencies: false })
+                    .mockResolvedValueOnce({ shouldUpload: false });
+                await getStartedCommand.handler(mockArgs);
+                expect(process.exit).toHaveBeenCalledWith(EXIT_CODES.SUCCESS);
+            });
+        });
+        describe('tracking', () => {
+            it('should track command usage', async () => {
+                promptUser.mockResolvedValue({
+                    default: GET_STARTED_OPTIONS.APP,
+                });
+                await getStartedCommand.handler(mockArgs);
+                expect(trackCommandUsage).toHaveBeenCalledWith('get-started', {}, mockArgs.derivedAccountId);
+            });
+        });
+    });
+});

package/commands/__tests__/hubdb.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/hubdb.test.js

@@ -0,0 +1,50 @@
+import yargs from 'yargs';
+import clear from '../hubdb/clear.js';
+import create from '../hubdb/create.js';
+import deleteCommand from '../hubdb/delete.js';
+import fetch from '../hubdb/fetch.js';
+import list from '../hubdb/list.js';
+import hubdbCommands from '../hubdb.js';
+vi.mock('../hubdb/clear');
+vi.mock('../hubdb/create');
+vi.mock('../hubdb/delete');
+vi.mock('../hubdb/fetch');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/hubdb', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(hubdbCommands.command).toEqual('hubdb');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(hubdbCommands.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [clear, create, deleteCommand, fetch, list];
+        it('should demand the command takes one positional argument', () => {
+            hubdbCommands.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            hubdbCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            hubdbCommands.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/init.test.js

@@ -0,0 +1,42 @@
+import yargs from 'yargs';
+import { addConfigOptions, addTestingOptions } from '../../lib/commonOpts.js';
+import initCommand from '../init.js';
+vi.mock('../../lib/commonOpts');
+const optionsSpy = vi
+    .spyOn(yargs, 'options')
+    .mockReturnValue(yargs);
+describe('commands/init', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(initCommand.command).toEqual('init');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(initCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            initCommand.builder(yargs);
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                'auth-type': expect.objectContaining({
+                    type: 'string',
+                    choices: ['personalaccesskey', 'oauth2'],
+                    default: 'personalaccesskey',
+                }),
+                account: expect.objectContaining({ type: 'string' }),
+                'disable-tracking': expect.objectContaining({
+                    type: 'boolean',
+                    hidden: true,
+                    default: false,
+                }),
+            });
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addTestingOptions).toHaveBeenCalledTimes(1);
+            expect(addTestingOptions).toHaveBeenCalledWith(yargs);
+        });
+    });
+});

package/commands/__tests__/lint.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/lint.test.js

@@ -0,0 +1,33 @@
+import yargs from 'yargs';
+import { addConfigOptions, addAccountOptions } from '../../lib/commonOpts.js';
+import lintCommand from '../lint.js';
+vi.mock('../../lib/commonOpts');
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+describe('commands/lint', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(lintCommand.command).toEqual('lint <path>');
+        });
+    });
+    describe('describe', () => {
+        it('should not provide a description', () => {
+            expect(lintCommand.describe).toEqual(undefined);
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct positional arguments', () => {
+            lintCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledWith('path', expect.objectContaining({ type: 'string' }));
+        });
+        it('should support the correct options', () => {
+            lintCommand.builder(yargs);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+        });
+    });
+});

package/commands/__tests__/list.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/list.test.js

@@ -0,0 +1,42 @@
+import yargs from 'yargs';
+import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../lib/commonOpts.js';
+import listCommand from '../list.js';
+vi.mock('../../lib/commonOpts');
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+describe('commands/list', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(listCommand.command).toEqual(['list [path]', 'ls [path]']);
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(listCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct positional arguments', () => {
+            listCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledWith('path', expect.objectContaining({ type: 'string' }));
+        });
+        it('should support the correct options', () => {
+            listCommand.builder(yargs);
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should provide examples', () => {
+            listCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/commands/__tests__/logs.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/logs.test.js

@@ -0,0 +1,71 @@
+import yargs from 'yargs';
+import { addConfigOptions, addAccountOptions, addUseEnvironmentOptions, } from '../../lib/commonOpts.js';
+vi.mock('../../lib/commonOpts');
+const optionsSpy = vi
+    .spyOn(yargs, 'options')
+    .mockReturnValue(yargs);
+const conflictsSpy = vi
+    .spyOn(yargs, 'conflicts')
+    .mockReturnValue(yargs);
+const exampleSpy = vi
+    .spyOn(yargs, 'example')
+    .mockReturnValue(yargs);
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+// Import this last so mocks apply
+import logsCommand from '../logs.js';
+describe('commands/logs', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(logsCommand.command).toEqual('logs [endpoint]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(logsCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct positional arguments', () => {
+            logsCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledTimes(1);
+            expect(positionalSpy).toHaveBeenCalledWith('endpoint', expect.objectContaining({ type: 'string' }));
+        });
+        it('should support the correct options', () => {
+            logsCommand.builder(yargs);
+            expect(optionsSpy).toHaveBeenCalledTimes(1);
+            expect(optionsSpy).toHaveBeenCalledWith({
+                latest: expect.objectContaining({
+                    alias: 'l',
+                    type: 'boolean',
+                }),
+                compact: expect.objectContaining({
+                    type: 'boolean',
+                }),
+                follow: expect.objectContaining({
+                    alias: ['f'],
+                    type: 'boolean',
+                }),
+                limit: expect.objectContaining({
+                    type: 'number',
+                }),
+            });
+            expect(addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should set the correct conflicts', () => {
+            logsCommand.builder(yargs);
+            expect(conflictsSpy).toHaveBeenCalledTimes(1);
+            expect(conflictsSpy).toHaveBeenCalledWith('follow', 'limit');
+        });
+        it('should provide examples', () => {
+            logsCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/commands/__tests__/mcp.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/mcp.test.js

@@ -0,0 +1,46 @@
+import yargs from 'yargs';
+import startCommand from '../mcp/start.js';
+import setupCommand from '../mcp/setup.js';
+import mcpCommand from '../mcp.js';
+vi.mock('../mcp/start');
+vi.mock('../mcp/setup');
+vi.mock('../../lib/commonOpts');
+const commandSpy = vi
+    .spyOn(yargs, 'command')
+    .mockReturnValue(yargs);
+const demandCommandSpy = vi
+    .spyOn(yargs, 'demandCommand')
+    .mockReturnValue(yargs);
+describe('commands/mcp', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(mcpCommand.command).toEqual('mcp');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(mcpCommand.describe).toBeUndefined();
+        });
+    });
+    describe('builder', () => {
+        beforeEach(() => {
+            commandSpy.mockClear();
+            demandCommandSpy.mockClear();
+        });
+        const subcommands = [startCommand, setupCommand];
+        it('should demand the command takes one positional argument', () => {
+            mcpCommand.builder(yargs);
+            expect(demandCommandSpy).toHaveBeenCalledTimes(1);
+            expect(demandCommandSpy).toHaveBeenCalledWith(1, '');
+        });
+        it('should add the correct number of sub commands', () => {
+            mcpCommand.builder(yargs);
+            expect(commandSpy).toHaveBeenCalledTimes(subcommands.length);
+        });
+        it.each(subcommands)('should attach the %s subcommand', module => {
+            mcpCommand.builder(yargs);
+            expect(module).toBeDefined();
+            expect(commandSpy).toHaveBeenCalledWith(module);
+        });
+    });
+});

package/commands/__tests__/mv.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/mv.test.js

@@ -0,0 +1,46 @@
+import yargs from 'yargs';
+import * as commonOpts from '../../lib/commonOpts.js';
+import mvCommand from '../mv.js';
+vi.mock('../../lib/commonOpts');
+const positionalSpy = vi
+    .spyOn(yargs, 'positional')
+    .mockReturnValue(yargs);
+describe('commands/mv', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(mvCommand.command).toBe('mv <srcPath> <destPath>');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(mvCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            mvCommand.builder(yargs);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should add the srcPath positional argument', () => {
+            mvCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('srcPath', {
+                describe: 'Remote hubspot path',
+                type: 'string',
+            });
+        });
+        it('should add the destPath positional argument', () => {
+            mvCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('destPath', {
+                describe: 'Remote hubspot path',
+                type: 'string',
+            });
+        });
+    });
+});

package/commands/__tests__/open.test.d.ts

@@ -0,0 +1 @@
+export {};

package/commands/__tests__/open.test.js

@@ -0,0 +1,58 @@
+import yargs from 'yargs';
+import openCommand from '../open.js';
+import * as commonOpts from '../../lib/commonOpts.js';
+vi.mock('../../lib/commonOpts');
+// Spies are now safe to create since the methods exist on the mock
+const positionalSpy = vi.spyOn(mockYargs, 'positional');
+const optionSpy = vi.spyOn(mockYargs, 'option');
+const exampleSpy = vi.spyOn(mockYargs, 'example');
+describe('commands/open', () => {
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(openCommand.command).toBe('open [shortcut]');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(openCommand.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            openCommand.builder(yargs);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addConfigOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addAccountOptions).toHaveBeenCalledWith(yargs);
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalledWith(yargs);
+        });
+        it('should add the shortcut positional argument', () => {
+            openCommand.builder(yargs);
+            expect(positionalSpy).toHaveBeenCalledWith('[shortcut]', {
+                describe: expect.any(String),
+                type: 'string',
+            });
+        });
+        it('should add the list option', () => {
+            openCommand.builder(yargs);
+            expect(optionSpy).toHaveBeenCalledWith('list', {
+                alias: 'l',
+                describe: expect.any(String),
+                type: 'boolean',
+            });
+        });
+        it('should add examples', () => {
+            openCommand.builder(yargs);
+            expect(exampleSpy).toHaveBeenCalledWith([
+                ['$0 open'],
+                ['$0 open --list'],
+                ['$0 open settings'],
+                ['$0 open settings/navigation'],
+                ['$0 open sn'],
+            ]);
+        });
+    });
+});

package/commands/__tests__/project.test.d.ts

@@ -0,0 +1 @@
+export {};