@hubspot/cli 7.6.0-beta.4 → 7.6.0-beta.6

package/lib/usageTracking.js

@@ -1,32 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventClass = void 0;
-exports.getNodeVersionData = getNodeVersionData;
-exports.getPlatform = getPlatform;
-exports.trackCommandUsage = trackCommandUsage;
-exports.trackHelpUsage = trackHelpUsage;
-exports.trackConvertFieldsUsage = trackConvertFieldsUsage;
-exports.trackAuthAction = trackAuthAction;
-exports.trackCommandMetadataUsage = trackCommandMetadataUsage;
-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 package_json_1 = require("../package.json");
-const errorHandlers_1 = require("./errorHandlers");
-exports.EventClass = {
+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 packageJson from '../package.json' with { type: 'json' };
+const version = packageJson.version;
+import { debugError } from './errorHandlers/index.js';
+export const EventClass = {
     USAGE: 'USAGE',
     INTERACTION: 'INTERACTION',
     VIEW: 'VIEW',
     ACTIVATION: 'ACTIVATION',
 };
-function getNodeVersionData() {
+export function getNodeVersionData() {
     return {
         nodeVersion: process.version,
         nodeMajorVersion: (process.version || '').split('.')[0],
     };
 }
-function getPlatform() {
+export function getPlatform() {
     switch (process.platform) {
         case 'darwin':
             return 'macos';
@@ -36,18 +27,18 @@ function getPlatform() {
             return process.platform;
     }
 }
-async function trackCommandUsage(command, meta = {}, accountId) {
-    if (!(0, config_1.isTrackingAllowed)()) {
+export async function trackCommandUsage(command, meta = {}, accountId) {
+    if (!isTrackingAllowed()) {
         return;
     }
-    logger_1.logger.debug('Attempting to track usage of "%s" command', command);
+    logger.debug('Attempting to track usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = (0, config_1.getAccountConfig)(accountId);
+        const accountConfig = getAccountConfig(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : auth_1.API_KEY_AUTH_METHOD.value;
+                : API_KEY_AUTH_METHOD.value;
     }
     return trackCliInteraction({
         action: 'cli-command',
@@ -57,28 +48,28 @@ async function trackCommandUsage(command, meta = {}, accountId) {
         accountId,
     });
 }
-async function trackHelpUsage(command) {
-    if (!(0, config_1.isTrackingAllowed)()) {
+export async function trackHelpUsage(command) {
+    if (!isTrackingAllowed()) {
         return;
     }
     if (command) {
-        logger_1.logger.debug('Tracking help usage of "%s" sub-command', command);
+        logger.debug('Tracking help usage of "%s" sub-command', command);
     }
     else {
-        logger_1.logger.debug('Tracking help usage of main command');
+        logger.debug('Tracking help usage of main command');
     }
     return trackCliInteraction({
         action: 'cli-help',
         command,
     });
 }
-async function trackConvertFieldsUsage(command) {
+export async function trackConvertFieldsUsage(command) {
     return trackCliInteraction({
         action: 'cli-process-fields',
         command,
     });
 }
-async function trackAuthAction(command, authType, step, accountId) {
+export async function trackAuthAction(command, authType, step, accountId) {
     return trackCliInteraction({
         action: 'cli-auth',
         command,
@@ -89,18 +80,18 @@ async function trackAuthAction(command, authType, step, accountId) {
         },
     });
 }
-async function trackCommandMetadataUsage(command, meta = {}, accountId) {
-    if (!(0, config_1.isTrackingAllowed)()) {
+export async function trackCommandMetadataUsage(command, meta = {}, accountId) {
+    if (!isTrackingAllowed()) {
         return;
     }
-    logger_1.logger.debug('Attempting to track metadata usage of "%s" command', command);
+    logger.debug('Attempting to track metadata usage of "%s" command', command);
     let authType = 'unknown';
     if (accountId) {
-        const accountConfig = (0, config_1.getAccountConfig)(accountId);
+        const accountConfig = getAccountConfig(accountId);
         authType =
             accountConfig && accountConfig.authType
                 ? accountConfig.authType
-                : auth_1.API_KEY_AUTH_METHOD.value;
+                : API_KEY_AUTH_METHOD.value;
     }
     return trackCliInteraction({
         action: 'cli-command-metadata',
@@ -112,44 +103,44 @@ async function trackCommandMetadataUsage(command, meta = {}, accountId) {
 }
 async function trackCliInteraction({ action, accountId, command, authType, meta = {}, }) {
     try {
-        if (!(0, config_1.isTrackingAllowed)()) {
+        if (!isTrackingAllowed()) {
             return;
         }
         const usageTrackingEvent = {
             action,
             os: getPlatform(),
             ...getNodeVersionData(),
-            version: package_json_1.version,
+            version,
             command,
             authType,
             ...meta,
         };
         if (process.env.HUBSPOT_MCP_AI_AGENT) {
             try {
-                await (0, trackUsage_1.trackUsage)('cli-interaction', exports.EventClass.INTERACTION, {
+                await trackUsage('cli-interaction', EventClass.INTERACTION, {
                     ...usageTrackingEvent,
                     action: 'cli-mcp-server',
                     type: process.env.HUBSPOT_MCP_AI_AGENT,
                 }, accountId);
-                logger_1.logger.debug('Sent AI usage tracking command event: %o', {
+                logger.debug('Sent AI usage tracking command event: %o', {
                     ...usageTrackingEvent,
                     action: 'cli-mcp-server',
                     type: process.env.HUBSPOT_MCP_AI_AGENT,
                 });
             }
             catch (error) {
-                (0, errorHandlers_1.debugError)(error);
+                debugError(error);
             }
         }
         try {
-            return (0, trackUsage_1.trackUsage)('cli-interaction', exports.EventClass.INTERACTION, usageTrackingEvent, accountId);
+            return trackUsage('cli-interaction', EventClass.INTERACTION, usageTrackingEvent, accountId);
         }
         catch (error) {
-            (0, errorHandlers_1.debugError)(error);
+            debugError(error);
         }
-        logger_1.logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
+        logger.debug('Sent usage tracking command event: %o', usageTrackingEvent);
     }
     catch (e) {
-        (0, errorHandlers_1.debugError)(e);
+        debugError(e);
     }
 }

package/lib/utils/__tests__/isDeepEqual.test.js

@@ -0,0 +1,269 @@
+import { describe, it, expect } from 'vitest';
+import { isDeepEqual } from '../isDeepEqual.js';
+describe('isDeepEqual', () => {
+    describe('primitive values', () => {
+        it('should return true for identical primitives', () => {
+            expect(isDeepEqual(1, 1)).toBe(true);
+            expect(isDeepEqual('hello', 'hello')).toBe(true);
+            expect(isDeepEqual(true, true)).toBe(true);
+            expect(isDeepEqual(false, false)).toBe(true);
+        });
+        it('should return false for different primitives', () => {
+            expect(isDeepEqual(1, 2)).toBe(false);
+            expect(isDeepEqual('hello', 'world')).toBe(false);
+            expect(isDeepEqual(true, false)).toBe(false);
+            expect(isDeepEqual(1, '1')).toBe(false);
+        });
+        it('should handle zero and negative numbers correctly', () => {
+            expect(isDeepEqual(0, 0)).toBe(true);
+            expect(isDeepEqual(-1, -1)).toBe(true);
+            expect(isDeepEqual(0, -0)).toBe(true);
+            expect(isDeepEqual(0, 1)).toBe(false);
+            expect(isDeepEqual(-1, 1)).toBe(false);
+        });
+        it('should handle empty strings', () => {
+            expect(isDeepEqual('', '')).toBe(true);
+            expect(isDeepEqual('', 'a')).toBe(false);
+        });
+    });
+    describe('null and undefined', () => {
+        it('should return true for null === null and undefined === undefined', () => {
+            expect(isDeepEqual(null, null)).toBe(true);
+            expect(isDeepEqual(undefined, undefined)).toBe(true);
+        });
+        it('should return false for null vs undefined', () => {
+            expect(isDeepEqual(null, undefined)).toBe(false);
+            expect(isDeepEqual(undefined, null)).toBe(false);
+        });
+        it('should return false for null/undefined vs other values', () => {
+            expect(isDeepEqual(null, 0)).toBe(false);
+            expect(isDeepEqual(undefined, 0)).toBe(false);
+            expect(isDeepEqual(null, '')).toBe(false);
+            expect(isDeepEqual(null, false)).toBe(false);
+            expect(isDeepEqual(null, {})).toBe(false);
+        });
+    });
+    describe('objects', () => {
+        it('should return true for identical empty objects', () => {
+            expect(isDeepEqual({}, {})).toBe(true);
+        });
+        it('should return true for objects with same properties', () => {
+            const obj1 = { a: 1, b: 'hello' };
+            const obj2 = { a: 1, b: 'hello' };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+        });
+        it('should return true for objects with same properties in different order', () => {
+            const obj1 = { a: 1, b: 'hello' };
+            const obj2 = { b: 'hello', a: 1 };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+        });
+        it('should return false for objects with different property values', () => {
+            const obj1 = { a: 1, b: 'hello' };
+            const obj2 = { a: 1, b: 'world' };
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+        });
+        it('should return false for objects with different number of properties', () => {
+            const obj1 = { a: 1 };
+            const obj2 = { a: 1, b: 2 };
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+        });
+        it('should return false for objects with different property keys', () => {
+            const obj1 = { a: 1 };
+            const obj2 = { b: 1 };
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+        });
+        it('should return true for same object reference', () => {
+            const obj = { a: 1, b: 'hello' };
+            expect(isDeepEqual(obj, obj)).toBe(true);
+        });
+    });
+    describe('nested objects', () => {
+        it('should return true for deeply nested identical objects', () => {
+            const obj1 = {
+                a: 1,
+                b: {
+                    c: 2,
+                    d: {
+                        e: 'nested',
+                        f: true,
+                    },
+                },
+            };
+            const obj2 = {
+                a: 1,
+                b: {
+                    c: 2,
+                    d: {
+                        e: 'nested',
+                        f: true,
+                    },
+                },
+            };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+        });
+        it('should return false for deeply nested objects with differences', () => {
+            const obj1 = {
+                a: 1,
+                b: {
+                    c: 2,
+                    d: {
+                        e: 'nested',
+                        f: true,
+                    },
+                },
+            };
+            const obj2 = {
+                a: 1,
+                b: {
+                    c: 2,
+                    d: {
+                        e: 'nested',
+                        f: false, // Different value
+                    },
+                },
+            };
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+        });
+        it('should handle objects with nested null/undefined values', () => {
+            const obj1 = { a: null, b: { c: undefined } };
+            const obj2 = { a: null, b: { c: undefined } };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+            const obj3 = { a: null, b: { c: null } };
+            expect(isDeepEqual(obj1, obj3)).toBe(false);
+        });
+    });
+    describe('arrays', () => {
+        it('should return true for identical empty arrays', () => {
+            expect(isDeepEqual([], [])).toBe(true);
+        });
+        it('should return true for arrays with same elements', () => {
+            expect(isDeepEqual([1, 2, 3], [1, 2, 3])).toBe(true);
+            expect(isDeepEqual(['a', 'b'], ['a', 'b'])).toBe(true);
+        });
+        it('should return false for arrays with different elements', () => {
+            expect(isDeepEqual([1, 2, 3], [1, 2, 4])).toBe(false);
+            expect(isDeepEqual(['a', 'b'], ['a', 'c'])).toBe(false);
+        });
+        it('should return false for arrays with different lengths', () => {
+            expect(isDeepEqual([1, 2], [1, 2, 3])).toBe(false);
+            expect(isDeepEqual([1, 2, 3], [1, 2])).toBe(false);
+        });
+        it('should return false for arrays with same elements in different order', () => {
+            expect(isDeepEqual([1, 2, 3], [3, 2, 1])).toBe(false);
+            expect(isDeepEqual(['a', 'b'], ['b', 'a'])).toBe(false);
+        });
+        it('should handle nested arrays', () => {
+            const arr1 = [1, [2, 3], [4, [5, 6]]];
+            const arr2 = [1, [2, 3], [4, [5, 6]]];
+            expect(isDeepEqual(arr1, arr2)).toBe(true);
+            const arr3 = [1, [2, 3], [4, [5, 7]]];
+            expect(isDeepEqual(arr1, arr3)).toBe(false);
+        });
+        it('should handle arrays with objects', () => {
+            const arr1 = [{ a: 1 }, { b: 2 }];
+            const arr2 = [{ a: 1 }, { b: 2 }];
+            expect(isDeepEqual(arr1, arr2)).toBe(true);
+            const arr3 = [{ a: 1 }, { b: 3 }];
+            expect(isDeepEqual(arr1, arr3)).toBe(false);
+        });
+    });
+    describe('mixed types', () => {
+        it('should return false for object vs array', () => {
+            expect(isDeepEqual({}, [])).toBe(false);
+            expect(isDeepEqual({ 0: 'a', 1: 'b' }, ['a', 'b'])).toBe(false);
+        });
+        it('should return false for object vs primitive', () => {
+            expect(isDeepEqual({}, null)).toBe(false);
+            expect(isDeepEqual({ a: 1 }, 1)).toBe(false);
+            expect(isDeepEqual({}, '')).toBe(false);
+        });
+        it('should return false for array vs primitive', () => {
+            expect(isDeepEqual([], null)).toBe(false);
+            expect(isDeepEqual([1], 1)).toBe(false);
+            expect(isDeepEqual([], '')).toBe(false);
+        });
+        it('should handle complex mixed structures', () => {
+            const obj1 = {
+                number: 42,
+                string: 'hello',
+                boolean: true,
+                null_value: null,
+                array: [1, 'two', { three: 3 }],
+                nested: {
+                    deep: {
+                        value: 'found',
+                    },
+                },
+            };
+            const obj2 = {
+                number: 42,
+                string: 'hello',
+                boolean: true,
+                null_value: null,
+                array: [1, 'two', { three: 3 }],
+                nested: {
+                    deep: {
+                        value: 'found',
+                    },
+                },
+            };
+            expect(isDeepEqual(obj1, obj2)).toBe(true);
+            const obj3 = { ...obj2, number: 43 };
+            expect(isDeepEqual(obj1, obj3)).toBe(false);
+        });
+    });
+    describe('ignoreKeys functionality', () => {
+        it('should ignore specified keys in comparison', () => {
+            const obj1 = { a: 1, b: 2, c: 3 };
+            const obj2 = { a: 1, b: 999, c: 3 }; // b is different
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+            expect(isDeepEqual(obj1, obj2, ['b'])).toBe(true);
+        });
+        it('should ignore multiple keys', () => {
+            const obj1 = { a: 1, b: 2, c: 3, d: 4 };
+            const obj2 = { a: 1, b: 999, c: 888, d: 4 }; // b and c are different
+            expect(isDeepEqual(obj1, obj2, ['b', 'c'])).toBe(true);
+        });
+        it('should ignore keys in nested objects', () => {
+            const obj1 = {
+                top: 'same',
+                nested: {
+                    keep: 'this',
+                    ignore: 'different1',
+                    deep: {
+                        keep: 'this',
+                        ignore: 'different2',
+                    },
+                },
+            };
+            const obj2 = {
+                top: 'same',
+                nested: {
+                    keep: 'this',
+                    ignore: 'DIFFERENT1',
+                    deep: {
+                        keep: 'this',
+                        ignore: 'DIFFERENT2',
+                    },
+                },
+            };
+            expect(isDeepEqual(obj1, obj2)).toBe(false);
+            expect(isDeepEqual(obj1, obj2, ['ignore'])).toBe(true);
+        });
+        it('should handle ignoreKeys when one object has extra properties', () => {
+            const obj1 = { a: 1, b: 2 };
+            const obj2 = { a: 1, b: 2, c: 3 };
+            expect(isDeepEqual(obj1, obj2, ['c'])).toBe(true);
+            expect(isDeepEqual(obj2, obj1, ['c'])).toBe(true);
+        });
+        it('should ignore keys in arrays (array indices as keys)', () => {
+            const arr1 = ['keep', 'ignore', 'keep'];
+            const arr2 = ['keep', 'DIFFERENT', 'keep'];
+            expect(isDeepEqual(arr1, arr2, ['1'])).toBe(true);
+        });
+        it('should not affect primitive comparisons', () => {
+            expect(isDeepEqual(1, 2, ['any', 'keys'])).toBe(false);
+            expect(isDeepEqual('hello', 'hello', ['any', 'keys'])).toBe(true);
+        });
+    });
+});

package/lib/utils/hasFlag.js

@@ -1,12 +1,6 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hasFlag = hasFlag;
-const process_1 = __importDefault(require("process"));
+import process from 'process';
 // See https://github.com/sindresorhus/has-flag/blob/main/index.js (License: https://github.com/sindresorhus/has-flag/blob/main/license)
-function hasFlag(flag, argv = process_1.default.argv) {
+export function hasFlag(flag, argv = process.argv) {
     const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
     const position = argv.indexOf(prefix + flag);
     const terminatorPosition = argv.indexOf('--');

package/lib/utils/isDeepEqual.d.ts

@@ -0,0 +1 @@
+export declare function isDeepEqual(object1: unknown, object2: unknown, ignoreKeys?: string[]): boolean;

package/lib/utils/isDeepEqual.js

@@ -0,0 +1,31 @@
+export function isDeepEqual(object1, object2, ignoreKeys) {
+    if (object1 === object2) {
+        return true;
+    }
+    if (object1 === null ||
+        object2 === null ||
+        typeof object1 !== 'object' ||
+        typeof object2 !== 'object') {
+        return object1 === object2;
+    }
+    if (typeof object1 !== typeof object2) {
+        return false;
+    }
+    const isArray1 = Array.isArray(object1);
+    const isArray2 = Array.isArray(object2);
+    if (isArray1 !== isArray2) {
+        return false;
+    }
+    const objKeys1 = Object.keys(object1).filter(key => !ignoreKeys?.includes(key));
+    const objKeys2 = Object.keys(object2).filter(key => !ignoreKeys?.includes(key));
+    if (objKeys1.length !== objKeys2.length)
+        return false;
+    for (const key of objKeys1) {
+        const value1 = object1[key];
+        const value2 = object2[key];
+        if (!isDeepEqual(value1, value2, ignoreKeys)) {
+            return false;
+        }
+    }
+    return true;
+}