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

package/lib/__tests__/usageTracking.test.js

@@ -0,0 +1,170 @@
+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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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.mockRejectedValue(error);
+            await trackCommandUsage(mockCommand);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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,
+            }));
+        });
+        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,
+            }));
+        });
+    });
+    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);
+            // Allow setImmediate to execute
+            await new Promise(resolve => setImmediate(resolve));
+            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' }));
+        });
+        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' }));
+        });
+        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' }));
+        });
+    });
+});

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,39 @@
+import { hasFlag, makeYargsBuilder } from '../yargsUtils.js';
+import * as commonOpts from '../commonOpts.js';
+vi.mock('../commonOpts');
+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();
+        });
+    });
+});

package/lib/accountTypes.js

@@ -1,54 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isStandardAccount = isStandardAccount;
-exports.isSandbox = isSandbox;
-exports.isStandardSandbox = isStandardSandbox;
-exports.isDevelopmentSandbox = isDevelopmentSandbox;
-exports.isDeveloperTestAccount = isDeveloperTestAccount;
-exports.isAppDeveloperAccount = isAppDeveloperAccount;
-exports.isTestAccountOrSandbox = isTestAccountOrSandbox;
-exports.isUnifiedAccount = isUnifiedAccount;
-const config_1 = require("@hubspot/local-dev-lib/constants/config");
-const hasFeature_1 = require("./hasFeature");
-const constants_1 = require("./constants");
-const getAccountIdentifier_1 = require("@hubspot/local-dev-lib/config/getAccountIdentifier");
+import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
+import { hasFeature } from './hasFeature.js';
+import { FEATURES } from './constants.js';
+import { getAccountIdentifier } from '@hubspot/local-dev-lib/config/getAccountIdentifier';
 function isAccountType(accountConfig, accountType) {
     return Boolean(accountConfig.accountType && accountType.includes(accountConfig.accountType));
 }
-function isStandardAccount(accountConfig) {
-    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD]);
+export function isStandardAccount(accountConfig) {
+    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.STANDARD]);
 }
-function isSandbox(accountConfig) {
+export function isSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-function isStandardSandbox(accountConfig) {
-    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]);
+export function isStandardSandbox(accountConfig) {
+    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]);
 }
-function isDevelopmentSandbox(accountConfig) {
+export function isDevelopmentSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-function isDeveloperTestAccount(accountConfig) {
-    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]);
+export function isDeveloperTestAccount(accountConfig) {
+    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]);
 }
-function isAppDeveloperAccount(accountConfig) {
-    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER]);
+export function isAppDeveloperAccount(accountConfig) {
+    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER]);
 }
-function isTestAccountOrSandbox(accountConfig) {
+export function isTestAccountOrSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
-        config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-async function isUnifiedAccount(account) {
-    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(account);
+export async function isUnifiedAccount(account) {
+    const accountId = getAccountIdentifier(account);
     if (!accountId) {
         return false;
     }
-    return (0, hasFeature_1.hasFeature)(accountId, constants_1.FEATURES.UNIFIED_APPS);
+    return hasFeature(accountId, FEATURES.UNIFIED_APPS);
 }

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

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