@hubspot/cli 8.0.10-experimental.7 → 8.0.11-experimental.0

package/lib/__tests__/usageTracking.test.js

@@ -0,0 +1,197 @@
+import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
+import { getConfig, getConfigAccountById } from '@hubspot/local-dev-lib/config';
+import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { uiLogger } from '../ui/logger.js';
+import { trackCommandUsage, trackHelpUsage, trackConvertFieldsUsage, trackAuthAction, trackCommandMetadataUsage, } from '../usageTracking.js';
+import { pkg } from '../jsonLoader.js';
+const version = pkg.version;
+// Unmock the usageTracking module for this test file
+vi.unmock('../usageTracking.js');
+vi.mock('@hubspot/local-dev-lib/trackUsage');
+vi.mock('@hubspot/local-dev-lib/config');
+const mockedTrackUsage = trackUsage;
+const mockedGetConfig = getConfig;
+const mockedGetConfigAccountById = getConfigAccountById;
+const mockedUiLogger = uiLogger;
+describe('lib/usageTracking', () => {
+    const mockPlatform = 'darwin';
+    const mockNodeVersion = 'v16.14.0';
+    beforeEach(() => {
+        mockedGetConfig.mockReturnValue({ allowUsageTracking: true });
+        Object.defineProperty(process, 'platform', { value: mockPlatform });
+        Object.defineProperty(process, 'version', { value: mockNodeVersion });
+        delete process.env.DISABLE_USAGE_TRACKING;
+    });
+    afterEach(() => {
+        delete process.env.DISABLE_USAGE_TRACKING;
+    });
+    describe('trackCommandUsage()', () => {
+        const mockCommand = 'test-command';
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled via config', async () => {
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
+            await trackCommandUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should not track when --disable-usage-tracking flag is set', async () => {
+            process.env.DISABLE_USAGE_TRACKING = 'true';
+            await trackCommandUsage(mockCommand, {}, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
+        });
+        it('should track command usage with default auth type', async () => {
+            await trackCommandUsage(mockCommand, {}, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-command',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version,
+                authType: API_KEY_AUTH_METHOD.value,
+            }), mockAccountId);
+        });
+        it('should track command usage with custom auth type', async () => {
+            mockedGetConfigAccountById.mockReturnValue({ authType: 'oauth2' });
+            await trackCommandUsage(mockCommand, {}, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                authType: 'oauth2',
+            }), mockAccountId);
+        });
+        it('should handle tracking errors gracefully', async () => {
+            const error = new Error('Tracking failed');
+            mockedTrackUsage.mockImplementationOnce(() => {
+                throw error;
+            });
+            await trackCommandUsage(mockCommand);
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
+        });
+    });
+    describe('trackHelpUsage()', () => {
+        const mockCommand = 'help-command';
+        it('should not track when tracking is disabled via config', async () => {
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
+            await trackHelpUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should not track when --disable-usage-tracking flag is set', async () => {
+            process.env.DISABLE_USAGE_TRACKING = 'true';
+            await trackHelpUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
+        });
+        it('should track help usage with command', async () => {
+            await trackHelpUsage(mockCommand);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-help',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version,
+            }), undefined);
+        });
+        it('should track main help usage without command', async () => {
+            await trackHelpUsage('');
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
+        });
+    });
+    describe('trackConvertFieldsUsage()', () => {
+        const mockCommand = 'convert-fields-command';
+        it('should not track when tracking is disabled via config', async () => {
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
+            await trackConvertFieldsUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should not track when --disable-usage-tracking flag is set', async () => {
+            process.env.DISABLE_USAGE_TRACKING = 'true';
+            await trackConvertFieldsUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track convert fields usage', async () => {
+            await trackConvertFieldsUsage(mockCommand);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-process-fields',
+                command: mockCommand,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version,
+            }), undefined);
+        });
+    });
+    describe('trackAuthAction()', () => {
+        const mockCommand = 'auth-command';
+        const mockAuthType = 'oauth2';
+        const mockStep = 'init';
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled via config', async () => {
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
+            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should not track when --disable-usage-tracking flag is set', async () => {
+            process.env.DISABLE_USAGE_TRACKING = 'true';
+            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should track auth action', async () => {
+            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-auth',
+                command: mockCommand,
+                authType: mockAuthType,
+                step: mockStep,
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version,
+            }), mockAccountId);
+        });
+    });
+    describe('trackCommandMetadataUsage()', () => {
+        const mockCommand = 'metadata-command';
+        const mockMeta = { assetType: 'test-asset' };
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled via config', async () => {
+            mockedGetConfig.mockReturnValue({ allowUsageTracking: false });
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        it('should not track when --disable-usage-tracking flag is set', async () => {
+            process.env.DISABLE_USAGE_TRACKING = 'true';
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+            expect(mockedUiLogger.debug).toHaveBeenCalledWith('Usage tracking is disabled via the --disable-usage-tracking flag, not sending usage events');
+        });
+        it('should track command metadata usage', async () => {
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
+                action: 'cli-command-metadata',
+                command: mockCommand,
+                assetType: 'test-asset',
+                os: 'macos',
+                nodeVersion: mockNodeVersion,
+                nodeMajorVersion: 'v16',
+                version,
+            }), mockAccountId);
+        });
+    });
+    describe('Platform detection', () => {
+        it('should return "macos" for darwin platform', async () => {
+            Object.defineProperty(process, 'platform', { value: 'darwin' });
+            await trackHelpUsage('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'macos' }), undefined);
+        });
+        it('should return "windows" for win32 platform', async () => {
+            Object.defineProperty(process, 'platform', { value: 'win32' });
+            await trackHelpUsage('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'windows' }), undefined);
+        });
+        it('should return platform name for other platforms', async () => {
+            Object.defineProperty(process, 'platform', { value: 'linux' });
+            await trackHelpUsage('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'linux' }), undefined);
+        });
+    });
+});

package/lib/__tests__/validation.test.d.ts

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

package/lib/__tests__/validation.test.js

@@ -0,0 +1,143 @@
+import { getConfigAccountById, getConfigAccountIfExists, } from '@hubspot/local-dev-lib/config';
+import { getOauthManager } from '@hubspot/local-dev-lib/oauth';
+import { accessTokenForPersonalAccessKey } from '@hubspot/local-dev-lib/personalAccessKey';
+import { validateAccount } from '../validation.js';
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('../errorHandlers/index.js');
+vi.mock('@hubspot/local-dev-lib/oauth');
+vi.mock('@hubspot/local-dev-lib/personalAccessKey');
+vi.mock('../commonOpts');
+const yargsOption = (option) => ({
+    $0: '',
+    _: [''],
+    ...option,
+});
+describe('lib/validation', () => {
+    const getConfigAccountIfExistsMock = getConfigAccountIfExists;
+    const getConfigAccountByIdMock = getConfigAccountById;
+    const getOauthManagerMock = getOauthManager;
+    const accessTokenForPersonalAccessKeyMock = accessTokenForPersonalAccessKey;
+    describe('validateAccount', () => {
+        it('returns false if an account is missing', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce(null);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns false if an account config is missing', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce(undefined);
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns false for oauth2 authType if auth is missing', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns false if OAuth is missing configuration', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                },
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns false if an access token was not retrieved', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return null;
+                },
+            });
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns false if an getting an access token throws', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    throw new Error('It failed');
+                },
+            });
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns true if OAuth is configured and an access token is received', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return 'yep';
+                },
+            });
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
+        });
+        it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                throw new Error('It failed');
+            });
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(false);
+        });
+        it('returns true if "personalaccesskey" configured and an access token is received', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                return 'secret-stuff';
+            });
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
+        });
+        it('returns true if apiKey is configured and present', async () => {
+            getConfigAccountIfExistsMock.mockReturnValueOnce('123');
+            getConfigAccountByIdMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'apikey',
+                apiKey: 'my-secret-key',
+            });
+            expect(await validateAccount(yargsOption({ derivedAccountId: '123' }))).toBe(true);
+        });
+    });
+});

package/lib/__tests__/yargsUtils.test.d.ts

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

package/lib/__tests__/yargsUtils.test.js

@@ -0,0 +1,124 @@
+import { hasFlag, makeYargsBuilder, strictEnforceBoolean, } from '../yargsUtils.js';
+import * as commonOpts from '../commonOpts.js';
+vi.mock('../commonOpts');
+vi.mock('../../lang/en.js', () => ({
+    commands: {
+        config: {
+            subcommands: {
+                set: {
+                    errors: {
+                        invalidBoolean: (option, value) => `Invalid boolean value "${value}" for --${option}. Valid values are: true, false`,
+                    },
+                },
+            },
+        },
+    },
+}));
+const argvWithFlag = ['hs', 'command', '--test'];
+const argvWithoutFlag = ['hs', 'command'];
+describe('lib/yargsUtils', () => {
+    describe('hasFlag()', () => {
+        it('should return true if the flag is present', () => {
+            const flag = hasFlag('test', argvWithFlag);
+            expect(flag).toBe(true);
+        });
+        it('should return false if argv is an empty array', () => {
+            const flag = hasFlag('test', []);
+            expect(flag).toBe(false);
+        });
+        it('should return false if the flag is not present', () => {
+            const flag = hasFlag('test', argvWithoutFlag);
+            expect(flag).toBe(false);
+        });
+    });
+    describe('makeYargsBuilder()', () => {
+        it('should add specified options', async () => {
+            const builder = makeYargsBuilder(yargs => yargs, 'command', 'describe', {
+                useAccountOptions: true,
+                useConfigOptions: true,
+                useEnvironmentOptions: true,
+                useTestingOptions: true,
+                useGlobalOptions: true,
+            });
+            await builder({});
+            expect(commonOpts.addGlobalOptions).toHaveBeenCalled();
+            expect(commonOpts.addAccountOptions).toHaveBeenCalled();
+            expect(commonOpts.addConfigOptions).toHaveBeenCalled();
+            expect(commonOpts.addUseEnvironmentOptions).toHaveBeenCalled();
+            expect(commonOpts.addTestingOptions).toHaveBeenCalled();
+            expect(commonOpts.addCustomHelpOutput).toHaveBeenCalled();
+        });
+    });
+    describe('strictEnforceBoolean()', () => {
+        it('should validate valid boolean values (true/false, case-insensitive)', () => {
+            const validArgs = [
+                ['hs', 'config', 'set', '--allow-usage-tracking=true'],
+                ['hs', 'config', 'set', '--allow-usage-tracking=false'],
+                ['hs', 'config', 'set', '--allow-usage-tracking=TRUE'],
+                ['hs', 'config', 'set', '--allow-usage-tracking=False'],
+            ];
+            validArgs.forEach(args => {
+                expect(() => strictEnforceBoolean(args, ['allow-usage-tracking'])).not.toThrow();
+                expect(strictEnforceBoolean(args, ['allow-usage-tracking'])).toBe(true);
+            });
+        });
+        it('should reject invalid boolean values with descriptive error messages', () => {
+            const invalidCases = [
+                {
+                    args: ['hs', 'config', 'set', '--allow-usage-tracking=yes'],
+                    value: 'yes',
+                },
+                {
+                    args: ['hs', 'config', 'set', '--allow-usage-tracking=1'],
+                    value: '1',
+                },
+                {
+                    args: ['hs', 'config', 'set', '--auto-open-browser=maybe'],
+                    value: 'maybe',
+                },
+            ];
+            invalidCases.forEach(({ args, value }) => {
+                const option = args[3].split('=')[0].replace('--', '');
+                expect(() => strictEnforceBoolean(args, [option])).toThrow(`Invalid boolean value "${value}" for --${option}. Valid values are: true, false`);
+            });
+        });
+        it('should support multiple config values in a single command', () => {
+            const args = [
+                'hs',
+                'config',
+                'set',
+                '--allow-usage-tracking=true',
+                '--auto-open-browser=false',
+                '--allow-auto-updates=true',
+                '--http-timeout=5000',
+                '--default-cms-publish-mode=draft',
+            ];
+            const booleanOptions = [
+                'allow-usage-tracking',
+                'auto-open-browser',
+                'allow-auto-updates',
+            ];
+            expect(() => strictEnforceBoolean(args, booleanOptions)).not.toThrow();
+            expect(strictEnforceBoolean(args, booleanOptions)).toBe(true);
+        });
+        it('should error when one of multiple values is invalid', () => {
+            const args = [
+                'hs',
+                'config',
+                'set',
+                '--allow-usage-tracking=true',
+                '--auto-open-browser=invalid',
+                '--http-timeout=5000',
+            ];
+            const booleanOptions = ['allow-usage-tracking', 'auto-open-browser'];
+            expect(() => strictEnforceBoolean(args, booleanOptions)).toThrow('Invalid boolean value "invalid" for --auto-open-browser. Valid values are: true, false');
+        });
+        it('should maintain backwards compatability', () => {
+            expect(() => strictEnforceBoolean(['hs', 'config', 'set', '--allow-usage-tracking=true'], ['allow-usage-tracking'])).not.toThrow();
+            // No values provided (interactive mode)
+            expect(() => strictEnforceBoolean(['hs', 'config', 'set'], ['allow-usage-tracking'])).not.toThrow();
+            // Flag without equals sign (succeed with true)
+            expect(() => strictEnforceBoolean(['hs', 'config', 'set', '--allow-usage-tracking'], ['allow-usage-tracking'])).not.toThrow();
+        });
+    });
+});

package/lib/app/__tests__/migrate.test.d.ts

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