@hubspot/cli 7.6.0-beta.11 → 7.6.0-beta.13

package/lib/projects/__tests__/AppDevModeInterface.test.js

@@ -100,6 +100,7 @@ describe('AppDevModeInterface', () => {
             setAppDataForUid: vi.fn(),
             addListener: vi.fn(),
             addUploadWarning: vi.fn(),
+            removeListener: vi.fn(),
         };
         mockLocalDevLogger = {};
         // Mock constructors
@@ -239,16 +240,21 @@ describe('AppDevModeInterface', () => {
             await newAppDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(0);
         });
-        it('should auto-install static auth app on test account', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            await appDevModeInterface.setup({});
-            expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(123, 67890, [1, 2, 3]);
-        });
+        // @TODO: Restore test account auto install functionality
+        // it('should auto-install static auth app on test account', async () => {
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   await appDevModeInterface.setup({});
+        //   expect(installStaticAuthAppOnTestAccount).toHaveBeenCalledWith(
+        //     123,
+        //     67890,
+        //     [1, 2, 3]
+        //   );
+        // });
         it('should open browser for OAuth app installation', async () => {
             const oauthAppNode = {
                 ...mockAppNode,
@@ -287,7 +293,12 @@ describe('AppDevModeInterface', () => {
                 },
             });
             await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true);
+            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', true, {
+                appUid: 'test-app-uid',
+                projectAccountId: 12345,
+                projectName: 'test-project',
+                testingAccountId: 67890,
+            });
         });
         it('should handle errors during setup', async () => {
             const error = new Error('Setup failed');
@@ -317,39 +328,46 @@ describe('AppDevModeInterface', () => {
             await appDevModeInterface.setup({});
             expect(process.exit).toHaveBeenCalledWith(1);
         });
-        it('should exit if user declines auto-install', async () => {
-            // Set up conditions for automatic installation
-            getAccountConfig.mockReturnValue({
-                parentAccountId: 12345, // matches targetProjectAccountId
-            });
-            isDeveloperTestAccount.mockReturnValue(true);
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installAppAutoPrompt.mockResolvedValue(false);
-            // Create a new instance to trigger the exit during setup
-            const newAppDevModeInterface = new AppDevModeInterface({
-                localDevState: mockLocalDevState,
-                localDevLogger: mockLocalDevLogger,
-            });
-            // The setup method catches the error, so we check that process.exit was called
-            await newAppDevModeInterface.setup({});
-            expect(process.exit).toHaveBeenCalledWith(0);
-        });
-        it('should fallback to browser install if auto-install fails', async () => {
-            fetchAppInstallationData.mockResolvedValue({
-                data: {
-                    isInstalledWithScopeGroups: false,
-                    previouslyAuthorizedScopeGroups: [],
-                },
-            });
-            installStaticAuthAppOnTestAccount.mockRejectedValue(new Error('Install failed'));
-            await appDevModeInterface.setup({});
-            expect(installAppBrowserPrompt).toHaveBeenCalledWith('http://static-install-url', false);
-        });
+        // @TODO: Restore test account auto install functionality
+        // it('should exit if user declines auto-install', async () => {
+        //   // Set up conditions for automatic installation
+        //   (getAccountConfig as Mock).mockReturnValue({
+        //     parentAccountId: 12345, // matches targetProjectAccountId
+        //   });
+        //   (isDeveloperTestAccount as Mock).mockReturnValue(true);
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   (installAppAutoPrompt as Mock).mockResolvedValue(false);
+        //   // Create a new instance to trigger the exit during setup
+        //   const newAppDevModeInterface = new AppDevModeInterface({
+        //     localDevState: mockLocalDevState,
+        //     localDevLogger: mockLocalDevLogger,
+        //   });
+        //   // The setup method catches the error, so we check that process.exit was called
+        //   await newAppDevModeInterface.setup({});
+        //   expect(process.exit).toHaveBeenCalledWith(0);
+        // });
+        // @TODO: Restore test account auto install functionality
+        // it('should fallback to browser install if auto-install fails', async () => {
+        //   (fetchAppInstallationData as Mock).mockResolvedValue({
+        //     data: {
+        //       isInstalledWithScopeGroups: false,
+        //       previouslyAuthorizedScopeGroups: [],
+        //     },
+        //   });
+        //   (installStaticAuthAppOnTestAccount as Mock).mockRejectedValue(
+        //     new Error('Install failed')
+        //   );
+        //   await appDevModeInterface.setup({});
+        //   expect(installAppBrowserPrompt).toHaveBeenCalledWith(
+        //     'http://static-install-url',
+        //     false
+        //   );
+        // });
     });
     describe('start()', () => {
         it('should return early if no app node exists', async () => {
@@ -387,6 +405,15 @@ describe('AppDevModeInterface', () => {
             await appDevModeInterface.cleanup();
             expect(UIEDevModeInterface.cleanup).toHaveBeenCalled();
         });
+        it('should remove state listeners', async () => {
+            await appDevModeInterface.cleanup();
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('devServerMessage', 
+            // @ts-expect-error access private method for testing
+            appDevModeInterface.onDevServerMessage);
+            expect(mockLocalDevState.removeListener).toHaveBeenCalledWith('projectNodes', 
+            // @ts-expect-error
+            appDevModeInterface.onChangeProjectNodes);
+        });
     });
     describe('isAutomaticallyInstallable()', () => {
         it('should return true for static auth app on test account with correct parent', () => {

package/lib/projects/__tests__/LocalDevProcess.test.js

@@ -39,6 +39,7 @@ describe('LocalDevProcess', () => {
         targetTestingAccountId: 456,
         projectId: 789,
         initialProjectNodes: {},
+        initialProjectProfileData: {},
         env: ENVIRONMENTS.PROD,
         projectName: 'test-project',
     };

package/lib/projects/__tests__/components.test.js

@@ -1,7 +1,29 @@
 import fs from 'fs';
-import { handleComponentCollision } from '../components.js';
+import { handleComponentCollision, updateHsMetaFilesWithAutoGeneratedFields, } from '../components.js';
+import { uiLogger } from '../../ui/logger.js';
+import { coerceToValidUid } from '@hubspot/project-parsing-lib';
 vi.mock('fs');
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/project-parsing-lib', () => ({
+    coerceToValidUid: vi.fn(),
+    metafileExtension: '.module.meta.json',
+}));
+vi.mock('@hubspot/project-parsing-lib/src/lib/constants.js', () => ({
+    AppKey: 'app',
+}));
+vi.mock('../../../lang/en.js', () => ({
+    lib: {
+        projects: {
+            updateHsMetaFilesWithAutoGeneratedFields: {
+                header: 'Updating component metadata files...',
+                applicationLog: (type, uid, name) => `Updated ${type} component with uid: ${uid} and name: ${name}`,
+                componentLog: (type, uid) => `Updated ${type} component with uid: ${uid}`,
+            },
+        },
+    },
+}));
 const mockedFs = vi.mocked(fs);
+const mockCoerceToValidUid = vi.mocked(coerceToValidUid);
 describe('lib/projects/components', () => {
     describe('handleComponentCollision()', () => {
         const mockCollision = {
@@ -152,10 +174,9 @@ describe('lib/projects/components', () => {
                 collisions: [
                     'regular.js',
                     'nested/path/file.ts',
-                    'component.module.meta.json',
+                    'component.meta.json',
                     'another.meta.json',
                     'package.json',
-                    'nested/package.json',
                 ],
             };
             // Mock metafileExtension
@@ -166,16 +187,152 @@ describe('lib/projects/components', () => {
             const mockMetaContent = '{}';
             mockedFs.readFileSync.mockReturnValue(mockMetaContent);
             mockedFs.writeFileSync.mockImplementation(() => { });
+            // Track what files are being copied to debug the issue
             mockedFs.copyFileSync.mockImplementation(() => { });
             // Mock console.log for package.json handling
             const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
             handleComponentCollision(collision);
-            // Should copy 2 source files
-            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
+            expect(mockedFs.readFileSync).toHaveBeenCalledTimes(2);
             // Should handle 2 metafiles
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
-            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/another.meta.json', 'utf-8');
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/dest/path/package.json', 'utf-8');
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/package.json', 'utf-8');
             consoleSpy.mockRestore();
         });
     });
+    describe('updateHsMetaFilesWithAutoGeneratedFields()', () => {
+        const mockUiLogger = vi.mocked(uiLogger);
+        beforeEach(() => {
+            vi.resetAllMocks();
+            mockCoerceToValidUid.mockImplementation((input) => input);
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('updates component metadata files with project-specific UIDs', () => {
+            const projectName = 'my-project';
+            const hsMetaFilePaths = [
+                '/path/to/component1.meta.json',
+                '/path/to/component2.meta.json',
+            ];
+            const component1 = {
+                type: 'card',
+                uid: 'old-uid-1',
+                config: {
+                    name: 'Old Name',
+                },
+            };
+            const component2 = {
+                type: 'function',
+                uid: 'old-uid-2',
+            };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(JSON.stringify(component1))
+                .mockReturnValueOnce(JSON.stringify(component2));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid
+                .mockReturnValueOnce('card-my-project')
+                .mockReturnValueOnce('function-my-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'card-my-project',
+                config: {
+                    name: 'Old Name',
+                },
+            }, null, 2));
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component2.meta.json', JSON.stringify({
+                type: 'function',
+                uid: 'function-my-project',
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated card component with uid: card-my-project');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated function component with uid: function-my-project');
+        });
+        it('handles app components by updating both uid and config.name', () => {
+            const projectName = 'test-app';
+            const hsMetaFilePaths = ['/path/to/app.meta.json'];
+            const appComponent = {
+                type: 'app',
+                uid: 'old-app-uid',
+                config: {
+                    name: 'Old App Name',
+                    other: 'property',
+                },
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(appComponent));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('app-test-app');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
+                type: 'app',
+                uid: 'app-test-app',
+                config: {
+                    name: 'test-app-Application',
+                    other: 'property',
+                },
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app-test-app and name: test-app-Application');
+        });
+        it('handles UID collisions by using timestamps', () => {
+            const projectName = 'collision-project';
+            const hsMetaFilePaths = ['/path/to/component1.meta.json'];
+            const existingUids = ['card-collision-project'];
+            const component1 = { type: 'card', uid: 'old-uid-1' };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component1));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // Mock Date.now to return consistent value for testing
+            vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+            mockCoerceToValidUid
+                .mockReturnValueOnce('card-collision-project')
+                .mockReturnValueOnce('card-1234567890-collision-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component1.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'card-1234567890-collision-project',
+            }, null, 2));
+        });
+        it('falls back to original uid when coerceToValidUid returns null', () => {
+            const projectName = 'fallback-project';
+            const hsMetaFilePaths = ['/path/to/component.meta.json'];
+            const component = {
+                type: 'card',
+                uid: 'original-uid',
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(component));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue(undefined);
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/component.meta.json', JSON.stringify({
+                type: 'card',
+                uid: 'original-uid',
+            }, null, 2));
+        });
+        it('handles empty hsMetaFilePaths array', () => {
+            const projectName = 'empty-project';
+            const hsMetaFilePaths = [];
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.readFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updating component metadata files...');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('');
+        });
+        it('handles components without config property for app type', () => {
+            const projectName = 'no-config-project';
+            const hsMetaFilePaths = ['/path/to/app.meta.json'];
+            const appComponent = {
+                type: 'app',
+                uid: 'app-uid',
+                // No config property
+            };
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(appComponent));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockCoerceToValidUid.mockReturnValue('app-no-config-project');
+            updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths);
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/path/to/app.meta.json', JSON.stringify({
+                type: 'app',
+                uid: 'app-no-config-project',
+            }, null, 2));
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Updated app component with uid: app-no-config-project');
+        });
+    });
 });

package/lib/projects/__tests__/deploy.test.js

@@ -0,0 +1,164 @@
+import { vi } from 'vitest';
+import { validateBuildIdForDeploy, logDeployErrors, handleProjectDeploy, } from '../deploy.js';
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { PROJECT_ERROR_TYPES } from '../../constants.js';
+import { deployProject } from '@hubspot/local-dev-lib/api/projects';
+import { pollDeployStatus } from '../pollProjectBuildAndDeploy.js';
+// Mock external dependencies
+vi.mock('../../ui/logger.js');
+vi.mock('@hubspot/local-dev-lib/api/projects');
+vi.mock('../pollProjectBuildAndDeploy.js');
+const mockUiLogger = vi.mocked(uiLogger);
+const mockDeployProject = vi.mocked(deployProject);
+const mockPollDeployStatus = vi.mocked(pollDeployStatus);
+describe('lib/projects/deploy', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('validateBuildIdForDeploy()', () => {
+        const accountId = 12345;
+        const projectName = 'test-project';
+        it('returns true when build ID is valid for deployment', () => {
+            const buildId = 5;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(true);
+        });
+        it('returns error message when build ID does not exist', () => {
+            const buildId = 15;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(commands.project.deploy.errors.buildIdDoesNotExist(accountId, buildId, projectName));
+        });
+        it('returns error message when build is already deployed', () => {
+            const buildId = 3;
+            const deployedBuildId = 3;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(commands.project.deploy.errors.buildAlreadyDeployed(accountId, buildId, projectName));
+        });
+        it('handles edge case when deployedBuildId is undefined', () => {
+            const buildId = 5;
+            const deployedBuildId = undefined;
+            const latestBuildId = 10;
+            const result = validateBuildIdForDeploy(buildId, deployedBuildId, latestBuildId, projectName, accountId);
+            expect(result).toBe(true);
+        });
+    });
+    describe('logDeployErrors()', () => {
+        it('logs main error message and individual error messages', () => {
+            const errorData = {
+                message: 'Deploy failed with errors',
+                errors: [
+                    {
+                        message: 'Component error 1',
+                        subCategory: 'SOME_ERROR',
+                        context: { COMPONENT_NAME: 'test-component' },
+                    },
+                    {
+                        message: 'Component error 2',
+                        subCategory: 'ANOTHER_ERROR',
+                        context: { COMPONENT_NAME: 'another-component' },
+                    },
+                ],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('Deploy failed with errors');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Component error 1');
+            expect(mockUiLogger.log).toHaveBeenCalledWith('Component error 2');
+        });
+        it('handles DEPLOY_CONTAINS_REMOVALS error type specially', () => {
+            const errorData = {
+                message: 'Deploy contains removals',
+                errors: [
+                    {
+                        message: 'Component will be removed',
+                        subCategory: PROJECT_ERROR_TYPES.DEPLOY_CONTAINS_REMOVALS,
+                        context: { COMPONENT_NAME: 'removed-component' },
+                    },
+                ],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('Deploy contains removals');
+            expect(mockUiLogger.log).toHaveBeenCalledWith(commands.project.deploy.errors.deployContainsRemovals('removed-component'));
+        });
+        it('handles empty errors array', () => {
+            const errorData = {
+                message: 'No specific errors',
+                errors: [],
+            };
+            logDeployErrors(errorData);
+            expect(mockUiLogger.error).toHaveBeenCalledWith('No specific errors');
+            expect(mockUiLogger.log).not.toHaveBeenCalled();
+        });
+    });
+    describe('handleProjectDeploy()', () => {
+        const targetAccountId = 12345;
+        const projectName = 'test-project';
+        const buildId = 5;
+        const useV3Api = true;
+        const force = false;
+        it('successfully deploys and returns deploy result', async () => {
+            const mockDeployResponseData = {
+                id: 'deploy-123',
+                buildResultType: 'DEPLOY_QUEUED',
+                links: {
+                    status: 'http://status-url',
+                },
+            };
+            const mockDeployResult = {
+                deployId: 123,
+                buildId: 5,
+                status: 'SUCCESS',
+                enqueuedAt: '2023-01-01T00:00:00Z',
+                startedAt: '2023-01-01T00:01:00Z',
+                finishedAt: '2023-01-01T00:05:00Z',
+                portalId: targetAccountId,
+                projectName: 'test-project',
+                userId: 456,
+                source: 'HUBSPOT_USER',
+                subdeployStatuses: [],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockDeployResponseData,
+            });
+            mockPollDeployStatus.mockResolvedValue(mockDeployResult);
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockDeployProject).toHaveBeenCalledWith(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(result).toEqual(mockDeployResult);
+        });
+        it('handles blocked deploy with warnings', async () => {
+            const mockBlockedResponse = {
+                buildResultType: 'DEPLOY_BLOCKED',
+                issues: [
+                    {
+                        uid: 'component-1',
+                        componentTypeName: 'module',
+                        errorMessages: [],
+                        blockingMessages: [
+                            {
+                                message: 'This is a warning',
+                                isWarning: true,
+                            },
+                        ],
+                    },
+                ],
+            };
+            mockDeployProject.mockResolvedValue({
+                data: mockBlockedResponse,
+            });
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockUiLogger.warn).toHaveBeenCalledWith(commands.project.deploy.errors.deployWarningsHeader);
+            expect(result).toBeUndefined();
+        });
+        it('handles general deploy failure', async () => {
+            mockDeployProject.mockResolvedValue({ data: null });
+            const result = await handleProjectDeploy(targetAccountId, projectName, buildId, useV3Api, force);
+            expect(mockUiLogger.error).toHaveBeenCalledWith(commands.project.deploy.errors.deploy);
+            expect(result).toBeUndefined();
+        });
+    });
+});

package/lib/projects/__tests__/platformVersion.test.d.ts

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

package/lib/projects/__tests__/{buildAndDeploy.test.js → platformVersion.test.js}

@@ -1,5 +1,5 @@
-import { useV3Api } from '../buildAndDeploy.js';
-describe('buildAndDeploy', () => {
+import { useV3Api } from '../platformVersion.js';
+describe('platformVersion', () => {
     describe('useV3Api', () => {
         it('returns true if platform version is UNSTABLE', () => {
             expect(useV3Api('UNSTABLE')).toBe(true);