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

package/lib/__tests__/usageTracking.test.js

@@ -1,17 +1,18 @@
-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;
+"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");
 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;
+const mockedTrackUsage = trackUsage_1.trackUsage;
+const mockedIsTrackingAllowed = config_1.isTrackingAllowed;
+const mockedGetAccountConfig = config_1.getAccountConfig;
+const mockedLogger = logger_1.logger;
 describe('lib/usageTracking', () => {
     const mockPlatform = 'darwin';
     const mockNodeVersion = 'v16.14.0';
@@ -25,38 +26,34 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await trackCommandUsage(mockCommand);
+            await (0, usageTracking_1.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));
+            await (0, usageTracking_1.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,
+                version: package_json_1.version,
+                authType: auth_1.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));
+            await (0, usageTracking_1.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.mockRejectedValue(error);
-            await trackCommandUsage(mockCommand);
-            // Allow setImmediate to execute
-            await new Promise(resolve => setImmediate(resolve));
+            mockedTrackUsage.mockImplementationOnce(() => {
+                throw error;
+            });
+            await (0, usageTracking_1.trackCommandUsage)(mockCommand);
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining(error.message));
         });
     });
@@ -64,22 +61,22 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'help-command';
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await trackHelpUsage(mockCommand);
+            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track help usage with command', async () => {
-            await trackHelpUsage(mockCommand);
+            await (0, usageTracking_1.trackHelpUsage)(mockCommand);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-help',
                 command: mockCommand,
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version,
-            }));
+                version: package_json_1.version,
+            }), undefined);
         });
         it('should track main help usage without command', async () => {
-            await trackHelpUsage('');
+            await (0, usageTracking_1.trackHelpUsage)('');
             expect(mockedLogger.debug).toHaveBeenCalledWith(expect.stringContaining('main command'));
         });
     });
@@ -87,19 +84,19 @@ describe('lib/usageTracking', () => {
         const mockCommand = 'convert-fields-command';
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await trackConvertFieldsUsage(mockCommand);
+            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track convert fields usage', async () => {
-            await trackConvertFieldsUsage(mockCommand);
+            await (0, usageTracking_1.trackConvertFieldsUsage)(mockCommand);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-process-fields',
                 command: mockCommand,
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version,
-            }));
+                version: package_json_1.version,
+            }), undefined);
         });
     });
     describe('trackAuthAction()', () => {
@@ -109,11 +106,11 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
+            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).not.toHaveBeenCalled();
         });
         it('should track auth action', async () => {
-            await trackAuthAction(mockCommand, mockAuthType, mockStep, mockAccountId);
+            await (0, usageTracking_1.trackAuthAction)(mockCommand, mockAuthType, mockStep, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-auth',
                 command: mockCommand,
@@ -122,7 +119,7 @@ describe('lib/usageTracking', () => {
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version,
+                version: package_json_1.version,
             }), mockAccountId);
         });
     });
@@ -132,13 +129,11 @@ describe('lib/usageTracking', () => {
         const mockAccountId = 123;
         it('should not track when tracking is disabled', async () => {
             mockedIsTrackingAllowed.mockReturnValue(false);
-            await trackCommandMetadataUsage(mockCommand, mockMeta, mockAccountId);
+            await (0, usageTracking_1.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));
+            await (0, usageTracking_1.trackCommandMetadataUsage)(mockCommand, mockMeta, mockAccountId);
             expect(mockedTrackUsage).toHaveBeenCalledWith('cli-interaction', 'INTERACTION', expect.objectContaining({
                 action: 'cli-command-metadata',
                 command: mockCommand,
@@ -146,25 +141,25 @@ describe('lib/usageTracking', () => {
                 os: 'macos',
                 nodeVersion: mockNodeVersion,
                 nodeMajorVersion: 'v16',
-                version,
+                version: package_json_1.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' }));
+            await (0, usageTracking_1.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' }));
+            await (0, usageTracking_1.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' }));
+            await (0, usageTracking_1.trackHelpUsage)('test');
+            expect(mockedTrackUsage).toHaveBeenCalledWith(expect.anything(), expect.anything(), expect.objectContaining({ os: 'linux' }), undefined);
         });
     });
 });

package/lib/__tests__/validation.test.js

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

package/lib/__tests__/yargsUtils.test.js

@@ -1,26 +1,61 @@
-import { hasFlag, makeYargsBuilder } from '../yargsUtils.js';
-import * as commonOpts from '../commonOpts.js';
+"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"));
 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);
+            const flag = (0, yargsUtils_1.hasFlag)('test', argvWithFlag);
             expect(flag).toBe(true);
         });
         it('should return false if argv is an empty array', () => {
-            const flag = hasFlag('test', []);
+            const flag = (0, yargsUtils_1.hasFlag)('test', []);
             expect(flag).toBe(false);
         });
         it('should return false if the flag is not present', () => {
-            const flag = hasFlag('test', argvWithoutFlag);
+            const flag = (0, yargsUtils_1.hasFlag)('test', argvWithoutFlag);
             expect(flag).toBe(false);
         });
     });
     describe('makeYargsBuilder()', () => {
         it('should add specified options', async () => {
-            const builder = makeYargsBuilder(yargs => yargs, 'command', 'describe', {
+            const builder = (0, yargsUtils_1.makeYargsBuilder)(yargs => yargs, 'command', 'describe', {
                 useAccountOptions: true,
                 useConfigOptions: true,
                 useEnvironmentOptions: true,

package/lib/accountTypes.js

@@ -1,44 +1,54 @@
-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';
+"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");
 function isAccountType(accountConfig, accountType) {
     return Boolean(accountConfig.accountType && accountType.includes(accountConfig.accountType));
 }
-export function isStandardAccount(accountConfig) {
-    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.STANDARD]);
+function isStandardAccount(accountConfig) {
+    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD]);
 }
-export function isSandbox(accountConfig) {
+function isSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-export function isStandardSandbox(accountConfig) {
-    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]);
+function isStandardSandbox(accountConfig) {
+    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX]);
 }
-export function isDevelopmentSandbox(accountConfig) {
+function isDevelopmentSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-export function isDeveloperTestAccount(accountConfig) {
-    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]);
+function isDeveloperTestAccount(accountConfig) {
+    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST]);
 }
-export function isAppDeveloperAccount(accountConfig) {
-    return isAccountType(accountConfig, [HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER]);
+function isAppDeveloperAccount(accountConfig) {
+    return isAccountType(accountConfig, [config_1.HUBSPOT_ACCOUNT_TYPES.APP_DEVELOPER]);
 }
-export function isTestAccountOrSandbox(accountConfig) {
+function isTestAccountOrSandbox(accountConfig) {
     return isAccountType(accountConfig, [
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
-        HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
-        HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
+        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST,
+        config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD_SANDBOX,
+        config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
     ]);
 }
-export async function isUnifiedAccount(account) {
-    const accountId = getAccountIdentifier(account);
+async function isUnifiedAccount(account) {
+    const accountId = (0, getAccountIdentifier_1.getAccountIdentifier)(account);
     if (!accountId) {
         return false;
     }
-    return hasFeature(accountId, FEATURES.UNIFIED_APPS);
+    return (0, hasFeature_1.hasFeature)(accountId, constants_1.FEATURES.UNIFIED_APPS);
 }