@hubspot/cli 8.0.10-experimental.6 → 8.0.10-experimental.7

package/lib/projects/components.js

@@ -0,0 +1,252 @@
+import path from 'path';
+import fs from 'fs';
+import { coerceToValidUid } from '@hubspot/project-parsing-lib/uid';
+import { METAFILE_EXTENSION as metafileExtension, APP_KEY as AppKey, } from '@hubspot/project-parsing-lib/constants';
+import { fileExists } from '../validation.js';
+import { uiLogger } from '../ui/logger.js';
+import { lib } from '../../lang/en.js';
+import { debugError } from '../errorHandlers/index.js';
+import { uiLink } from '../ui/index.js';
+import chalk from 'chalk';
+import { renderInline } from '../../ui/render.js';
+import { getSuccessBox } from '../../ui/components/StatusMessageBoxes.js';
+// Prefix for the metafile extension
+const metafileExtensionPrefix = path.parse(metafileExtension).name;
+export function buildProjectTree(projectName, uids, componentsByType, showOnlyNew) {
+    const lines = [];
+    lines.push(chalk.bold(projectName));
+    const types = Array.from(componentsByType.keys());
+    for (const uid of uids) {
+        lines.push(`├─ [app] ${uid}`);
+        for (let i = 0; i < types.length; i++) {
+            const type = types[i];
+            const allComponents = componentsByType.get(type) || [];
+            const components = showOnlyNew
+                ? allComponents.filter(c => c.isNew)
+                : allComponents;
+            if (components.length === 0)
+                continue;
+            const isLastType = i === types.length - 1;
+            const typePrefix = isLastType ? '│  └─' : '│  ├─';
+            const typeConnector = isLastType ? '   ' : '│  ';
+            lines.push(`${typePrefix} ${type}`);
+            for (let j = 0; j < components.length; j++) {
+                const component = components[j];
+                const isLastComponent = j === components.length - 1;
+                const componentPrefix = isLastComponent ? '└─' : '├─';
+                const addedLabel = component.isNew ? chalk.green(' (added)') : '';
+                lines.push(`│  ${typeConnector}${componentPrefix} ${component.filename}${addedLabel}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function buildSuccessMessage(projectName, uids, componentsByType, newComponentsCount, showOnlyNew, isProjectEmpty, projectDest) {
+    const messages = lib.projects.components.buildSuccessMessage;
+    const tree = buildProjectTree(projectName, uids, componentsByType, showOnlyNew);
+    const featureText = `${newComponentsCount} feature${newComponentsCount > 1 ? 's' : ''}`;
+    const uid = uids.length === 1 ? uids[0] : projectName;
+    const docsLink = uiLink(messages.seeOurDocs, messages.docsUrl);
+    const header = projectDest
+        ? messages.headerCreated(projectName, projectDest)
+        : messages.headerAdded(featureText, uid, newComponentsCount > 1);
+    // Use \n\n between sections to create gaps, \n within sections for no gaps
+    const sections = [
+        header,
+        isProjectEmpty ? null : tree,
+        messages.docsDetails(docsLink),
+        `${messages.uploadPrompt}\n${messages.devPrompt}`,
+    ].filter(Boolean);
+    return sections.join('\n\n');
+}
+function applyDifferentiatorToFilename(filename, differentiator, isHsMetaFile) {
+    const { name, ext, dir } = path.parse(filename);
+    if (isHsMetaFile) {
+        return path.join(dir, `${name.replace(metafileExtensionPrefix, '')}-${differentiator}${metafileExtension}`);
+    }
+    return path.join(dir, `${name}-${differentiator}${ext}`);
+}
+// Generates safe filename differentiators, avoiding collisions with existing filenames
+// E.x. "NewCard.tsx" -> "NewCard-1.tsx"
+function generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles) {
+    let differentiator = 1;
+    let isDifferentiatorUnique = false;
+    let maxAttempts = 10;
+    while (!isDifferentiatorUnique) {
+        differentiator++;
+        maxAttempts--;
+        try {
+            const isDifferentiatorUniqueForSourceFiles = sourceFiles.every(file => {
+                return !fileExists(applyDifferentiatorToFilename(file, differentiator, false));
+            });
+            const isDifferentiatorUniqueForHsMetaFiles = hsMetaFiles.every(file => {
+                return !fileExists(applyDifferentiatorToFilename(file, differentiator, true));
+            });
+            isDifferentiatorUnique =
+                isDifferentiatorUniqueForSourceFiles &&
+                    isDifferentiatorUniqueForHsMetaFiles;
+        }
+        catch (error) {
+            uiLogger.debug(lib.projects.generateSafeFilenameDifferentiator.failedToCheckFiles);
+            maxAttempts = 0;
+        }
+        // If we've tried too many times, just use a timestamp
+        if (maxAttempts <= 0) {
+            return Date.now();
+        }
+    }
+    return differentiator;
+}
+// Handles a collision between component source files
+export function handleComponentCollision({ dest, src, collisions }) {
+    const hsMetaFiles = [];
+    const packageJsonFiles = [];
+    const sourceFiles = [];
+    collisions.forEach(collision => {
+        if (collision.endsWith(metafileExtension)) {
+            hsMetaFiles.push(collision);
+        }
+        else if (path.parse(collision).base === 'package.json') {
+            packageJsonFiles.push(collision);
+        }
+        else {
+            sourceFiles.push(collision);
+        }
+    });
+    const filenameDifferentiator = generateSafeFilenameDifferentiator(sourceFiles, hsMetaFiles);
+    const sourceFilenameMapping = sourceFiles
+        .filter(filename => {
+        // Exclude markdown files from the rename process because they should not be duplicated
+        if (filename.endsWith('.md')) {
+            return false;
+        }
+        // Also exclude the tooling config we add to new projects
+        const base = path.parse(filename).base;
+        if (base === '.prettierrc.json' || base === 'eslint.config.js') {
+            return false;
+        }
+        return true;
+    })
+        .reduce((acc, filename) => {
+        return {
+            ...acc,
+            [filename]: applyDifferentiatorToFilename(filename, filenameDifferentiator, false),
+        };
+    }, {});
+    const metaFilenameMapping = hsMetaFiles.reduce((acc, filename) => {
+        return {
+            ...acc,
+            [filename]: applyDifferentiatorToFilename(filename, filenameDifferentiator, true),
+        };
+    }, {});
+    // Update the metafiles that might contain references to the old filenames
+    hsMetaFiles.forEach(file => {
+        updateMetaFile({
+            dest,
+            src,
+            file,
+            sourceFilenameMapping,
+            metaFilenameMapping,
+        });
+    });
+    // Copy the renamed files into their new destination location
+    Object.entries(sourceFilenameMapping).forEach(([key, 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.readFileSync(path.join(src, file), 'utf-8');
+    Object.entries(sourceFilenameMapping).forEach(([key, value]) => {
+        const { base: oldFileName } = path.parse(key);
+        const { base: newFileName } = path.parse(value);
+        text = text.replace(oldFileName, newFileName);
+    });
+    fs.writeFileSync(path.join(dest, metaFilenameMapping[file]), text);
+}
+function handlePackageJsonCollisions(dest, src, packageJsonFiles) {
+    packageJsonFiles.forEach(file => {
+        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,
+        };
+        existingPackageJsonContents.devDependencies = {
+            ...newPackageJsonContents.devDependencies,
+            ...existingPackageJsonContents.devDependencies,
+        };
+        fs.writeFileSync(path.join(dest, file), JSON.stringify(existingPackageJsonContents, null, 2));
+    });
+}
+export async function updateHsMetaFilesWithAutoGeneratedFields(projectName, hsMetaFilePaths, existingUids = [], options) {
+    for (const hsMetaFile of hsMetaFilePaths) {
+        try {
+            const component = JSON.parse(fs.readFileSync(hsMetaFile).toString());
+            const getBaseUid = () => {
+                const customUid = coerceToValidUid(`${projectName}_${component.type}`);
+                if (customUid) {
+                    return customUid.replace(/-/g, '_');
+                }
+                return component.uid;
+            };
+            let uid = getBaseUid();
+            let differentiator = 2;
+            while (existingUids.includes(uid)) {
+                uid = `${getBaseUid()}_${differentiator}`;
+                differentiator++;
+            }
+            component.uid = uid;
+            existingUids.push(uid);
+            if (component.type === AppKey && component.config) {
+                component.config.name = `${projectName}-App`;
+            }
+            fs.writeFileSync(hsMetaFile, JSON.stringify(component, null, 2));
+        }
+        catch (error) {
+            debugError(error);
+            uiLogger.error(lib.projects.updateHsMetaFilesWithAutoGeneratedFields.failedToUpdate(hsMetaFile));
+        }
+    }
+    if (options?.showSuccessMessage && options?.updatedProjectMetadata) {
+        const { currentProjectMetadata, updatedProjectMetadata, isProjectEmpty, projectDest, } = options;
+        const uids = [];
+        const updatedAppsMetadata = updatedProjectMetadata.components[AppKey];
+        // Get UID(s) from -hsmeta.json files
+        if (updatedAppsMetadata?.hsMetaFiles) {
+            updatedAppsMetadata.hsMetaFiles.forEach(appLocation => {
+                try {
+                    const appConfig = JSON.parse(fs.readFileSync(appLocation, 'utf-8'));
+                    uids.push(appConfig.uid || 'unknown app'); // fallback to unknown app incase we can't get uid
+                }
+                catch (err) {
+                    uiLogger.debug(lib.projects.components.unableToGetUidFromHsmeta);
+                }
+            });
+        }
+        // Fallback if no app hsmeta files found or all failed to parse
+        if (uids.length === 0) {
+            uids.push('unknown app');
+        }
+        const componentsByType = new Map();
+        const addComponent = (hsMetaPath, isNew) => {
+            const type = path.basename(path.dirname(hsMetaPath));
+            const existing = componentsByType.get(type) || [];
+            existing.push({ filename: path.basename(hsMetaPath), isNew });
+            componentsByType.set(type, existing);
+        };
+        // Add new files
+        hsMetaFilePaths.forEach(hsMetaFile => addComponent(hsMetaFile, true));
+        if (currentProjectMetadata) {
+            Object.entries(currentProjectMetadata.components)
+                .filter(([type, metadata]) => type !== AppKey && metadata.count > 0)
+                .flatMap(([, metadata]) => metadata.hsMetaFiles)
+                .forEach(hsMetaFile => addComponent(hsMetaFile, false));
+        }
+        const newComponentsCount = hsMetaFilePaths.length;
+        const successMessage = buildSuccessMessage(projectName, uids, componentsByType, newComponentsCount, false, isProjectEmpty, projectDest);
+        await renderInline(getSuccessBox({ title: 'SUCCESS', message: successMessage }));
+    }
+}

package/lib/projects/config.d.ts

@@ -0,0 +1,9 @@
+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 {
+    projectDir: string | null;
+    projectConfig: ProjectConfig | null;
+}
+export declare function getProjectConfig(dir?: string): Promise<LoadedProjectConfig>;
+export declare function validateProjectConfig(projectConfig: ProjectConfig | null, projectDir: string | null): asserts projectConfig is ProjectConfig;

package/lib/projects/config.js

@@ -0,0 +1,73 @@
+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 { uiLogger } from '../ui/logger.js';
+import ProjectValidationError from '../errors/ProjectValidationError.js';
+export function writeProjectConfig(configPath, config) {
+    try {
+        fs.ensureFileSync(configPath);
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+        uiLogger.debug(`Wrote project config at ${configPath}`);
+    }
+    catch (e) {
+        uiLogger.debug(e);
+        return false;
+    }
+    return true;
+}
+export function getIsInProject(dir) {
+    const configPath = getProjectConfigPath(dir);
+    return !!configPath;
+}
+function getProjectConfigPath(dir) {
+    const projectDir = dir ? getAbsoluteFilePath(dir) : getCwd();
+    const configPath = findup(PROJECT_CONFIG_FILE, {
+        cwd: projectDir,
+        nocase: true,
+    });
+    return configPath;
+}
+export async function getProjectConfig(dir) {
+    const configPath = getProjectConfigPath(dir);
+    if (!configPath) {
+        return { projectConfig: null, projectDir: null };
+    }
+    try {
+        const config = fs.readFileSync(configPath);
+        const projectConfig = JSON.parse(config.toString());
+        return {
+            projectDir: path.dirname(configPath),
+            projectConfig,
+        };
+    }
+    catch (e) {
+        uiLogger.error(lib.projects.getProjectConfig.error);
+        return { projectConfig: null, projectDir: null };
+    }
+}
+export function validateProjectConfig(projectConfig, projectDir) {
+    if (!projectConfig || !projectDir) {
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.configNotFound);
+    }
+    const missingFields = [];
+    if (!projectConfig.name) {
+        missingFields.push('name');
+    }
+    if (!projectConfig.srcDir) {
+        missingFields.push('srcDir');
+    }
+    if (missingFields.length > 0) {
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.configMissingFields(missingFields));
+    }
+    const resolvedPath = path.resolve(projectDir, projectConfig.srcDir);
+    if (!resolvedPath.startsWith(projectDir)) {
+        const projectConfigFile = path.relative('.', path.join(projectDir, PROJECT_CONFIG_FILE));
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcOutsideProjectDir(projectConfigFile, projectConfig.srcDir));
+    }
+    if (!fs.existsSync(resolvedPath)) {
+        throw new ProjectValidationError(lib.projects.validateProjectConfig.srcDirNotFound(projectConfig.srcDir, projectDir));
+    }
+}

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

@@ -0,0 +1,24 @@
+import { ArgumentsCamelCase } from '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;
+    dest?: string;
+    templateSource?: RepoPath;
+    template?: string;
+    features?: string[];
+    platformVersion: string;
+    projectBase?: string;
+    auth?: string;
+    distribution?: string;
+};
+export declare function handleProjectCreationFlow(args: ArgumentsCamelCase<ProjectCreateArgs>): Promise<{
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
+    projectNameAndDestPromptResponse: ProjectNameAndDestPromptResponse;
+}>;

package/lib/projects/create/index.js

@@ -0,0 +1,33 @@
+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 { isV2Project } from '../platformVersion.js';
+import { v2ComponentFlow } from './v2.js';
+import { getProjectTemplateListFromRepo } from './legacy.js';
+import { commands } from '../../../lang/en.js';
+export async function handleProjectCreationFlow(args) {
+    const { platformVersion, templateSource, projectBase, auth: providedAuth, distribution: providedDistribution, } = args;
+    const repo = templateSource || HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH;
+    const projectNameAndDestPromptResponse = await projectNameAndDestPrompt(args);
+    if (isV2Project(platformVersion)) {
+        const { componentTemplateChoices, authType, distribution, repoConfig, projectContents, } = await v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, args.derivedAccountId);
+        const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, undefined, projectContents !== EMPTY_PROJECT ? componentTemplateChoices : undefined);
+        return {
+            authType,
+            distribution,
+            repoConfig,
+            projectContents,
+            selectProjectTemplatePromptResponse,
+            projectNameAndDestPromptResponse,
+        };
+    }
+    const projectTemplates = await getProjectTemplateListFromRepo(repo, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+    if (!projectTemplates.length) {
+        throw new Error(commands.project.create.errors.failedToFetchProjectList);
+    }
+    const selectProjectTemplatePromptResponse = await selectProjectTemplatePrompt(args, projectTemplates);
+    return {
+        selectProjectTemplatePromptResponse,
+        projectNameAndDestPromptResponse,
+    };
+}

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

@@ -0,0 +1,6 @@
+import { RepoPath } from '@hubspot/local-dev-lib/types/Github';
+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[]>;
+export declare function getProjectTemplateListFromRepo(templateSource: RepoPath, githubRef: string): Promise<ProjectTemplate[]>;

package/lib/projects/create/legacy.js

@@ -0,0 +1,48 @@
+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 { debugError } from '../../errorHandlers/index.js';
+import { isV2Project } from '../platformVersion.js';
+import { lib } from '../../../lang/en.js';
+const PROJECT_TEMPLATE_PROPERTIES = ['name', 'label', 'path'];
+export const EMPTY_PROJECT_TEMPLATE_NAME = 'no-template';
+export async function getConfigForPlatformVersion(platformVersion) {
+    let path = '';
+    if (isV2Project(platformVersion)) {
+        path = `${platformVersion}/`;
+    }
+    const { data } = await fetchRepoFile(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, `${path}config.json`, DEFAULT_PROJECT_TEMPLATE_BRANCH);
+    return data;
+}
+export async function getProjectComponentListFromRepo(platformVersion) {
+    let config;
+    try {
+        config = await getConfigForPlatformVersion(platformVersion);
+    }
+    catch (err) {
+        debugError(err);
+    }
+    if (config) {
+        return config[PROJECT_COMPONENT_TYPES.COMPONENTS] || [];
+    }
+    return [];
+}
+export async function getProjectTemplateListFromRepo(templateSource, githubRef) {
+    let config;
+    try {
+        const { data } = await fetchRepoFile(templateSource, 'config.json', githubRef);
+        config = data;
+    }
+    catch (e) {
+        debugError(e);
+        throw new Error(lib.projects.create.errors.missingConfigFileTemplateSource);
+    }
+    if (!config || !config[PROJECT_COMPONENT_TYPES.PROJECTS]) {
+        throw new Error(lib.projects.create.errors.noProjectsInConfig);
+    }
+    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) {
+        throw new Error(lib.projects.create.errors.missingPropertiesInConfig);
+    }
+    return templates;
+}

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

@@ -0,0 +1,26 @@
+import { Separator } from '@inquirer/prompts';
+import { ComponentTemplate, ComponentTemplateChoice, ProjectTemplateRepoConfig } from '../../../types/Projects.js';
+import type { ProjectMetadata } from '@hubspot/project-parsing-lib/projects';
+import { SelectProjectTemplatePromptResponse } from '../../prompts/selectProjectTemplatePrompt.js';
+export declare function createV2App(providedAuth: string | undefined, providedDistribution: string | undefined): Promise<{
+    authType: string;
+    distribution: string;
+}>;
+export declare function calculateComponentTemplateChoices(components: ComponentTemplate[], authType: string | undefined, distribution: string | undefined, accountId: number, projectMetadata?: ProjectMetadata): Promise<(ComponentTemplateChoice | Separator)[]>;
+type V2ComponentInfo = {
+    authType?: string;
+    distribution?: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    componentTemplateChoices?: (ComponentTemplateChoice | Separator)[];
+};
+export declare function v2ComponentFlow(platformVersion: string, projectBase: string | undefined, providedAuth: string | undefined, providedDistribution: string | undefined, accountId: number): Promise<V2ComponentInfo>;
+export declare function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }: {
+    selectProjectTemplatePromptResponse: SelectProjectTemplatePromptResponse;
+    platformVersion: string;
+    repoConfig?: ProjectTemplateRepoConfig;
+    projectContents?: string;
+    authType?: string;
+    distribution?: string;
+}): string[];
+export {};

package/lib/projects/create/v2.js

@@ -0,0 +1,158 @@
+import { marketplaceDistribution, oAuth, privateDistribution, staticAuth, EMPTY_PROJECT, PROJECT_WITH_APP, FEATURES, } from '../../constants.js';
+import { commands, lib } from '../../../lang/en.js';
+import { listPrompt } from '../../prompts/promptUtils.js';
+import { APP_EVENTS_KEY as AppEventsKey, PAGES_KEY as PagesKey, } from '@hubspot/project-parsing-lib/constants';
+import { isV2Project } from '../platformVersion.js';
+import path from 'path';
+import { getConfigForPlatformVersion } from './legacy.js';
+import { hasFeature } from '../../hasFeature.js';
+export async function createV2App(providedAuth, providedDistribution) {
+    let authType;
+    if (providedAuth &&
+        providedDistribution === marketplaceDistribution &&
+        providedAuth !== oAuth) {
+        throw new Error(lib.projects.create.errors.invalidAuthDistCombo(providedAuth, providedDistribution));
+    }
+    const distribution = providedDistribution ||
+        (await listPrompt(lib.projects.create.prompt.distribution, {
+            choices: [
+                {
+                    name: lib.projects.create.prompt.marketPlaceDistribution,
+                    value: marketplaceDistribution,
+                },
+                {
+                    name: lib.projects.create.prompt.privateDistribution,
+                    value: privateDistribution,
+                },
+            ],
+        }));
+    if (distribution === marketplaceDistribution) {
+        // This is the only valid auth type for marketplace
+        authType = oAuth;
+    }
+    else {
+        authType =
+            providedAuth ||
+                (await listPrompt(lib.projects.create.prompt.auth, {
+                    choices: [
+                        { name: lib.projects.create.prompt.staticAuth, value: staticAuth },
+                        { name: lib.projects.create.prompt.oauth, value: oAuth },
+                    ],
+                }));
+    }
+    return {
+        distribution: distribution,
+        authType: authType,
+    };
+}
+const componentTypeToGateMap = {
+    [AppEventsKey]: FEATURES.APP_EVENTS,
+    [PagesKey]: FEATURES.APPS_HOME,
+    'workflow-action-tool': FEATURES.AGENT_TOOLS,
+};
+export async function calculateComponentTemplateChoices(components, authType, distribution, accountId, projectMetadata) {
+    const enabledComponents = [];
+    const disabledComponents = [];
+    for (const template of components) {
+        const { supportedAuthTypes, supportedDistributions } = template;
+        const disabledReasons = [];
+        if (projectMetadata) {
+            const componentMetadata = projectMetadata.components[template.type];
+            if (!componentMetadata) {
+                disabledReasons.push(commands.project.add.error.invalidComponentType(template.type));
+            }
+            else {
+                const { count, maxCount } = componentMetadata;
+                if (count >= maxCount) {
+                    disabledReasons.push(commands.project.add.error.maxExceeded(maxCount));
+                }
+            }
+        }
+        if (Array.isArray(supportedAuthTypes) &&
+            authType &&
+            !supportedAuthTypes.includes(authType.toLowerCase())) {
+            const supportedAuthTypesString = supportedAuthTypes.join(', ');
+            disabledReasons.push(commands.project.add.error.authTypeNotAllowed(supportedAuthTypesString));
+        }
+        if (Array.isArray(supportedDistributions) &&
+            distribution &&
+            !supportedDistributions.includes(distribution.toLowerCase())) {
+            const supportedDistributionsString = supportedDistributions.join(', ');
+            disabledReasons.push(commands.project.add.error.distributionNotAllowed(supportedDistributionsString));
+        }
+        const templateGate = componentTypeToGateMap[template.cliSelector || template.type];
+        if (templateGate) {
+            const isUngated = await hasFeature(accountId, templateGate);
+            if (!isUngated) {
+                disabledReasons.unshift(commands.project.add.error.portalDoesNotHaveAccessToThisFeature());
+            }
+        }
+        if (disabledReasons.length > 0) {
+            disabledComponents.push({
+                name: `${template.label} [${template.cliSelector || template.type}]`,
+                value: template,
+                disabled: `– ${disabledReasons.join(' ')}`,
+            });
+        }
+        else {
+            enabledComponents.push({
+                name: `${template.label} [${template.cliSelector || template.type}]`,
+                value: template,
+            });
+        }
+    }
+    return disabledComponents.length
+        ? [...enabledComponents, ...disabledComponents]
+        : [...enabledComponents];
+}
+export async function v2ComponentFlow(platformVersion, projectBase, providedAuth, providedDistribution, accountId) {
+    let repoConfig = undefined;
+    let authType;
+    let distribution;
+    repoConfig = await getConfigForPlatformVersion(platformVersion);
+    const projectContentsChoice = projectBase ||
+        (await listPrompt(commands.project.create.prompts.parentComponents, {
+            choices: [
+                { name: commands.project.create.prompts.app, value: PROJECT_WITH_APP },
+                {
+                    name: commands.project.create.prompts.emptyProject,
+                    value: EMPTY_PROJECT,
+                },
+            ],
+        }));
+    if (projectContentsChoice === PROJECT_WITH_APP) {
+        const { authType: selectedAuthType, distribution: selectedDistribution } = await createV2App(providedAuth, providedDistribution);
+        authType = selectedAuthType;
+        distribution = selectedDistribution;
+    }
+    const componentTemplateChoices = await calculateComponentTemplateChoices(repoConfig?.components || [], authType, distribution, accountId);
+    return {
+        componentTemplateChoices,
+        authType,
+        distribution,
+        projectContents: projectContentsChoice,
+        repoConfig,
+    };
+}
+export function generateComponentPaths({ selectProjectTemplatePromptResponse, platformVersion, repoConfig, projectContents, authType, distribution, }) {
+    if (!isV2Project(platformVersion)) {
+        return [];
+    }
+    const components = selectProjectTemplatePromptResponse.componentTemplates?.map((componentTemplate) => {
+        return path.join(platformVersion, componentTemplate.path);
+    }) || [];
+    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.join(platformVersion, parentComponent.path));
+        }
+    }
+    if (repoConfig?.defaultFiles) {
+        components.push(path.join(platformVersion, repoConfig?.defaultFiles));
+    }
+    return components;
+}

package/lib/projects/deploy.d.ts

@@ -0,0 +1,13 @@
+import { Deploy } from '@hubspot/local-dev-lib/types/Deploy';
+export declare function validateBuildIdForDeploy(buildId: number, deployedBuildId: number | undefined, latestBuildId: number, projectName: string | undefined, accountId: number): boolean | string;
+export declare function logDeployErrors(errorData: {
+    message: string;
+    errors: Array<{
+        message: string;
+        subCategory: string;
+        context: {
+            COMPONENT_NAME: string;
+        };
+    }>;
+}): void;
+export declare function handleProjectDeploy(targetAccountId: number, projectName: string, buildId: number, isV2Project: boolean, force: boolean): Promise<Deploy | undefined>;