@hubspot/cli 7.7.19-experimental.2 → 7.7.20-experimental.0

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

@@ -0,0 +1,249 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const HSfs = __importStar(require("@hubspot/local-dev-lib/fs"));
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const structure_1 = require("../structure");
+const Projects_1 = require("../../../types/Projects");
+vi.mock('fs');
+vi.mock('@hubspot/local-dev-lib/fs');
+vi.mock('@hubspot/local-dev-lib/logger');
+const mockedReadFileSync = fs_1.default.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((0, structure_1.getComponentTypeFromConfigFile)('public-app.json')).toBe(Projects_1.ComponentTypes.PublicApp);
+        });
+        it('returns correct type for private app config', () => {
+            expect((0, structure_1.getComponentTypeFromConfigFile)('app.json')).toBe(Projects_1.ComponentTypes.PrivateApp);
+        });
+        it('returns correct type for theme config', () => {
+            expect((0, structure_1.getComponentTypeFromConfigFile)('theme.json')).toBe(Projects_1.ComponentTypes.HublTheme);
+        });
+        it('returns null for unknown config file', () => {
+            expect((0, structure_1.getComponentTypeFromConfigFile)('unknown.json')).toBeNull();
+        });
+    });
+    describe('loadConfigFile()', () => {
+        it('returns parsed JSON when file exists', () => {
+            const mockConfig = { name: 'test-app' };
+            mockedReadFileSync.mockReturnValue(JSON.stringify(mockConfig));
+            expect((0, structure_1.loadConfigFile)('test/path/app.json')).toEqual(mockConfig);
+        });
+        it('returns null when file read fails', () => {
+            mockedReadFileSync.mockImplementation(() => {
+                throw new Error('File not found');
+            });
+            expect((0, structure_1.loadConfigFile)('nonexistent/path/app.json')).toBeNull();
+            expect(logger_1.logger.debug).toHaveBeenCalled();
+        });
+    });
+    describe('getAppCardConfigs()', () => {
+        const mockAppPath = '/test/path';
+        it('returns empty array when no cards exist', () => {
+            const appConfig = getMockPrivateAppConfig();
+            expect((0, structure_1.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((0, structure_1.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((0, structure_1.getIsLegacyApp)(appConfig, mockAppPath)).toBe(true);
+        });
+        it('returns false when the app has no cards', () => {
+            const appConfig = getMockPrivateAppConfig();
+            expect((0, structure_1.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((0, structure_1.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 (0, structure_1.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: Projects_1.ComponentTypes.PrivateApp,
+                config: appConfig,
+                runnable: true,
+                path: '',
+            };
+            mockedWalk.mockReturnValue(['app.json']);
+            mockedReadFileSync
+                .mockReturnValueOnce(JSON.stringify(appConfig))
+                .mockReturnValueOnce(JSON.stringify(cardConfig));
+            const components = await (0, structure_1.findProjectComponents)('');
+            expect(components).toEqual([component]);
+        });
+    });
+    describe('getProjectComponentTypes()', () => {
+        it('returns the correct component types', () => {
+            const component = {
+                type: Projects_1.ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            const components = [component];
+            expect((0, structure_1.getProjectComponentTypes)(components)).toEqual({
+                [Projects_1.ComponentTypes.PrivateApp]: true,
+            });
+        });
+        it('returns the correct component types for multiple components', () => {
+            const component1 = {
+                type: Projects_1.ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            const component2 = {
+                type: Projects_1.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((0, structure_1.getProjectComponentTypes)(components)).toEqual({
+                [Projects_1.ComponentTypes.PrivateApp]: true,
+                [Projects_1.ComponentTypes.PublicApp]: true,
+            });
+        });
+        it('returns an empty object when no components are provided', () => {
+            const components = [];
+            expect((0, structure_1.getProjectComponentTypes)(components)).toEqual({});
+        });
+    });
+    describe('getComponentUid()', () => {
+        it('returns uid from the component config', () => {
+            const component = {
+                type: Projects_1.ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect((0, structure_1.getComponentUid)(component)).toBe(component.config.uid);
+        });
+        it('returns null for null input', () => {
+            expect((0, structure_1.getComponentUid)(null)).toBeNull();
+        });
+    });
+    describe('componentIsApp()', () => {
+        it('returns true for public app component', () => {
+            const component = {
+                type: Projects_1.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((0, structure_1.componentIsApp)(component)).toBe(true);
+        });
+        it('returns true for private app component', () => {
+            const component = {
+                type: Projects_1.ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect((0, structure_1.componentIsApp)(component)).toBe(true);
+        });
+        it('returns false for null input', () => {
+            expect((0, structure_1.componentIsApp)(null)).toBe(false);
+        });
+    });
+    describe('componentIsPublicApp()', () => {
+        it('returns true for public app component', () => {
+            const component = {
+                type: Projects_1.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((0, structure_1.componentIsPublicApp)(component)).toBe(true);
+        });
+        it('returns false for private app component', () => {
+            const component = {
+                type: Projects_1.ComponentTypes.PrivateApp,
+                config: getMockPrivateAppConfig(),
+                runnable: true,
+                path: 'test/path',
+            };
+            expect((0, structure_1.componentIsPublicApp)(component)).toBe(false);
+        });
+        it('returns false for null input', () => {
+            expect((0, structure_1.componentIsPublicApp)(null)).toBe(false);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const legacyAddComponent_1 = require("../legacyAddComponent");
+const structure_1 = require("../../structure");
+const legacy_1 = require("../../create/legacy");
+const projectAddPrompt_1 = require("../../../prompts/projectAddPrompt");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const Projects_1 = require("../../../../types/Projects");
+const en_1 = require("../../../../lang/en");
+vi.mock('../../structure');
+vi.mock('../../create/legacy');
+vi.mock('../../../prompts/projectAddPrompt');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/github');
+const mockedFindProjectComponents = vi.mocked(structure_1.findProjectComponents);
+const mockedGetProjectComponentListFromRepo = vi.mocked(legacy_1.getProjectComponentListFromRepo);
+const mockedProjectAddPrompt = vi.mocked(projectAddPrompt_1.projectAddPrompt);
+const mockedLogger = vi.mocked(logger_1.logger);
+const mockedCloneGithubRepo = vi.mocked(github_1.cloneGithubRepo);
+describe('lib/projects/add/legacyAddComponent', () => {
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: 'v1',
+    };
+    const mockArgs = { name: 'test-component', type: 'module' };
+    const projectDir = '/path/to/project';
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    describe('legacyAddComponent()', () => {
+        it('successfully adds a component to a project without public apps', async () => {
+            const mockComponents = [
+                {
+                    type: Projects_1.ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await (0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig);
+            expect(mockedFindProjectComponents).toHaveBeenCalledWith(projectDir);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), '/path/to/project/src/new-component', expect.objectContaining({
+                sourceDir: 'template-path',
+                branch: 'main',
+                hideLogs: true,
+            }));
+            expect(mockedLogger.log).toHaveBeenCalledWith(en_1.commands.project.add.creatingComponent('test-project'));
+            expect(mockedLogger.success).toHaveBeenCalledWith(en_1.commands.project.add.success('new-component'));
+        });
+        it('throws an error when project contains a public app', async () => {
+            const mockComponents = [
+                {
+                    type: Projects_1.ComponentTypes.PublicApp,
+                    config: {
+                        name: 'public-app',
+                        uid: '',
+                        description: '',
+                        allowedUrls: [],
+                        auth: {
+                            redirectUrls: [],
+                            requiredScopes: [],
+                            optionalScopes: [],
+                            conditionallyRequiredScopes: [],
+                        },
+                        support: {
+                            supportEmail: '',
+                            documentationUrl: '',
+                            supportUrl: '',
+                            supportPhone: '',
+                        },
+                    },
+                    runnable: true,
+                    path: '/path/to/public-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            await expect((0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.projectContainsPublicApp);
+            expect(mockedGetProjectComponentListFromRepo).not.toHaveBeenCalled();
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('continues when findProjectComponents throws an error', async () => {
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockRejectedValue(new Error('Find components error'));
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await (0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig);
+            expect(mockedGetProjectComponentListFromRepo).toHaveBeenCalledWith('v1');
+            expect(mockedProjectAddPrompt).toHaveBeenCalledWith(mockComponentList, mockArgs);
+            expect(mockedCloneGithubRepo).toHaveBeenCalled();
+        });
+        it('throws an error when component list is empty', async () => {
+            const mockComponents = [
+                {
+                    type: Projects_1.ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue([]);
+            await expect((0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when component list is null', async () => {
+            const mockComponents = [
+                {
+                    type: Projects_1.ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            // @ts-expect-error Breaking stuff on purpose
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(null);
+            await expect((0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when cloning fails', async () => {
+            const mockComponents = [
+                {
+                    type: Projects_1.ComponentTypes.PrivateApp,
+                    config: {
+                        name: 'private-app',
+                        description: '',
+                        uid: '',
+                        scopes: [],
+                        public: false,
+                    },
+                    runnable: true,
+                    path: '/path/to/private-app',
+                },
+            ];
+            const mockComponentList = [
+                { label: 'Test Component', path: 'test-component', type: 'module' },
+            ];
+            const mockPromptResponse = {
+                name: 'new-component',
+                componentTemplate: {
+                    label: 'Test Component',
+                    path: 'template-path',
+                    type: 'module',
+                },
+            };
+            mockedFindProjectComponents.mockResolvedValue(mockComponents);
+            mockedGetProjectComponentListFromRepo.mockResolvedValue(mockComponentList);
+            mockedProjectAddPrompt.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            await expect((0, legacyAddComponent_1.legacyAddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.failedToDownloadComponent);
+            expect(mockedCloneGithubRepo).toHaveBeenCalled();
+            expect(mockedLogger.success).not.toHaveBeenCalled();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,190 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const v3AddComponent_1 = require("../v3AddComponent");
+const legacy_1 = require("../../create/legacy");
+const v3_1 = require("../../create/v3");
+const promptUtils_1 = require("../../../prompts/promptUtils");
+const projectAddPrompt_1 = require("../../../prompts/projectAddPrompt");
+const github_1 = require("@hubspot/local-dev-lib/github");
+const logger_1 = require("@hubspot/local-dev-lib/logger");
+const project_1 = require("@hubspot/project-parsing-lib/src/lib/project");
+const en_1 = require("../../../../lang/en");
+vi.mock('fs');
+vi.mock('../../../prompts/promptUtils');
+vi.mock('../../create/legacy');
+vi.mock('../../create/v3');
+vi.mock('../../../prompts/projectAddPrompt');
+vi.mock('@hubspot/local-dev-lib/github');
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/project-parsing-lib/src/lib/project');
+const mockedFs = vi.mocked(fs_1.default);
+const mockedGetConfigForPlatformVersion = vi.mocked(legacy_1.getConfigForPlatformVersion);
+const mockedConfirmPrompt = vi.mocked(promptUtils_1.confirmPrompt);
+const mockedCreateV3App = vi.mocked(v3_1.createV3App);
+const mockedProjectAddPromptV3 = vi.mocked(projectAddPrompt_1.projectAddPromptV3);
+const mockedCloneGithubRepo = vi.mocked(github_1.cloneGithubRepo);
+const mockedLogger = vi.mocked(logger_1.logger);
+const mockedGetProjectMetadata = vi.mocked(project_1.getProjectMetadata);
+describe('lib/projects/add/v3AddComponent', () => {
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: 'v3',
+    };
+    const mockArgs = { name: 'test-component', type: 'module' };
+    const projectDir = '/path/to/project';
+    const mockComponentTemplate = {
+        label: 'Test Component',
+        path: 'test-component',
+        type: 'module',
+        supportedAuthTypes: ['oauth'],
+        supportedDistributions: ['private'],
+    };
+    const mockParentComponent = {
+        label: 'Test App',
+        type: 'app',
+        authType: 'oauth',
+        distribution: 'private',
+        path: 'app-template',
+    };
+    const mockConfig = {
+        components: [mockComponentTemplate],
+        parentComponents: [mockParentComponent],
+    };
+    const mockProjectMetadata = {
+        hsMetaFiles: [],
+        components: {
+            app: { count: 1, maxCount: 1, hsMetaFiles: ['/path/to/app.meta.json'] },
+            module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+        },
+    };
+    beforeEach(() => {
+        mockedCreateV3App.mockResolvedValue({
+            authType: 'oauth',
+            distribution: 'private',
+        });
+    });
+    describe('v3AddComponent()', () => {
+        it('successfully adds a component when app already exists', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await (0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig);
+            expect(mockedGetConfigForPlatformVersion).toHaveBeenCalledWith('v3');
+            expect(mockedGetProjectMetadata).toHaveBeenCalledWith('/path/to/project/src');
+            expect(mockedProjectAddPromptV3).toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
+                sourceDir: ['v3/test-component'],
+                hideLogs: true,
+                branch: 'main',
+            }));
+            expect(mockedLogger.success).toHaveBeenCalled();
+        });
+        it('creates an app when no app exists and user confirms', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: { count: 0, maxCount: 1, hsMetaFiles: [] },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await (0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig);
+            expect(mockedCreateV3App).toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).toHaveBeenCalledWith(expect.any(String), projectDir, expect.objectContaining({
+                sourceDir: ['v3/test-component', 'v3/app-template'],
+            }));
+        });
+        it('should not call clone', async () => {
+            const mockProjectMetadataNoApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: {
+                        count: 1,
+                        maxCount: 1,
+                        hsMetaFiles: ['/path/to/app.meta.json'],
+                    },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataNoApps);
+            mockedConfirmPrompt.mockResolvedValue(true);
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockResolvedValue(true);
+            await (0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig);
+            expect(mockedCreateV3App).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when app count exceeds maximum', async () => {
+            const mockProjectMetadataMaxApps = {
+                hsMetaFiles: [],
+                components: {
+                    app: { count: 2, maxCount: 1, hsMetaFiles: [] },
+                    module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                },
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadataMaxApps);
+            await expect((0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('This project currently has the maximum number of apps: 1');
+        });
+        it('throws an error when components list is empty', async () => {
+            const mockEmptyConfig = {
+                components: [],
+                parentComponents: [],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockEmptyConfig);
+            await expect((0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.failedToFetchComponentList);
+        });
+        it('throws an error when app meta file cannot be parsed', async () => {
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockImplementation(() => {
+                throw new Error('File read error');
+            });
+            await expect((0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow('Unable to parse app file');
+        });
+        it('throws an error when cloning fails', async () => {
+            const mockAppMeta = {
+                config: {
+                    distribution: 'private',
+                    auth: { type: 'oauth' },
+                },
+            };
+            const mockPromptResponse = {
+                componentTemplate: [mockComponentTemplate],
+            };
+            mockedGetConfigForPlatformVersion.mockResolvedValue(mockConfig);
+            mockedGetProjectMetadata.mockResolvedValue(mockProjectMetadata);
+            mockedFs.readFileSync.mockReturnValue(JSON.stringify(mockAppMeta));
+            mockedProjectAddPromptV3.mockResolvedValue(mockPromptResponse);
+            mockedCloneGithubRepo.mockRejectedValue(new Error('Clone failed'));
+            await expect((0, v3AddComponent_1.v3AddComponent)(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(en_1.commands.project.add.error.failedToDownloadComponent);
+        });
+    });
+});

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

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