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

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

@@ -0,0 +1,23 @@
+import { useV3Api } from '../buildAndDeploy.js';
+describe('buildAndDeploy', () => {
+    describe('useV3Api', () => {
+        it('returns true if platform version is UNSTABLE', () => {
+            expect(useV3Api('UNSTABLE')).toBe(true);
+        });
+        it('returns true if platform version is equal to the minimum', () => {
+            expect(useV3Api('2025.2')).toBe(true);
+        });
+        it('returns true if platform version is greater than the minimum', () => {
+            expect(useV3Api('2026.2')).toBe(true);
+        });
+        it('returns false if platform version is less than the minimum', () => {
+            expect(useV3Api('2025.0')).toBe(false);
+        });
+        it('returns false if platform version is invalid', () => {
+            expect(useV3Api(null)).toBe(false);
+        });
+        it('returns false for an invalid platform version', () => {
+            expect(useV3Api('notplaformversion')).toBe(false);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,181 @@
+import fs from 'fs';
+import { handleComponentCollision } from '../components.js';
+vi.mock('fs');
+const mockedFs = vi.mocked(fs);
+describe('lib/projects/components', () => {
+    describe('handleComponentCollision()', () => {
+        const mockCollision = {
+            dest: '/dest/path',
+            src: '/src/path',
+            collisions: [],
+        };
+        beforeEach(() => {
+            vi.resetAllMocks();
+            // Mock Date.now to return consistent values for testing
+            vi.spyOn(Date, 'now').mockReturnValue(1234567890);
+        });
+        afterEach(() => {
+            vi.restoreAllMocks();
+        });
+        it('handles source file collisions by renaming them with timestamps', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.js', 'utils.ts'],
+            };
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            handleComponentCollision(collision);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledTimes(2);
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+        });
+        it('handles metafile collisions by renaming and updating references', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['component.module.meta.json', 'source.js'],
+            };
+            const mockMetaContent = JSON.stringify({
+                file: 'source.js',
+                label: 'Test Component',
+            });
+            mockedFs.readFileSync.mockReturnValue(mockMetaContent);
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.module.meta.json',
+                writable: false,
+            });
+            handleComponentCollision(collision);
+            expect(mockedFs.readFileSync).toHaveBeenCalledWith('/src/path/component.module.meta.json', 'utf-8');
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('source-1234567890.js'));
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/source.js', '/dest/path/source-1234567890.js');
+        });
+        it('handles package.json collisions by merging dependencies', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: ['package.json'],
+            };
+            const existingPackageJson = {
+                name: 'existing-package',
+                dependencies: {
+                    existing: '1.0.0',
+                    shared: '1.0.0',
+                },
+                devDependencies: {
+                    'existing-dev': '1.0.0',
+                },
+            };
+            const newPackageJson = {
+                name: 'new-package',
+                dependencies: {
+                    new: '2.0.0',
+                    shared: '2.0.0',
+                },
+                devDependencies: {
+                    'new-dev': '2.0.0',
+                    'existing-dev': '2.0.0',
+                },
+            };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(JSON.stringify(existingPackageJson))
+                .mockReturnValueOnce(JSON.stringify(newPackageJson));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            // Mock console.log to avoid output during tests
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            handleComponentCollision(collision);
+            const expectedMergedPackageJson = {
+                name: 'existing-package',
+                dependencies: {
+                    new: '2.0.0',
+                    shared: '1.0.0',
+                    existing: '1.0.0',
+                },
+                devDependencies: {
+                    'new-dev': '2.0.0',
+                    'existing-dev': '1.0.0',
+                },
+            };
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/package.json', JSON.stringify(expectedMergedPackageJson, null, 2));
+            consoleSpy.mockRestore();
+        });
+        it('handles mixed collision types (source files, metafiles, and package.json)', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [
+                    'component.js',
+                    'component.module.meta.json',
+                    'package.json',
+                    'utils.ts',
+                ],
+            };
+            const mockMetaContent = JSON.stringify({
+                file: 'component.js',
+                label: 'Test Component',
+            });
+            const existingPackageJson = { name: 'existing' };
+            const newPackageJson = { name: 'new', dependencies: { test: '1.0.0' } };
+            mockedFs.readFileSync
+                .mockReturnValueOnce(mockMetaContent)
+                .mockReturnValueOnce(JSON.stringify(existingPackageJson))
+                .mockReturnValueOnce(JSON.stringify(newPackageJson));
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            mockedFs.copyFileSync.mockImplementation(() => { });
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.module.meta.json',
+                writable: false,
+            });
+            const consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
+            handleComponentCollision(collision);
+            // Verify source files are copied with new names
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/component.js', '/dest/path/component-1234567890.js');
+            expect(mockedFs.copyFileSync).toHaveBeenCalledWith('/src/path/utils.ts', '/dest/path/utils-1234567890.ts');
+            // Verify metafile is updated and written with new name
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/component-1234567890.module.meta.json', expect.stringContaining('component-1234567890.js'));
+            // Verify package.json is merged
+            expect(mockedFs.writeFileSync).toHaveBeenCalledWith('/dest/path/package.json', expect.stringContaining('"dependencies"'));
+            consoleSpy.mockRestore();
+        });
+        it('handles empty collisions array gracefully', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [],
+            };
+            handleComponentCollision(collision);
+            expect(mockedFs.copyFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.readFileSync).not.toHaveBeenCalled();
+            expect(mockedFs.writeFileSync).not.toHaveBeenCalled();
+        });
+        it('correctly categorizes different file types', () => {
+            const collision = {
+                ...mockCollision,
+                collisions: [
+                    'regular.js',
+                    'nested/path/file.ts',
+                    'component.module.meta.json',
+                    'another.meta.json',
+                    'package.json',
+                    'nested/package.json',
+                ],
+            };
+            // Mock metafileExtension
+            Object.defineProperty(require('@hubspot/project-parsing-lib'), 'metafileExtension', {
+                value: '.meta.json',
+                writable: false,
+            });
+            const mockMetaContent = '{}';
+            mockedFs.readFileSync.mockReturnValue(mockMetaContent);
+            mockedFs.writeFileSync.mockImplementation(() => { });
+            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);
+            // 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');
+            consoleSpy.mockRestore();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,84 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { validateProjectConfig } from '../../projects/config.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+vi.mock('@hubspot/local-dev-lib/logger');
+describe('lib/projects', () => {
+    describe('validateProjectConfig()', () => {
+        let projectDir;
+        let exitMock;
+        beforeAll(() => {
+            projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'projects-'));
+            fs.mkdirSync(path.join(projectDir, 'src'));
+        });
+        beforeEach(() => {
+            // @ts-expect-error - Mocking process.exit
+            exitMock = vi
+                .spyOn(process, 'exit')
+                .mockImplementation(() => undefined);
+        });
+        afterEach(() => {
+            exitMock.mockRestore();
+        });
+        it('rejects undefined configuration', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig(null, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*Unable to locate a project configuration file. Try running again from a project directory, or run*/));
+        });
+        it('rejects configuration with missing name', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig({ srcDir: '.' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields*/));
+        });
+        it('rejects configuration with missing srcDir', () => {
+            // @ts-ignore Testing invalid input
+            validateProjectConfig({ name: 'hello' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*missing required fields.*/));
+        });
+        describe('rejects configuration with srcDir outside project directory', () => {
+            it('for parent directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '..', platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: ".."'));
+            });
+            it('for root directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '/', platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining('srcDir: "/"'));
+            });
+            it('for complicated directory', () => {
+                const srcDir = './src/././../src/../../src';
+                validateProjectConfig({ name: 'hello', srcDir, platformVersion: '' }, projectDir);
+                expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+                expect(logger.error).toHaveBeenCalledWith(expect.stringContaining(`srcDir: "${srcDir}"`));
+            });
+        });
+        it('rejects configuration with srcDir that does not exist', () => {
+            validateProjectConfig({ name: 'hello', srcDir: 'foo', platformVersion: '' }, projectDir);
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/.*could not be found in.*/));
+        });
+        describe('accepts configuration with valid srcDir', () => {
+            it('for current directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: '.', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+            it('for relative directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: './src', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+            it('for implied relative directory', () => {
+                validateProjectConfig({ name: 'hello', srcDir: 'src', platformVersion: '' }, projectDir);
+                expect(exitMock).not.toHaveBeenCalled();
+                expect(logger.error).not.toHaveBeenCalled();
+            });
+        });
+    });
+});

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

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

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

@@ -0,0 +1,211 @@
+import fs from 'fs';
+import * as HSfs from '@hubspot/local-dev-lib/fs';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getComponentTypeFromConfigFile, loadConfigFile, getAppCardConfigs, getIsLegacyApp, componentIsApp, findProjectComponents, getProjectComponentTypes, getComponentUid, componentIsPublicApp, } from '../structure.js';
+import { ComponentTypes } from '../../../types/Projects.js';
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/fs');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedReadFileSync = fs.readFileSync;
+const mockedWalk = HSfs.walk;
+const getMockPrivateAppConfig = (cards = []) => ({
+    name: 'test-app',
+    description: 'test-description',
+    uid: 'test-uid',
+    scopes: ['test-scope'],
+    public: true,
+    extensions: {
+        crm: {
+            cards,
+        },
+    },
+});
+describe('lib/projects/structure', () => {
+    describe('getComponentTypeFromConfigFile()', () => {
+        it('returns correct type for public app config', () => {
+            expect(getComponentTypeFromConfigFile('public-app.json')).toBe(ComponentTypes.PublicApp);
+        });
+        it('returns correct type for private app config', () => {
+            expect(getComponentTypeFromConfigFile('app.json')).toBe(ComponentTypes.PrivateApp);
+        });
+        it('returns correct type for theme config', () => {
+            expect(getComponentTypeFromConfigFile('theme.json')).toBe(ComponentTypes.HublTheme);
+        });
+        it('returns null for unknown config file', () => {
+            expect(getComponentTypeFromConfigFile('unknown.json')).toBeNull();
+        });
+    });
+    describe('loadConfigFile()', () => {
+        it('returns parsed JSON when file exists', () => {
+            const mockConfig = { name: 'test-app' };
+            mockedReadFileSync.mockReturnValue(JSON.stringify(mockConfig));
+            expect(loadConfigFile('test/path/app.json')).toEqual(mockConfig);
+        });
+        it('returns null when file read fails', () => {
+            mockedReadFileSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            expect(loadConfigFile('nonexistent/path/app.json')).toBeNull();
+            expect(logger.debug).toHaveBeenCalled();
+        });
+    });
+    describe('getAppCardConfigs()', () => {
+        const mockAppPath = '/test/path';
+        it('returns empty array when no cards exist', () => {
+            const appConfig = getMockPrivateAppConfig();
+            expect(getAppCardConfigs(appConfig, mockAppPath)).toEqual([]);
+        });
+        it('returns array of card configs when valid cards exist', () => {
+            const mockCardConfig = { type: 'crm-card' };
+            mockedReadFileSync.mockReturnValue(JSON.stringify(mockCardConfig));
+            const appConfig = getMockPrivateAppConfig([{ file: 'card.json' }]);
+            expect(getAppCardConfigs(appConfig, mockAppPath)).toEqual([
+                mockCardConfig,
+            ]);
+        });
+    });
+    describe('getIsLegacyApp()', () => {
+        const mockAppPath = '/test/path';
+        it('returns true for a legacy app', () => {
+            const cardConfig = { type: 'crm-card' };
+            const appConfig = getMockPrivateAppConfig([{ file: 'card.json' }]);
+            mockedReadFileSync.mockReturnValue(JSON.stringify(cardConfig));
+            expect(getIsLegacyApp(appConfig, mockAppPath)).toBe(true);
+        });
+        it('returns false when the app has no cards', () => {
+            const appConfig = getMockPrivateAppConfig();
+            expect(getIsLegacyApp(appConfig, mockAppPath)).toBe(false);
+        });
+        it('returns false for non-legacy app', () => {
+            const cardConfig = {
+                data: { module: { file: 'ReactCard.jsx' } },
+            };
+            const appConfig = getMockPrivateAppConfig([{ file: 'card.json' }]);
+            mockedReadFileSync.mockReturnValue(JSON.stringify(cardConfig));
+            expect(getIsLegacyApp(appConfig, mockAppPath)).toBe(false);
+        });
+    });
+    describe('findProjectComponents()', () => {
+        it('returns an empty array of components when no components are found', async () => {
+            mockedWalk.mockReturnValue([]);
+            const components = await findProjectComponents('');
+            expect(components).toEqual([]);
+        });
+        it('returns an array of components when components are found', async () => {
+            const cardConfig = { type: 'crm-card' };
+            const appConfig = getMockPrivateAppConfig();
+            const component = {
+                type: ComponentTypes.PrivateApp,
+                config: appConfig,
+                runnable: true,
+                path: '',
+            };
+            mockedWalk.mockReturnValue(['app.json']);
+            mockedReadFileSync
+                .mockReturnValueOnce(JSON.stringify(appConfig))
+                .mockReturnValueOnce(JSON.stringify(cardConfig));
+            const components = await findProjectComponents('');
+            expect(components).toEqual([component]);
+        });
+    });
+    describe('getProjectComponentTypes()', () => {
+        it('returns the correct component types', () => {
+            const component = {
+                type: ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            const components = [component];
+            expect(getProjectComponentTypes(components)).toEqual({
+                [ComponentTypes.PrivateApp]: true,
+            });
+        });
+        it('returns the correct component types for multiple components', () => {
+            const component1 = {
+                type: ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            const component2 = {
+                type: ComponentTypes.PublicApp,
+                // Config doesn't matter for this test so we can use a private app config
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            const components = [component1, component2];
+            expect(getProjectComponentTypes(components)).toEqual({
+                [ComponentTypes.PrivateApp]: true,
+                [ComponentTypes.PublicApp]: true,
+            });
+        });
+        it('returns an empty object when no components are provided', () => {
+            const components = [];
+            expect(getProjectComponentTypes(components)).toEqual({});
+        });
+    });
+    describe('getComponentUid()', () => {
+        it('returns uid from the component config', () => {
+            const component = {
+                type: ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect(getComponentUid(component)).toBe(component.config.uid);
+        });
+        it('returns null for null input', () => {
+            expect(getComponentUid(null)).toBeNull();
+        });
+    });
+    describe('componentIsApp()', () => {
+        it('returns true for public app component', () => {
+            const component = {
+                type: ComponentTypes.PublicApp,
+                // Config doesn't matter for this test so we can use a private app config
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect(componentIsApp(component)).toBe(true);
+        });
+        it('returns true for private app component', () => {
+            const component = {
+                type: ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect(componentIsApp(component)).toBe(true);
+        });
+        it('returns false for null input', () => {
+            expect(componentIsApp(null)).toBe(false);
+        });
+    });
+    describe('componentIsPublicApp()', () => {
+        it('returns true for public app component', () => {
+            const component = {
+                type: ComponentTypes.PublicApp,
+                // Config doesn't matter for this test so we can use a private app config
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect(componentIsPublicApp(component)).toBe(true);
+        });
+        it('returns false for private app component', () => {
+            const component = {
+                type: ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect(componentIsPublicApp(component)).toBe(false);
+        });
+        it('returns false for null input', () => {
+            expect(componentIsPublicApp(null)).toBe(false);
+        });
+    });
+});

package/lib/projects/add/__tests__/legacyAddComponent.test.d.ts

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