@hubspot/cli 7.6.0-beta.1 → 7.6.0-beta.10

package/lib/projects/components.js

@@ -1,22 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleComponentCollision = handleComponentCollision;
-const path_1 = __importDefault(require("path"));
-const fs_1 = __importDefault(require("fs"));
-const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+import path from 'path';
+import fs from 'fs';
+import { metafileExtension } from '@hubspot/project-parsing-lib';
 // Handles a collision between component source files
-function handleComponentCollision({ dest, src, collisions }) {
+export function handleComponentCollision({ dest, src, collisions }) {
     const hsMetaFiles = [];
     const packageJsonFiles = [];
     const sourceFiles = [];
     collisions.forEach(collision => {
-        if (collision.endsWith(project_parsing_lib_1.metafileExtension)) {
+        if (collision.endsWith(metafileExtension)) {
             hsMetaFiles.push(collision);
         }
-        else if (path_1.default.parse(collision).base === 'package.json') {
+        else if (path.parse(collision).base === 'package.json') {
             packageJsonFiles.push(collision);
         }
         else {
@@ -24,18 +18,18 @@ function handleComponentCollision({ dest, src, collisions }) {
         }
     });
     const sourceFilenameMapping = sourceFiles.reduce((acc, filename) => {
-        const { name, ext, dir } = path_1.default.parse(filename);
+        const { name, ext, dir } = path.parse(filename);
         return {
             ...acc,
-            [filename]: path_1.default.join(dir, `${name}-${Date.now()}${ext}`),
+            [filename]: path.join(dir, `${name}-${Date.now()}${ext}`),
         };
     }, {});
-    const metafileExtensionPrefix = path_1.default.parse(project_parsing_lib_1.metafileExtension).name;
+    const metafileExtensionPrefix = path.parse(metafileExtension).name;
     const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
-        const { name, dir } = path_1.default.parse(filename);
+        const { name, dir } = path.parse(filename);
         return {
             ...acc,
-            [filename]: path_1.default.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${project_parsing_lib_1.metafileExtension}`),
+            [filename]: path.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${Date.now()}${metafileExtension}`),
         };
     }, {});
     // Update the metafiles that might contain references to the old filenames
@@ -50,25 +44,25 @@ function handleComponentCollision({ dest, src, collisions }) {
     });
     // Copy the renamed files into their new destination location
     Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
-        fs_1.default.copyFileSync(path_1.default.join(src, key), path_1.default.join(dest, value));
+        fs.copyFileSync(path.join(src, key), path.join(dest, value));
     });
     if (packageJsonFiles.length) {
         handlePackageJsonCollisions(dest, src, packageJsonFiles);
     }
 }
 function updateMetaFile({ dest, src, file, sourceFilenameMapping, metaFilenameMapping, }) {
-    let text = fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8');
+    let text = fs.readFileSync(path.join(src, file), 'utf-8');
     Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
-        const { base: oldFileName } = path_1.default.parse(key);
-        const { base: newFileName } = path_1.default.parse(value);
+        const { base: oldFileName } = path.parse(key);
+        const { base: newFileName } = path.parse(value);
         text = text.replace(oldFileName, newFileName);
     });
-    fs_1.default.writeFileSync(path_1.default.join(dest, metaFilenameMapping[file]), text);
+    fs.writeFileSync(path.join(dest, metaFilenameMapping[file]), text);
 }
 function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
     packageJsonFiles.forEach(file => {
-        const existingPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(dest, file), 'utf-8'));
-        const newPackageJsonContents = JSON.parse(fs_1.default.readFileSync(path_1.default.join(src, file), 'utf-8'));
+        const existingPackageJsonContents = JSON.parse(fs.readFileSync(path.join(dest, file), 'utf-8'));
+        const newPackageJsonContents = JSON.parse(fs.readFileSync(path.join(src, file), 'utf-8'));
         existingPackageJsonContents.dependencies = {
             ...newPackageJsonContents.dependencies,
             ...existingPackageJsonContents.dependencies,
@@ -77,6 +71,6 @@ function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
             ...newPackageJsonContents.devDependencies,
             ...existingPackageJsonContents.devDependencies,
         };
-        fs_1.default.writeFileSync(path_1.default.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
+        fs.writeFileSync(path.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
     });
 }

package/lib/projects/config.d.ts

@@ -1,4 +1,4 @@
-import { ProjectConfig } from '../../types/Projects';
+import { ProjectConfig } from '../../types/Projects.js';
 export declare function writeProjectConfig(configPath: string, config: ProjectConfig): boolean;
 export declare function getIsInProject(dir?: string): boolean;
 export interface LoadedProjectConfig {

package/lib/projects/config.js

@@ -1,79 +1,70 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeProjectConfig = writeProjectConfig;
-exports.getIsInProject = getIsInProject;
-exports.getProjectConfig = getProjectConfig;
-exports.validateProjectConfig = validateProjectConfig;
-const fs_extra_1 = __importDefault(require("fs-extra"));
-const path_1 = __importDefault(require("path"));
-const findup_sync_1 = __importDefault(require("findup-sync"));
-const path_2 = require("@hubspot/local-dev-lib/path");
-const constants_1 = require("../constants");
-const en_1 = require("../../lang/en");
-const exitCodes_1 = require("../enums/exitCodes");
-const logger_1 = require("../ui/logger");
-function writeProjectConfig(configPath, config) {
+import fs from 'fs-extra';
+import path from 'path';
+import findup from 'findup-sync';
+import { getAbsoluteFilePath, getCwd } from '@hubspot/local-dev-lib/path';
+import { PROJECT_CONFIG_FILE } from '../constants.js';
+import { lib } from '../../lang/en.js';
+import { EXIT_CODES } from '../enums/exitCodes.js';
+import { uiLogger } from '../ui/logger.js';
+export function writeProjectConfig(configPath, config) {
     try {
-        fs_extra_1.default.ensureFileSync(configPath);
-        fs_extra_1.default.writeFileSync(configPath, JSON.stringify(config, null, 2));
-        logger_1.uiLogger.debug(`Wrote project config at ${configPath}`);
+        fs.ensureFileSync(configPath);
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        uiLogger.debug(`Wrote project config at ${configPath}`);
     }
     catch (e) {
-        logger_1.uiLogger.debug(e);
+        uiLogger.debug(e);
         return false;
     }
     return true;
 }
-function getIsInProject(dir) {
+export function getIsInProject(dir) {
     const configPath = getProjectConfigPath(dir);
     return !!configPath;
 }
 function getProjectConfigPath(dir) {
-    const projectDir = dir ? (0, path_2.getAbsoluteFilePath)(dir) : (0, path_2.getCwd)();
-    const configPath = (0, findup_sync_1.default)(constants_1.PROJECT_CONFIG_FILE, {
+    const projectDir = dir ? getAbsoluteFilePath(dir) : getCwd();
+    const configPath = findup(PROJECT_CONFIG_FILE, {
         cwd: projectDir,
         nocase: true,
     });
     return configPath;
 }
-async function getProjectConfig(dir) {
+export async function getProjectConfig(dir) {
     const configPath = getProjectConfigPath(dir);
     if (!configPath) {
         return { projectConfig: null, projectDir: null };
     }
     try {
-        const config = fs_extra_1.default.readFileSync(configPath);
+        const config = fs.readFileSync(configPath);
         const projectConfig = JSON.parse(config.toString());
         return {
-            projectDir: path_1.default.dirname(configPath),
+            projectDir: path.dirname(configPath),
             projectConfig,
         };
     }
     catch (e) {
-        logger_1.uiLogger.error(en_1.lib.projects.getProjectConfig.error);
+        uiLogger.error(lib.projects.getProjectConfig.error);
         return { projectConfig: null, projectDir: null };
     }
 }
-function validateProjectConfig(projectConfig, projectDir) {
+export function validateProjectConfig(projectConfig, projectDir) {
     if (!projectConfig || !projectDir) {
-        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.configNotFound);
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.error(lib.projects.validateProjectConfig.configNotFound);
+        return process.exit(EXIT_CODES.ERROR);
     }
     if (!projectConfig.name || !projectConfig.srcDir) {
-        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.configMissingFields);
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        uiLogger.error(lib.projects.validateProjectConfig.configMissingFields);
+        return process.exit(EXIT_CODES.ERROR);
     }
-    const resolvedPath = path_1.default.resolve(projectDir, projectConfig.srcDir);
+    const resolvedPath = path.resolve(projectDir, projectConfig.srcDir);
     if (!resolvedPath.startsWith(projectDir)) {
-        const projectConfigFile = path_1.default.relative('.', path_1.default.join(projectDir, constants_1.PROJECT_CONFIG_FILE));
-        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+        const projectConfigFile = path.relative('.', path.join(projectDir, PROJECT_CONFIG_FILE));
+        uiLogger.error(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
+        return process.exit(EXIT_CODES.ERROR);
     }
-    if (!fs_extra_1.default.existsSync(resolvedPath)) {
-        logger_1.uiLogger.error(en_1.lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
-        return process.exit(exitCodes_1.EXIT_CODES.ERROR);
+    if (!fs.existsSync(resolvedPath)) {
+        uiLogger.error(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
+        return process.exit(EXIT_CODES.ERROR);
     }
 }

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

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

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 { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
-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;
@@ -19,5 +19,6 @@ export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<Proje
     distribution?: string;
     repoConfig?: ProjectTemplateRepoConfig;
     projectContents?: string;
-    createProjectPromptResponse: CreateProjectPromptResponse;
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
+    projectNameAndDestPromptResponse: ProjectNameAndDestPromptResponse;
 }>;

package/lib/projects/create/index.js

@@ -1,33 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleProjectCreationFlow = handleProjectCreationFlow;
-const createProjectPrompt_1 = require("../../prompts/createProjectPrompt");
-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 { DEFAULT_PROJECT_TEMPLATE_BRANCH, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, EMPTY_PROJECT, } from '../../constants.js';
+import { useV3Api } from '../buildAndDeploy.js';
+import { 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;
-    if ((0, buildAndDeploy_1.useV3Api)(platformVersion)) {
-        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await (0, v3_1.v3ComponentFlow)(platformVersion, projectBase, providedAuth, providedDistribution);
-        const createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(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,
             repoConfig,
             projectContents,
-            createProjectPromptResponse,
+            selectProjectTemplatePromptResponse,
+            projectNameAndDestPromptResponse,
         };
     }
-    const projectTemplates = await (0, legacy_1.getProjectTemplateListFromRepo)(repo, 'main');
+    const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     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 createProjectPromptResponse = await (0, createProjectPrompt_1.createProjectPrompt)(args, projectTemplates);
-    return { createProjectPromptResponse };
+    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 { DEFAULT_PROJECT_TEMPLATE_BRANCH, 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`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
     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,23 +1,22 @@
-import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects';
-import { ProjectMetadata } from '@hubspot/project-parsing-lib/src/lib/project';
-import { CreateProjectPromptResponse } from '../../prompts/createProjectPrompt';
-export declare const EMPTY_PROJECT = "empty";
-export declare const PROJECT_WITH_APP = "app";
+import { Separator } from '@inquirer/prompts';
+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 function createV3App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
     authType: string;
     distribution: string;
 }>;
-export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): ComponentTemplateChoice[];
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, projectMetadata?: ProjectMetadata): (ComponentTemplateChoice | Separator)[];
 type V3ComponentInfo = {
     authType?: string;
     distribution?: string;
     repoConfig?: ProjectTemplateRepoConfig;
     projectContents?: string;
-    componentTemplateChoices?: ComponentTemplateChoice[];
+    componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
 };
 export declare function v3ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined): Promise<V3ComponentInfo>;
-export declare function generateComponentPaths({ createProjectPromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
-    createProjectPromptResponse: CreateProjectPromptResponse;
+export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
     platformVersion: string;
     repoConfig?: ProjectTemplateRepoConfig;
     projectContents?: string;