@hubspot/cli 7.7.21-experimental.1 → 7.7.23-experimental.0

package/lib/__tests__/usageTracking.test.js

@@ -1,18 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const trackUsage_1 = require("@hubspot/local-dev-lib/trackUsage");
-const config_1 = require("@hubspot/local-dev-lib/config");
-const auth_1 = require("@hubspot/local-dev-lib/constants/auth");
-const logger_1 = require("@hubspot/local-dev-lib/logger");
-const usageTracking_1 = require("../usageTracking");
-const package_json_1 = require("../../package.json");
+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_1.trackUsage;
-const mockedIsTrackingAllowed = config_1.isTrackingAllowed;
-const mockedGetAccountConfig = config_1.getAccountConfig;
-const mockedLogger = logger_1.logger;
+const mockedTrackUsage = trackUsage;
+const mockedIsTrackingAllowed = isTrackingAllowed;
+const mockedGetAccountConfig = getAccountConfig;
+const mockedLogger = logger;
 describe('lib/usageTracking', () => {
     const mockPlatform = 'darwin';
     const mockNodeVersion = 'v16.14.0';
@@ -26,24 +25,24 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
+            await trackCommandUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track command usage with default auth type', async () => {
-            await (0, usageTracking_1.trackCommandUsage)(mockCommand, {}, mockAccountId);
+            await trackCommandUsage(mockCommand, {}, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-command',
                 command: mockCommand,
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version: package_json_1.version,
-                authType: auth_1.API_KEY_AUTH_METHOD.value,
+                version,
+                authType: API_KEY_AUTH_METHOD.value,
             }), mockAccountId);
         });
         it('should track command usage with custom auth type', async () => {
             mockedGetAccountConfig.mockReturnValue({ authType: 'oauth2' });
-            await (0, usageTracking_1.trackCommandUsage)(mockCommand, {}, mockAccountId);
+            await trackCommandUsage(mockCommand, {}, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 authType: 'oauth2',
             }), mockAccountId);
@@ -53,7 +52,7 @@ describe('lib/usageTracking', () => {
             mockedTrackUsage.mockImplementationOnce(() => {
                 throw error;
             });
-            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
+            await trackCommandUsage(mockCommand);
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
         });
     });
@@ -61,22 +60,22 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'help-command';
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
+            await trackHelpUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track help usage with command', async () => {
-            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
+            await trackHelpUsage(mockCommand);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-help',
                 command: mockCommand,
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version: package_json_1.version,
+                version,
             }), undefined);
         });
         it('should track main help usage without command', async () => {
-            await (0, usageTracking_1.trackHelpUsage)('');
+            await trackHelpUsage('');
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
         });
     });
@@ -84,18 +83,18 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'convert-fields-command';
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
+            await trackConvertFieldsUsage(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track convert fields usage', async () => {
-            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
+            await trackConvertFieldsUsage(mockCommand);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-process-fields',
                 command: mockCommand,
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version: package_json_1.version,
+                version,
             }), undefined);
         });
     });
@@ -106,11 +105,11 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
+            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track auth action', async () => {
-            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
+            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-auth',
                 command: mockCommand,
@@ -119,7 +118,7 @@ describe('lib/usageTracking', () => {
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version: package_json_1.version,
+                version,
             }), mockAccountId);
         });
     });
@@ -129,11 +128,11 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await (0, usageTracking_1.trackCommandMetadataUsage)(mockCommand, mockMeta, mockAccountId);
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track command metadata usage', async () => {
-            await (0, usageTracking_1.trackCommandMetadataUsage)(mockCommand, mockMeta, mockAccountId);
+            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-command-metadata',
                 command: mockCommand,
@@ -141,24 +140,24 @@ describe('lib/usageTracking', () => {
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version: package_json_1.version,
+                version,
             }), mockAccountId);
         });
     });
     describe('Platform detection', () => {
         it('should return "macos" for darwin platform', async () => {
             Object.defineProperty(process, 'platform', { value: 'darwin' });
-            await (0, usageTracking_1.trackHelpUsage)('test');
+            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 (0, usageTracking_1.trackHelpUsage)('test');
+            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 (0, usageTracking_1.trackHelpUsage)('test');
+            await trackHelpUsage('test');
             expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'linux' }), undefined);
         });
     });

package/lib/__tests__/validation.test.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const config_1 = require("@hubspot/local-dev-lib/config");
-const oauth_1 = require("@hubspot/local-dev-lib/oauth");
-const personalAccessKey_1 = require("@hubspot/local-dev-lib/personalAccessKey");
-const validation_1 = require("../validation");
+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');
@@ -15,19 +13,19 @@ const yargsOption = (option) => ({
     ...option,
 });
 describe('lib/validation', () => {
-    const getAccountIdMock = config_1.getAccountId;
-    const getAccountConfigMock = config_1.getAccountConfig;
-    const getOauthManagerMock = oauth_1.getOauthManager;
-    const accessTokenForPersonalAccessKeyMock = personalAccessKey_1.accessTokenForPersonalAccessKey;
+    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 (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            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 (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
         });
         it('returns false for oauth2 authType if auth is missing', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -35,7 +33,7 @@ describe('lib/validation', () => {
                 accountId: '123',
                 authType: 'oauth2',
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
         });
         it('returns false if OAuth is missing configuration', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -46,7 +44,7 @@ describe('lib/validation', () => {
                     clientId: 'foo',
                 },
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
         });
         it('returns false if an access token was not retrieved', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -66,7 +64,7 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
         });
         it('returns false if an getting an access token throws', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -86,7 +84,7 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            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');
@@ -106,7 +104,7 @@ describe('lib/validation', () => {
                     },
                 },
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
         });
         it('returns false if "personalaccesskey" configured and getting an access token throws', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -118,7 +116,7 @@ describe('lib/validation', () => {
                 authType: 'personalaccesskey',
                 personalAccessKey: 'foo',
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(false);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(false);
         });
         it('returns true if "personalaccesskey" configured and an access token is received', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -130,7 +128,7 @@ describe('lib/validation', () => {
                 authType: 'personalaccesskey',
                 personalAccessKey: 'foo',
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
         });
         it('returns true if apiKey is configured and present', async () => {
             getAccountIdMock.mockReturnValueOnce('123');
@@ -139,7 +137,7 @@ describe('lib/validation', () => {
                 authType: 'apikey',
                 apiKey: 'my-secret-key',
             });
-            expect(await (0, validation_1.validateAccount)(yargsOption({ account: '123' }))).toBe(true);
+            expect(await validateAccount(yargsOption({ account: '123' }))).toBe(true);
         });
     });
 });

package/lib/__tests__/yargsUtils.test.js

@@ -1,61 +1,26 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const yargsUtils_1 = require("../yargsUtils");
-const commonOpts = __importStar(require("../commonOpts"));
+import { hasFlag, makeYargsBuilder, getExclusiveConflicts, } 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 = (0, yargsUtils_1.hasFlag)('test', argvWithFlag);
+            const flag = hasFlag('test', argvWithFlag);
             expect(flag).toBe(true);
         });
         it('should return false if argv is an empty array', () => {
-            const flag = (0, yargsUtils_1.hasFlag)('test', []);
+            const flag = hasFlag('test', []);
             expect(flag).toBe(false);
         });
         it('should return false if the flag is not present', () => {
-            const flag = (0, yargsUtils_1.hasFlag)('test', argvWithoutFlag);
+            const flag = hasFlag('test', argvWithoutFlag);
             expect(flag).toBe(false);
         });
     });
     describe('makeYargsBuilder()', () => {
         it('should add specified options', async () => {
-            const builder = (0, yargsUtils_1.makeYargsBuilder)(yargs => yargs, 'command', 'describe', {
+            const builder = makeYargsBuilder(yargs => yargs, 'command', 'describe', {
                 useAccountOptions: true,
                 useConfigOptions: true,
                 useEnvironmentOptions: true,
@@ -71,4 +36,15 @@ describe('lib/yargsUtils', () => {
             expect(commonOpts.addCustomHelpOutput).toHaveBeenCalled();
         });
     });
+    describe('getExclusiveConflicts()', () => {
+        it('should return an object where each option conflicts with all others', () => {
+            const options = ['option1', 'option2', 'option3'];
+            const result = getExclusiveConflicts(options);
+            expect(result).toEqual({
+                option1: ['option2', 'option3'],
+                option2: ['option1', 'option3'],
+                option3: ['option1', 'option2'],
+            });
+        });
+    });
 });

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);
 }