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

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

@@ -0,0 +1,91 @@
+import { logger } from '@hubspot/local-dev-lib/logger';
+import * as github from '@hubspot/local-dev-lib/api/github';
+import { EXIT_CODES } from '../../../enums/exitCodes.js';
+import { getProjectComponentListFromRepo, getProjectTemplateListFromRepo, } from '../legacy.js';
+import { PROJECT_COMPONENT_TYPES, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../../../constants.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/github');
+const mockedFetchRepoFile = vi.mocked(github.fetchRepoFile);
+const repoConfig = {
+    [PROJECT_COMPONENT_TYPES.COMPONENTS]: [
+        {
+            label: 'Component 1',
+            path: 'component1',
+            type: 'Component',
+        },
+    ],
+    [PROJECT_COMPONENT_TYPES.PROJECTS]: [
+        {
+            name: 'project1',
+            label: 'Project 1',
+            path: 'project1',
+        },
+    ],
+};
+describe('lib/projects/create/legacy', () => {
+    describe('getProjectComponentListFromRepo()', () => {
+        it('returns a list of components', async () => {
+            // @ts-expect-error - Mocking AxiosResponse
+            mockedFetchRepoFile.mockResolvedValue({
+                data: repoConfig,
+            });
+            const components = await getProjectComponentListFromRepo('gh-ref');
+            expect(components).toEqual(repoConfig[PROJECT_COMPONENT_TYPES.COMPONENTS]);
+        });
+        it('returns an empty list if no components are found', async () => {
+            mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
+            const components = await getProjectComponentListFromRepo('gh-ref');
+            expect(components).toEqual([]);
+        });
+    });
+    describe('getProjectTemplateListFromRepo()', () => {
+        let exitMock;
+        beforeEach(() => {
+            // @ts-expect-error - Mocking process.exit
+            exitMock = vi
+                .spyOn(process, 'exit')
+                .mockImplementation(() => undefined);
+        });
+        afterEach(() => {
+            exitMock.mockRestore();
+        });
+        it('returns a list of project templates', async () => {
+            // @ts-expect-error - Mocking AxiosResponse
+            mockedFetchRepoFile.mockResolvedValue({
+                data: repoConfig,
+            });
+            const templates = await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
+            expect(templates).toEqual(repoConfig[PROJECT_COMPONENT_TYPES.PROJECTS]);
+        });
+        it('Logs an error and exits the process if the request for the template list fails', async () => {
+            mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
+            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Failed to fetch the config.json file from the target repository/));
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('Logs an error and exits the process if there are no projects listed in the repo config', async () => {
+            // @ts-expect-error - Mocking AxiosResponse
+            mockedFetchRepoFile.mockResolvedValue({});
+            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Unable to find any projects in the target repository's config.json file/));
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+        it('Logs an error and exits the process if any of the projects in the repo config are missing required properties', async () => {
+            // @ts-expect-error - Mocking AxiosResponse
+            mockedFetchRepoFile.mockResolvedValue({
+                data: {
+                    ...repoConfig,
+                    [PROJECT_COMPONENT_TYPES.PROJECTS]: [
+                        {
+                            name: 'project1',
+                            label: 'Project 1',
+                        },
+                    ],
+                },
+            });
+            await getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref');
+            expect(logger.error).toHaveBeenCalledWith(expect.stringMatching(/Found misconfigured projects in the target repository's config.json file/));
+            expect(exitMock).toHaveBeenCalledWith(EXIT_CODES.ERROR);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,78 @@
+import { calculateComponentTemplateChoices } from '../v3.js';
+vi.mock('@hubspot/local-dev-lib/logger');
+vi.mock('@hubspot/local-dev-lib/api/github');
+describe('lib/projects/create/v3', () => {
+    describe('calculateComponentTemplateChoices()', () => {
+        const mockComponents = [
+            {
+                label: 'Module Component',
+                path: 'module',
+                type: 'module',
+                supportedAuthTypes: ['oauth'],
+                supportedDistributions: ['private'],
+            },
+            {
+                label: 'Card Component',
+                path: 'card',
+                type: 'card',
+                supportedAuthTypes: ['oauth', 'static'],
+                supportedDistributions: ['private', 'marketplace'],
+            },
+        ];
+        const mockProjectMetadataForChoices = {
+            hsMetaFiles: [],
+            components: {
+                module: { count: 0, maxCount: 5, hsMetaFiles: [] },
+                card: { count: 3, maxCount: 3, hsMetaFiles: [] },
+            },
+        };
+        it('returns enabled components when they meet all requirements', () => {
+            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', mockProjectMetadataForChoices);
+            expect(choices).toHaveLength(3); // includes separator
+            expect(choices[0]).toEqual({
+                name: 'Module Component',
+                value: mockComponents[0],
+            });
+            expect(choices[2]).toEqual({
+                name: expect.stringContaining('Card Component'),
+                value: mockComponents[1],
+                disabled: expect.stringContaining('maximum'),
+            });
+        });
+        it('disables components when auth type is not supported', () => {
+            const choices = calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', mockProjectMetadataForChoices);
+            // All components should be disabled, so they come after the separator
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Module Component'),
+                value: mockComponents[0],
+                disabled: expect.stringContaining('privatekey'),
+            });
+        });
+        it('disables components when distribution is not supported', () => {
+            const choices = calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', mockProjectMetadataForChoices);
+            // All components should be disabled, so they come after the separator
+            expect(choices[1]).toEqual({
+                name: expect.stringContaining('Module Component'),
+                value: mockComponents[0],
+                disabled: expect.stringContaining('enterprise'),
+            });
+        });
+        it('handles components without auth type or distribution restrictions', () => {
+            const componentsWithoutRestrictions = [
+                {
+                    label: 'Unrestricted Component',
+                    path: 'unrestricted',
+                    type: 'module',
+                },
+            ];
+            const choices = calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', {
+                hsMetaFiles: [],
+                components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
+            });
+            expect(choices[0]).toEqual({
+                name: 'Unrestricted Component',
+                value: componentsWithoutRestrictions[0],
+            });
+        });
+    });
+});

package/lib/projects/create/index.d.ts

@@ -1,7 +1,7 @@
 import { ArgumentsCamelCase } from 'yargs';
-import { ProjectTemplateRepoConfig } from '../../../types/Projects';
-import { SelectProjectTemplatePromptResponse, ProjectNameAndDestPromptResponse } from '../../prompts/selectProjectTemplatePrompt';
-import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs';
+import { ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+import { SelectProjectTemplatePromptResponse, ProjectNameAndDestPromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
+import { AccountArgs, CommonArgs, ConfigArgs, EnvironmentArgs } from '../../../types/Yargs.js';
 import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
 export type ProjectCreateArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
     name?: string;

package/lib/projects/create/index.js

@@ -1,22 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleProjectCreationFlow = handleProjectCreationFlow;
-const selectProjectTemplatePrompt_1 = require("../../prompts/selectProjectTemplatePrompt");
-const projectNameAndDestPrompt_1 = require("../../prompts/projectNameAndDestPrompt");
-const constants_1 = require("../../constants");
-const buildAndDeploy_1 = require("../buildAndDeploy");
-const v3_1 = require("./v3");
-const legacy_1 = require("./legacy");
-const logger_1 = require("../../ui/logger");
-const en_1 = require("../../../lang/en");
-const exitCodes_1 = require("../../enums/exitCodes");
-async function handleProjectCreationFlow(args) {
+import { selectProjectTemplatePrompt, } from '../../prompts/selectProjectTemplatePrompt.js';
+import { projectNameAndDestPrompt } from '../../prompts/projectNameAndDestPrompt.js';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH } from '../../constants.js';
+import { useV3Api } from '../buildAndDeploy.js';
+import { EMPTY_PROJECT, v3ComponentFlow } from './v3.js';
+import { getProjectTemplateListFromRepo } from './legacy.js';
+import { uiLogger } from '../../ui/logger.js';
+import { commands } from '../../../lang/en.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+export async function handleProjectCreationFlow(args) {
     const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
-    const repo = templateSource || constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
-    const projectNameAndDestPromptResponse = await (0, projectNameAndDestPrompt_1.projectNameAndDestPrompt)(args);
-    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
-        const selectProjectTemplatePromptResponse = await (0, selectProjectTemplatePrompt_1.selectProjectTemplatePrompt)(args, undefined, projectContents !== v3_1.EMPTY_PROJECT ? componentTemplateChoices : undefined);
+    const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
+    if (useV3Api(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution);
+        const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
         return {
             authType,
             distribution,
@@ -26,12 +23,12 @@ async function handleProjectCreationFlow(args) {
             projectNameAndDestPromptResponse,
         };
     }
-    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    const projectTemplates = await getProjectTemplateListFromRepo(repo, 'main');
     if (!projectTemplates.length) {
-        logger_1.uiLogger.error(en_1.commands.project.create.errors.failedToFetchProjectList);
-        process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.error(commands.project.create.errors.failedToFetchProjectList);
+        process.exit(EXIT_CODES.ERROR);
     }
-    const selectProjectTemplatePromptResponse = await (0, selectProjectTemplatePrompt_1.selectProjectTemplatePrompt)(args, projectTemplates);
+    const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
     return {
         selectProjectTemplatePromptResponse,
         projectNameAndDestPromptResponse,

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

@@ -1,5 +1,5 @@
 import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
-import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects';
+import { ProjectTemplate, ComponentTemplate, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
 export declare const EMPTY_PROJECT_TEMPLATE_NAME = "no-template";
 export declare function getConfigForPlatformVersion(platformVersion: string): Promise<ProjectTemplateRepoConfig> | never;
 export declare function getProjectComponentListFromRepo(platformVersion: string): Promise<ComponentTemplate[]>;

package/lib/projects/create/legacy.js

@@ -1,59 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EMPTY_PROJECT_TEMPLATE_NAME = void 0;
-exports.getConfigForPlatformVersion = getConfigForPlatformVersion;
-exports.getProjectComponentListFromRepo = getProjectComponentListFromRepo;
-exports.getProjectTemplateListFromRepo = getProjectTemplateListFromRepo;
-const github_1 = require("@hubspot/local-dev-lib/api/github");
-const constants_1 = require("../../constants");
-const exitCodes_1 = require("../../enums/exitCodes");
-const errorHandlers_1 = require("../../errorHandlers");
-const logger_1 = require("../../ui/logger");
-const buildAndDeploy_1 = require("../buildAndDeploy");
-const en_1 = require("../../../lang/en");
+import { fetchRepoFile } from '@hubspot/local-dev-lib/api/github';
+import { HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, PROJECT_COMPONENT_TYPES, } from '../../constants.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+import { debugError } from '../../errorHandlers/index.js';
+import { uiLogger } from '../../ui/logger.js';
+import { useV3Api } from '../buildAndDeploy.js';
+import { lib } from '../../../lang/en.js';
 const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
-exports.EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
-async function getConfigForPlatformVersion(platformVersion) {
+export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
+export async function getConfigForPlatformVersion(platformVersion) {
     let path = '';
-    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+    if (useV3Api(platformVersion)) {
         path = `${platformVersion}/`;
     }
-    const { data } = await (0, github_1.fetchRepoFile)(constants_1.HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
+    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, 'main');
     return data;
 }
-async function getProjectComponentListFromRepo(platformVersion) {
+export async function getProjectComponentListFromRepo(platformVersion) {
     let config;
     try {
         config = await getConfigForPlatformVersion(platformVersion);
     }
     catch (err) {
-        (0, errorHandlers_1.debugError)(err);
+        debugError(err);
     }
     if (config) {
-        return config[constants_1.PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
+        return config[PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
     }
     return [];
 }
-async function getProjectTemplateListFromRepo(templateSource, githubRef) {
+export async function getProjectTemplateListFromRepo(templateSource, githubRef) {
     let config;
     try {
-        const { data } = await (0, github_1.fetchRepoFile)(templateSource, 'config.json', githubRef);
+        const { data } = await fetchRepoFile(templateSource, 'config.json', githubRef);
         config = data;
     }
     catch (e) {
-        (0, errorHandlers_1.debugError)(e);
-        logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingConfigFileTemplateSource);
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        debugError(e);
+        uiLogger.error(lib.projects.create.errors.missingConfigFileTemplateSource);
+        return process.exit(EXIT_CODES.ERROR);
     }
-    if (!config || !config[constants_1.PROJECT_COMPONENT_TYPES.PROJECTS]) {
-        logger_1.uiLogger.error(en_1.lib.projects.create.errors.noProjectsInConfig);
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
+        uiLogger.error(lib.projects.create.errors.noProjectsInConfig);
+        return process.exit(EXIT_CODES.ERROR);
     }
-    const templates = config[constants_1.PROJECT_COMPONENT_TYPES.PROJECTS];
+    const templates = config[PROJECT_COMPONENT_TYPES.PROJECTS];
     const templatesContainAllProperties = templates.every(config => PROJECT_TEMPLATE_PROPERTIES.every(p => Object.prototype.hasOwnProperty.call(config, p)));
     if (!templatesContainAllProperties) {
-        logger_1.uiLogger.error(en_1.lib.projects.create.errors.missingPropertiesInConfig);
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.error(lib.projects.create.errors.missingPropertiesInConfig);
+        return process.exit(EXIT_CODES.ERROR);
     }
     return templates;
 }

package/lib/projects/create/v3.d.ts

@@ -1,7 +1,7 @@
 import { Separator } from '@inquirer/prompts';
-import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
-import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
-import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project.js';
+import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
 export declare const EMPTY_PROJECT = "empty";
 export declare const PROJECT_WITH_APP = "app";
 export declare function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{

package/lib/projects/create/v3.js

@@ -1,65 +1,55 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PROJECT_WITH_APP = exports.EMPTY_PROJECT = void 0;
-exports.createV3App = createV3App;
-exports.calculateComponentTemplateChoices = calculateComponentTemplateChoices;
-exports.v3ComponentFlow = v3ComponentFlow;
-exports.generateComponentPaths = generateComponentPaths;
-const prompts_1 = require("@inquirer/prompts");
-const constants_1 = require("../../constants");
-const en_1 = require("../../../lang/en");
-const promptUtils_1 = require("../../prompts/promptUtils");
-const chalk_1 = __importDefault(require("chalk"));
-const buildAndDeploy_1 = require("../buildAndDeploy");
-const path_1 = __importDefault(require("path"));
-const legacy_1 = require("./legacy");
-const errorHandlers_1 = require("../../errorHandlers");
-const exitCodes_1 = require("../../enums/exitCodes");
-exports.EMPTY_PROJECT = 'empty';
-exports.PROJECT_WITH_APP = 'app';
-async function createV3App(providedAuth, providedDistribution) {
+import { Separator } from '@inquirer/prompts';
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, } from '../../constants.js';
+import { commands, lib } from '../../../lang/en.js';
+import { listPrompt } from '../../prompts/promptUtils.js';
+import chalk from 'chalk';
+import { useV3Api } from '../buildAndDeploy.js';
+import path from 'path';
+import { getConfigForPlatformVersion } from './legacy.js';
+import { logError } from '../../errorHandlers/index.js';
+import { EXIT_CODES } from '../../enums/exitCodes.js';
+export const EMPTY_PROJECT = 'empty';
+export const PROJECT_WITH_APP = 'app';
+export async function createV3App(providedAuth, providedDistribution) {
     let authType;
     if (providedAuth &&
-        providedDistribution === constants_1.marketplaceDistribution &&
-        providedAuth !== constants_1.oAuth) {
-        throw new Error(en_1.lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+        providedDistribution === marketplaceDistribution &&
+        providedAuth !== oAuth) {
+        throw new Error(lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
     }
     const distribution = providedDistribution ||
-        (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.distribution, {
+        (await listPrompt(lib.projects.create.prompt.distribution, {
             choices: [
                 {
-                    name: en_1.lib.projects.create.prompt.marketPlaceDistribution,
-                    value: constants_1.marketplaceDistribution,
+                    name: lib.projects.create.prompt.marketPlaceDistribution,
+                    value: marketplaceDistribution,
                 },
                 {
-                    name: en_1.lib.projects.create.prompt.privateDistribution,
-                    value: constants_1.privateDistribution,
+                    name: lib.projects.create.prompt.privateDistribution,
+                    value: privateDistribution,
                 },
             ],
         }));
-    if (distribution === constants_1.marketplaceDistribution) {
+    if (distribution === marketplaceDistribution) {
         // This is the only valid auth type for marketplace
-        authType = constants_1.oAuth;
+        authType = oAuth;
     }
     else {
         authType =
             providedAuth ||
-                (await (0, promptUtils_1.listPrompt)(en_1.lib.projects.create.prompt.auth, {
+                (await listPrompt(lib.projects.create.prompt.auth, {
                     choices: [
-                        { name: en_1.lib.projects.create.prompt.staticAuth, value: constants_1.staticAuth },
-                        { name: en_1.lib.projects.create.prompt.oauth, value: constants_1.oAuth },
+                        { name: lib.projects.create.prompt.staticAuth, value: staticAuth },
+                        { name: lib.projects.create.prompt.oauth, value: oAuth },
                     ],
                 }));
     }
     return {
-        distribution,
-        authType,
+        distribution: distribution,
+        authType: authType,
     };
 }
-function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
+export function calculateComponentTemplateChoices(components, authType, distribution, projectMetadata) {
     const enabledComponents = [];
     const disabledComponents = [];
     components.forEach(template => {
@@ -68,22 +58,22 @@ function calculateComponentTemplateChoices(components, authType, distribution, p
         if (projectMetadata) {
             const { count, maxCount } = projectMetadata.components[template.type];
             if (count >= maxCount) {
-                disabledReasons.push(en_1.commands.project.add.error.maxExceeded(maxCount));
+                disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
             }
         }
         if (Array.isArray(supportedAuthTypes) &&
             authType &&
             !supportedAuthTypes.includes(authType)) {
-            disabledReasons.push(en_1.commands.project.add.error.authTypeNotAllowed(authType));
+            disabledReasons.push(commands.project.add.error.authTypeNotAllowed(authType));
         }
         if (Array.isArray(supportedDistributions) &&
             distribution &&
             !supportedDistributions.includes(distribution)) {
-            disabledReasons.push(en_1.commands.project.add.error.distributionNotAllowed(distribution));
+            disabledReasons.push(commands.project.add.error.distributionNotAllowed(distribution));
         }
         if (disabledReasons.length > 0) {
             disabledComponents.push({
-                name: `[${chalk_1.default.yellow('DISABLED')}] ${template.label}`,
+                name: `[${chalk.yellow('DISABLED')}] ${template.label}`,
                 value: template,
                 disabled: disabledReasons.join(' '),
             });
@@ -96,31 +86,31 @@ function calculateComponentTemplateChoices(components, authType, distribution, p
         }
     });
     return disabledComponents.length
-        ? [...enabledComponents, new prompts_1.Separator(), ...disabledComponents]
+        ? [...enabledComponents, new Separator(), ...disabledComponents]
         : [...enabledComponents];
 }
-async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
+export async function v3ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution) {
     let repoConfig = undefined;
     let authType;
     let distribution;
     try {
-        repoConfig = await (0, legacy_1.getConfigForPlatformVersion)(platformVersion);
+        repoConfig = await getConfigForPlatformVersion(platformVersion);
     }
     catch (error) {
-        (0, errorHandlers_1.logError)(error);
-        return process.exit(exitCodes_1.EXIT_CODES.SUCCESS);
+        logError(error);
+        return process.exit(EXIT_CODES.SUCCESS);
     }
     const projectContentsChoice = projectBase ||
-        (await (0, promptUtils_1.listPrompt)(en_1.commands.project.create.prompts.parentComponents, {
+        (await listPrompt(commands.project.create.prompts.parentComponents, {
             choices: [
                 {
-                    name: en_1.commands.project.create.prompts.emptyProject,
-                    value: exports.EMPTY_PROJECT,
+                    name: commands.project.create.prompts.emptyProject,
+                    value: EMPTY_PROJECT,
                 },
-                { name: en_1.commands.project.create.prompts.app, value: exports.PROJECT_WITH_APP },
+                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
             ],
         }));
-    if (projectContentsChoice === exports.PROJECT_WITH_APP) {
+    if (projectContentsChoice === PROJECT_WITH_APP) {
         const { authType: selectedAuthType, distribution: selectedDistribution } = await createV3App(providedAuth, providedDistribution);
         authType = selectedAuthType;
         distribution = selectedDistribution;
@@ -134,25 +124,25 @@ async function v3ComponentFlow(platformVersion, projectBase, providedAuth, provi
         repoConfig,
     };
 }
-function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
-    if (!(0, buildAndDeploy_1.useV3Api)(platformVersion)) {
+export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!useV3Api(platformVersion)) {
         return [];
     }
     const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {
-        return path_1.default.join(platformVersion, componentTemplate.path);
+        return path.join(platformVersion, componentTemplate.path);
     }) || [];
-    if (projectContents && projectContents !== exports.EMPTY_PROJECT) {
+    if (projectContents && projectContents !== EMPTY_PROJECT) {
         const parentComponent = repoConfig?.parentComponents?.find(possibleParent => {
             return (possibleParent.type === projectContents &&
                 possibleParent.authType === authType &&
                 possibleParent.distribution === distribution);
         });
         if (parentComponent) {
-            components.push(path_1.default.join(platformVersion, parentComponent.path));
+            components.push(path.join(platformVersion, parentComponent.path));
         }
     }
     if (repoConfig?.defaultFiles) {
-        components.push(path_1.default.join(platformVersion, repoConfig?.defaultFiles));
+        components.push(path.join(platformVersion, repoConfig?.defaultFiles));
     }
     return components;
 }