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

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

@@ -0,0 +1,204 @@
+import { legacyAddComponent } from '../legacyAddComponent.js';
+import { findProjectComponents } from '../../structure.js';
+import { getProjectComponentListFromRepo } from '../../create/legacy.js';
+import { projectAddPrompt } from '../../../prompts/projectAddPrompt.js';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { ComponentTypes, } from '../../../../types/Projects.js';
+import { commands } from '../../../../lang/en.js';
+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(findProjectComponents);
+const mockedGetProjectComponentListFromRepo = vi.mocked(getProjectComponentListFromRepo);
+const mockedProjectAddPrompt = vi.mocked(projectAddPrompt);
+const mockedLogger = vi.mocked(logger);
+const mockedCloneGithubRepo = vi.mocked(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: 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 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(commands.project.add.creatingComponent('test-project'));
+            expect(mockedLogger.success).toHaveBeenCalledWith(commands.project.add.success('new-component'));
+        });
+        it('throws an error when project contains a public app', async () => {
+            const mockComponents = [
+                {
+                    type: 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(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(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 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: 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(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(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: 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(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToFetchComponentList);
+            expect(mockedProjectAddPrompt).not.toHaveBeenCalled();
+            expect(mockedCloneGithubRepo).not.toHaveBeenCalled();
+        });
+        it('throws an error when cloning fails', async () => {
+            const mockComponents = [
+                {
+                    type: 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(legacyAddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(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,185 @@
+import fs from 'fs';
+import { v3AddComponent } from '../v3AddComponent.js';
+import { getConfigForPlatformVersion } from '../../create/legacy.js';
+import { createV3App } from '../../create/v3.js';
+import { confirmPrompt } from '../../../prompts/promptUtils.js';
+import { projectAddPromptV3 } from '../../../prompts/projectAddPrompt.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { logger } from '@hubspot/local-dev-lib/logger';
+import { getProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { commands } from '../../../../lang/en.js';
+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);
+const mockedGetConfigForPlatformVersion = vi.mocked(getConfigForPlatformVersion);
+const mockedConfirmPrompt = vi.mocked(confirmPrompt);
+const mockedCreateV3App = vi.mocked(createV3App);
+const mockedProjectAddPromptV3 = vi.mocked(projectAddPromptV3);
+const mockedCloneGithubRepo = vi.mocked(cloneGithubRepo);
+const mockedLogger = vi.mocked(logger);
+const mockedGetProjectMetadata = vi.mocked(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 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 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 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(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(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(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(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(v3AddComponent(mockArgs, projectDir, mockProjectConfig)).rejects.toThrow(commands.project.add.error.failedToDownloadComponent);
+        });
+    });
+});

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

@@ -1,4 +1,4 @@
-import { ProjectConfig } from '../../../types/Projects';
+import { ProjectConfig } from '../../../types/Projects.js';
 export declare function legacyAddComponent(args: {
     name?: string;
     type?: string;

package/lib/projects/add/legacyAddComponent.js

@@ -1,48 +1,42 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.legacyAddComponent = legacyAddComponent;
-const Projects_1 = require("../../../types/Projects");
-const structure_1 = require("../structure");
-const errorHandlers_1 = require("../../errorHandlers");
-const en_1 = require("../../../lang/en");
-const legacy_1 = require("../create/legacy");
-const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
-const path_1 = __importDefault(require("path"));
-const constants_1 = require("../../constants");
-const github_1 = require("@hubspot/local-dev-lib/github");
-const logger_1 = require("../../ui/logger");
-async function legacyAddComponent(args, projectDir, projectConfig) {
+import { ComponentTypes } from '../../../types/Projects.js';
+import { findProjectComponents } from '../structure.js';
+import { debugError } from '../../errorHandlers/index.js';
+import { commands } from '../../../lang/en.js';
+import { getProjectComponentListFromRepo } from '../create/legacy.js';
+import { projectAddPrompt } from '../../prompts/projectAddPrompt.js';
+import path from 'path';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } from '../../constants.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { uiLogger } from '../../ui/logger.js';
+export async function legacyAddComponent(args, projectDir, projectConfig) {
     // We currently only support adding private apps to projects
     let projectContainsPublicApp = false;
     try {
-        const components = await (0, structure_1.findProjectComponents)(projectDir);
-        projectContainsPublicApp = components.some(c => c.type === Projects_1.ComponentTypes.PublicApp);
+        const components = await findProjectComponents(projectDir);
+        projectContainsPublicApp = components.some(c => c.type === ComponentTypes.PublicApp);
     }
     catch (err) {
-        (0, errorHandlers_1.debugError)(err);
+        debugError(err);
     }
     if (projectContainsPublicApp) {
-        throw new Error(en_1.commands.project.add.error.projectContainsPublicApp);
+        throw new Error(commands.project.add.error.projectContainsPublicApp);
     }
-    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
-    const components = await (0, legacy_1.getProjectComponentListFromRepo)(projectConfig.platformVersion);
+    uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
+    const components = await getProjectComponentListFromRepo(projectConfig.platformVersion);
     if (!components || !components.length) {
-        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+        throw new Error(commands.project.add.error.failedToFetchComponentList);
     }
-    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPrompt)(components, args);
+    const projectAddPromptResponse = await projectAddPrompt(components, args);
     try {
-        const componentPath = path_1.default.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
-        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
+        const componentPath = path.join(projectDir, projectConfig.srcDir, projectAddPromptResponse.name);
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, componentPath, {
             sourceDir: projectAddPromptResponse.componentTemplate.path,
             branch: 'main',
             hideLogs: true,
         });
-        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.name));
+        uiLogger.success(commands.project.add.success(projectAddPromptResponse.name));
     }
     catch (error) {
-        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent);
+        throw new Error(commands.project.add.error.failedToDownloadComponent);
     }
 }

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

@@ -1,4 +1,4 @@
-import { ProjectConfig } from '../../../types/Projects';
+import { ProjectConfig } from '../../../types/Projects.js';
 export declare function v3AddComponent(args: {
     name?: string;
     type?: string;

package/lib/projects/add/v3AddComponent.js

@@ -1,88 +1,82 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.v3AddComponent = v3AddComponent;
-const en_1 = require("../../../lang/en");
-const legacy_1 = require("../create/legacy");
-const v3_1 = require("../create/v3");
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const projectAddPrompt_1 = require("../../prompts/projectAddPrompt");
-const constants_1 = require("../../constants");
-const components_1 = require("../components");
-const project_1 = require("@hubspot/project-parsing-lib/src/lib/project");
-const constants_2 = require("@hubspot/project-parsing-lib/src/lib/constants");
-const github_1 = require("@hubspot/local-dev-lib/github");
-const errorHandlers_1 = require("../../errorHandlers");
-const logger_1 = require("../../ui/logger");
-async function v3AddComponent(args, projectDir, projectConfig) {
-    logger_1.uiLogger.log(en_1.commands.project.add.creatingComponent(projectConfig.name));
-    const config = await (0, legacy_1.getConfigForPlatformVersion)(projectConfig.platformVersion);
+import { commands, lib } from '../../../lang/en.js';
+import { getConfigForPlatformVersion } from '../create/legacy.js';
+import { calculateComponentTemplateChoices, createV3App, PROJECT_WITH_APP, } from '../create/v3.js';
+import path from 'path';
+import fs from 'fs';
+import { projectAddPromptV3 } from '../../prompts/projectAddPrompt.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } from '../../constants.js';
+import { handleComponentCollision } from '../components.js';
+import { getProjectMetadata, } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { AppKey } from '@hubspot/project-parsing-lib/src/lib/constants.js';
+import { cloneGithubRepo } from '@hubspot/local-dev-lib/github';
+import { debugError } from '../../errorHandlers/index.js';
+import { uiLogger } from '../../ui/logger.js';
+export async function v3AddComponent(args, projectDir, projectConfig) {
+    uiLogger.log(commands.project.add.creatingComponent(projectConfig.name));
+    const config = await getConfigForPlatformVersion(projectConfig.platformVersion);
     const { components, parentComponents } = config;
     if (!components || !components.length) {
-        throw new Error(en_1.commands.project.add.error.failedToFetchComponentList);
+        throw new Error(commands.project.add.error.failedToFetchComponentList);
     }
-    const projectSrcDirectory = path_1.default.join(projectDir, projectConfig.srcDir);
-    const projectMetadata = await (0, project_1.getProjectMetadata)(projectSrcDirectory);
+    const projectSrcDirectory = path.join(projectDir, projectConfig.srcDir);
+    const projectMetadata = await getProjectMetadata(projectSrcDirectory);
     let derivedAuthType;
     let derivedDistribution;
-    const appsMetadata = projectMetadata.components[constants_2.AppKey];
+    const appsMetadata = projectMetadata.components[AppKey];
     const shouldCreateApp = appsMetadata.count === 0;
     if (shouldCreateApp) {
-        const { authType, distribution } = await (0, v3_1.createV3App)(args.auth, args.distribution);
+        const { authType, distribution } = await createV3App(args.auth, args.distribution);
         derivedDistribution = distribution;
         derivedAuthType = authType;
     }
     else if (appsMetadata.count > appsMetadata.maxCount) {
-        throw new Error(en_1.lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
+        throw new Error(lib.projects.create.errors.exceededMaxNumberOfApps(appsMetadata.maxCount));
     }
     else {
         const apps = appsMetadata.hsMetaFiles.map(appLoc => {
             try {
-                return JSON.parse(fs_1.default.readFileSync(appLoc, 'utf8'));
+                return JSON.parse(fs.readFileSync(appLoc, 'utf8'));
             }
             catch (err) {
-                throw new Error(en_1.lib.projects.create.errors.unableToParseAppConfig(appLoc));
+                throw new Error(lib.projects.create.errors.unableToParseAppConfig(appLoc));
             }
         });
         derivedDistribution = apps[0].config?.distribution;
         derivedAuthType = apps[0].config?.auth?.type;
     }
-    const componentTemplateChoices = (0, v3_1.calculateComponentTemplateChoices)(components, derivedAuthType, derivedDistribution, projectMetadata);
-    const projectAddPromptResponse = await (0, projectAddPrompt_1.projectAddPromptV3)(componentTemplateChoices, args.features);
+    const componentTemplateChoices = calculateComponentTemplateChoices(components, derivedAuthType, derivedDistribution, projectMetadata);
+    const projectAddPromptResponse = await projectAddPromptV3(componentTemplateChoices, args.features);
     try {
         const components = projectAddPromptResponse.componentTemplate?.map((componentTemplate) => {
-            return path_1.default.join(projectConfig.platformVersion, componentTemplate.path);
+            return path.join(projectConfig.platformVersion, componentTemplate.path);
         }) || [];
         if (shouldCreateApp) {
             const parentComponent = parentComponents?.find(possibleParent => {
-                return (possibleParent.type === v3_1.PROJECT_WITH_APP &&
+                return (possibleParent.type === PROJECT_WITH_APP &&
                     possibleParent.authType === derivedAuthType &&
                     possibleParent.distribution === derivedDistribution);
             });
             if (parentComponent) {
-                components.push(path_1.default.join(projectConfig.platformVersion, parentComponent.path));
+                components.push(path.join(projectConfig.platformVersion, parentComponent.path));
             }
         }
         if (components.length === 0) {
-            logger_1.uiLogger.log(en_1.lib.projects.add.nothingAdded);
+            uiLogger.log(lib.projects.add.nothingAdded);
             return;
         }
-        await (0, github_1.cloneGithubRepo)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
+        await cloneGithubRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, projectDir, {
             sourceDir: components,
             hideLogs: true,
             branch: 'main',
-            handleCollision: components_1.handleComponentCollision,
+            handleCollision: handleComponentCollision,
         });
-        logger_1.uiLogger.success(en_1.commands.project.add.success(projectAddPromptResponse.componentTemplate
+        uiLogger.success(commands.project.add.success(projectAddPromptResponse.componentTemplate
             .map(template => `'${template.label}'`)
             .join(', '), projectAddPromptResponse.componentTemplate.length > 1));
     }
     catch (error) {
-        (0, errorHandlers_1.debugError)(error);
-        throw new Error(en_1.commands.project.add.error.failedToDownloadComponent, {
+        debugError(error);
+        throw new Error(commands.project.add.error.failedToDownloadComponent, {
             cause: error,
         });
     }

package/lib/projects/buildAndDeploy.d.ts

@@ -1,7 +1,7 @@
 import { FileResult } from 'tmp';
 import { Build } from '@hubspot/local-dev-lib/types/Build';
 import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
-import { ProjectConfig, ProjectTask, ProjectPollResult } from '../../types/Projects';
+import { ProjectConfig, ProjectTask, ProjectPollResult } from '../../types/Projects.js';
 export declare function useV3Api(platformVersion?: string | null): boolean;
 type PollTaskStatusFunction<T extends ProjectTask> = (accountId: number, taskName: string, taskId: number, deployedBuildId: number | null, silenceLogs?: boolean) => Promise<T>;
 export declare const pollBuildStatus: PollTaskStatusFunction<Build>;