@hubspot/cli 7.7.0-experimental.2 → 7.7.0

package/lib/__tests__/serverlessLogs.test.js

@@ -0,0 +1,149 @@
+import mockStdIn from 'mock-stdin';
+import { outputLogs } from '../ui/serverlessFunctionLogs.js';
+import { tailLogs } from '../serverlessLogs.js';
+vi.mock('../ui/serverlessFunctionLogs');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('../ui/SpinniesManager', () => ({
+    default: {
+        init: vi.fn(),
+        add: vi.fn(),
+        remove: vi.fn(),
+        succeed: vi.fn(),
+        fail: vi.fn(),
+        stopAll: vi.fn(),
+    },
+}));
+vi.useFakeTimers();
+const ACCOUNT_ID = 123;
+describe('lib/serverlessLogs', () => {
+    describe('tailLogs()', () => {
+        let stdinMock;
+        beforeEach(() => {
+            // @ts-ignore - we don't need to mock the entire process object
+            vi.spyOn(process, 'exit').mockImplementation(() => { });
+            stdinMock = mockStdIn.stdin();
+        });
+        afterEach(() => {
+            vi.clearAllTimers();
+            stdinMock.restore();
+        });
+        it('calls tailCall() to get the next results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [] },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            const tailCall = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        results: [],
+                        paging: {
+                            next: {
+                                after: 'somehash',
+                            },
+                        },
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(fetchLatest).toHaveBeenCalled();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('outputs results', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.resolve({
+                    data: {
+                        id: '1234',
+                        executionTime: 510,
+                        log: 'Log message',
+                        error: { message: '', type: '', stackTrace: [], statusCode: null },
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    status: 200,
+                    statusText: 'OK',
+                    headers: {},
+                    config: {},
+                });
+            });
+            const latestLogResponse = {
+                results: [
+                    {
+                        id: '456',
+                        executionTime: 510,
+                        log: 'Message 1',
+                        error: null,
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                    {
+                        id: '457',
+                        executionTime: 510,
+                        log: 'Message 2',
+                        error: null,
+                        status: 'SUCCESS',
+                        createdAt: 1620232011451,
+                        memory: '70/128 MB',
+                        duration: '53.40 ms',
+                    },
+                ],
+                paging: {
+                    next: {
+                        after: 'somehash',
+                    },
+                },
+            };
+            const tailCall = vi.fn(() => Promise.resolve({ data: latestLogResponse }));
+            // @ts-ignore - headers is not used in the actual function and does not need to be mocked
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(outputLogs).toHaveBeenCalledWith(latestLogResponse, expect.objectContaining({ compact }));
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+        it('handles no logs', async () => {
+            const compact = false;
+            const fetchLatest = vi.fn(() => {
+                return Promise.reject({
+                    message: '',
+                    type: '',
+                    stackTrace: [],
+                    statusCode: 404,
+                });
+            });
+            const tailCall = vi.fn(() => Promise.reject({
+                message: '',
+                type: '',
+                stackTrace: [],
+                statusCode: 404,
+            }));
+            await tailLogs(ACCOUNT_ID, 'name', fetchLatest, tailCall, compact);
+            vi.runOnlyPendingTimers();
+            expect(tailCall).toHaveBeenCalledTimes(2);
+        });
+    });
+});

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

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

package/lib/__tests__/usageTracking.test.js

@@ -0,0 +1,164 @@
+import { trackUsage } from '@hubspot/local-dev-lib/trackUsage';
+import { isTrackingAllowed, getAccountConfig, } from '@hubspot/local-dev-lib/config';
+import { API_KEY_AUTH_METHOD } from '@hubspot/local-dev-lib/constants/auth';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { trackCommandUsage, trackHelpUsage, trackConvertFieldsUsage, trackAuthAction, trackCommandMetadataUsage, } from '../usageTracking.js';
+import packageJson from '../../package.json' with { type: 'json' };
+const version = packageJson.version;
+vi.mock('@hubspot/local-dev-lib/trackUsage');
+vi.mock('@hubspot/local-dev-lib/config');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedTrackUsage = trackUsage;
+const mockedIsTrackingAllowed = isTrackingAllowed;
+const mockedGetAccountConfig = getAccountConfig;
+const mockedLogger = logger;
+describe('lib/usageTracking', () => {
+    const mockPlatform = 'darwin';
+    const mockNodeVersion = 'v16.14.0';
+    beforeEach(() => {
+        mockedIsTrackingAllowed.mockReturnValue(true);
+        Object.defineProperty(process, 'platform', { value: mockPlatform });
+        Object.defineProperty(process, 'version', { value: mockNodeVersion });
+    });
+    describe('trackCommandUsage()', () => {
+        const mockCommand = 'test-command';
+        const mockAccountId = 123;
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await trackCommandUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        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 () => {
+            mockedGetAccountConfig.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(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
+        });
+    });
+    describe('trackHelpUsage()', () => {
+        const mockCommand = 'help-command';
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await trackHelpUsage(mockCommand);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        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(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
+        });
+    });
+    describe('trackConvertFieldsUsage()', () => {
+        const mockCommand = 'convert-fields-command';
+        it('should not track when tracking is disabled', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            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', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            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', async () => {
+            mockedIsTrackingAllowed.mockReturnValue(false);
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
+            expect(mockedTrackUsage).not.toHaveBeenCalled();
+        });
+        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 { getAccountId, getAccountConfig } 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('@hubspot/local-dev-lib/logger');
+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 getAccountIdMock = getAccountId;
+    const getAccountConfigMock = getAccountConfig;
+    const getOauthManagerMock = getOauthManager;
+    const accessTokenForPersonalAccessKeyMock = accessTokenForPersonalAccessKey;
+    describe('validateAccount', () => {
+        it('returns false if an account is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce(null);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an account config is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce(undefined);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false for oauth2 authType if auth is missing', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if OAuth is missing configuration', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                },
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an access token was not retrieved', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return null;
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns false if an getting an access token throws', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    throw new Error('It failed');
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns true if OAuth is configured and an access token is received', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getOauthManagerMock.mockReturnValueOnce({
+                accessToken() {
+                    return 'yep';
+                },
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'oauth2',
+                auth: {
+                    clientId: 'foo',
+                    clientSecret: 'abc',
+                    tokenInfo: {
+                        refreshToken: 'def',
+                    },
+                },
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
+        });
+        it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                throw new Error('It failed');
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
+        });
+        it('returns true if "personalaccesskey" configured and an access token is received', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            accessTokenForPersonalAccessKeyMock.mockImplementationOnce(() => {
+                return 'secret-stuff';
+            });
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'personalaccesskey',
+                personalAccessKey: 'foo',
+            });
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
+        });
+        it('returns true if apiKey is configured and present', async () => {
+            getAccountIdMock.mockReturnValueOnce('123');
+            getAccountConfigMock.mockReturnValueOnce({
+                accountId: '123',
+                authType: 'apikey',
+                apiKey: 'my-secret-key',
+            });
+            expect(await validateAccount(yargsOption({ account: '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/accountTypes.d.ts

@@ -5,4 +5,5 @@ export declare function isStandardSandbox(accountConfig: CLIAccount): boolean;
 export declare function isDevelopmentSandbox(accountConfig: CLIAccount): boolean;
 export declare function isDeveloperTestAccount(accountConfig: CLIAccount): boolean;
 export declare function isAppDeveloperAccount(accountConfig: CLIAccount): boolean;
+export declare function isTestAccountOrSandbox(accountConfig: CLIAccount): boolean;
 export declare function isUnifiedAccount(account: CLIAccount): Promise<boolean>;