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

package/lib/projects/components.js

@@ -1,241 +0,0 @@
-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);
-    // Exclude markdown files fromthe rename process because they should not be duplicated
-    const sourceFilenameMapping = sourceFiles
-        .filter(filename => !filename.endsWith('.md'))
-        .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 = 1;
-            while (existingUids.includes(uid)) {
-                differentiator++;
-                uid = `${getBaseUid()}_${differentiator}`;
-            }
-            component.uid = 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

@@ -1,9 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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/__tests__/legacy.test.d.ts

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

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

@@ -1,72 +0,0 @@
-import * as github from '@hubspot/local-dev-lib/api/github';
-import { getProjectComponentListFromRepo, getProjectTemplateListFromRepo, } from '../legacy.js';
-import { PROJECT_COMPONENT_TYPES, HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, } from '../../../constants.js';
-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()', () => {
-        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('throws an error if the request for the template list fails', async () => {
-            mockedFetchRepoFile.mockRejectedValue(new Error('Not found'));
-            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Failed to fetch the config.json file from the target repository');
-        });
-        it('throws an error if there are no projects listed in the repo config', async () => {
-            // @ts-expect-error - Mocking AxiosResponse
-            mockedFetchRepoFile.mockResolvedValue({});
-            await expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Unable to find any projects in the target repository');
-        });
-        it('throws an error 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 expect(getProjectTemplateListFromRepo(HUBSPOT_PROJECT_COMPONENTS_GITHUB_PATH, 'gh-ref')).rejects.toThrow('Found misconfigured projects in the target repository');
-        });
-    });
-});

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

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

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

@@ -1,257 +0,0 @@
-import { calculateComponentTemplateChoices } from '../v2.js';
-import { hasFeature } from '../../../hasFeature.js';
-import { getConfigAccountById as __getConfigAccountById } from '@hubspot/local-dev-lib/config';
-const getConfigAccountById = __getConfigAccountById;
-vi.mock('@hubspot/local-dev-lib/api/github');
-vi.mock('../../../hasFeature.js');
-vi.mock('@hubspot/local-dev-lib/config');
-const mockHasFeature = vi.mocked(hasFeature);
-describe('lib/projects/create/v2', () => {
-    beforeEach(() => {
-        mockHasFeature.mockResolvedValue(true);
-        // Mock account config
-        getConfigAccountById.mockReturnValue({
-            accountId: 123,
-            name: 'Test Account',
-            authType: 'personalaccesskey',
-            personalAccessKey: 'test-key',
-            env: 'prod',
-        });
-    });
-    describe('calculateComponentTemplateChoices()', () => {
-        beforeEach(() => {
-            mockHasFeature.mockClear();
-        });
-        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', async () => {
-            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'private', 123, mockProjectMetadataForChoices);
-            expect(choices).toHaveLength(2);
-            expect(choices[0]).toEqual({
-                name: 'Module Component [module]',
-                value: mockComponents[0],
-            });
-            expect(choices[1]).toEqual({
-                name: expect.stringContaining('Card Component'),
-                value: mockComponents[1],
-                disabled: expect.stringContaining('maximum'),
-            });
-        });
-        it('disables components when auth type is not supported', async () => {
-            const choices = await calculateComponentTemplateChoices(mockComponents, 'privatekey', 'private', 123, mockProjectMetadataForChoices);
-            // All components should be disabled
-            expect(choices[0]).toEqual({
-                name: expect.stringContaining('Module Component'),
-                value: mockComponents[0],
-                disabled: expect.stringContaining('oauth'),
-            });
-        });
-        it('disables components when distribution is not supported', async () => {
-            const choices = await calculateComponentTemplateChoices(mockComponents, 'oauth', 'enterprise', 123, mockProjectMetadataForChoices);
-            // All components should be disabled
-            expect(choices[0]).toEqual({
-                name: expect.stringContaining('Module Component'),
-                value: mockComponents[0],
-                disabled: expect.stringContaining('private'),
-            });
-        });
-        it('handles components without auth type or distribution restrictions', async () => {
-            const componentsWithoutRestrictions = [
-                {
-                    label: 'Unrestricted Component',
-                    path: 'unrestricted',
-                    type: 'module',
-                },
-            ];
-            const choices = await calculateComponentTemplateChoices(componentsWithoutRestrictions, 'oauth', 'private', 123, {
-                hsMetaFiles: [],
-                components: { module: { count: 0, maxCount: 5, hsMetaFiles: [] } },
-            });
-            expect(choices[0]).toEqual({
-                name: 'Unrestricted Component [module]',
-                value: componentsWithoutRestrictions[0],
-            });
-        });
-        it('handles components with cliSelector field (metadata compatibility)', async () => {
-            const componentWithCliSelector = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const projectMetadataWithWorkflowAction = {
-                hsMetaFiles: [],
-                components: {
-                    'workflow-action': { count: 2, maxCount: 3, hsMetaFiles: [] },
-                },
-            };
-            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 213, projectMetadataWithWorkflowAction);
-            expect(choices).toHaveLength(1); // no disabled components
-            expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool [workflow-action-tool]',
-                value: componentWithCliSelector[0],
-            });
-        });
-        it('disables component when project metadata count exceeds maximum', async () => {
-            const componentWithCliSelector = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const projectMetadataAtMaxWorkflowAction = {
-                hsMetaFiles: [],
-                components: {
-                    'workflow-action': { count: 3, maxCount: 3, hsMetaFiles: [] },
-                },
-            };
-            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, projectMetadataAtMaxWorkflowAction);
-            expect(choices).toHaveLength(1);
-            expect(choices[0]).toEqual({
-                name: expect.stringContaining('Workflow Action Tool'),
-                value: componentWithCliSelector[0],
-                disabled: expect.stringContaining('maximum'),
-            });
-        });
-        it('handles undefined projectMetadata without throwing errors', async () => {
-            const componentWithCliSelector = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const choices = await calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, undefined);
-            expect(choices).toHaveLength(1); // no disabled components
-            expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool [workflow-action-tool]',
-                value: componentWithCliSelector[0],
-            });
-        });
-        it('handles projectMetadata with undefined components property (after fix)', async () => {
-            const componentWithCliSelector = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const projectMetadataWithoutComponents = {
-                hsMetaFiles: [],
-                components: undefined,
-            };
-            // This test verifies the null check fix works
-            // Currently this will fail because the fix checks for projectMetadata.components
-            await expect(async () => calculateComponentTemplateChoices(componentWithCliSelector, 'oauth', 'private', 123, 
-            // @ts-expect-error breaking stuff on purpose
-            projectMetadataWithoutComponents)).rejects.toThrow();
-        });
-        it('disables gated components when hasFeature returns false', async () => {
-            mockHasFeature.mockResolvedValue(false);
-            const gatedComponent = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const projectMetadataWithWorkflowAction = {
-                hsMetaFiles: [],
-                components: {
-                    'workflow-action': { count: 0, maxCount: 3, hsMetaFiles: [] },
-                },
-            };
-            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, projectMetadataWithWorkflowAction);
-            expect(choices).toHaveLength(1);
-            expect(choices[0]).toEqual({
-                name: expect.stringContaining('Workflow Action Tool'),
-                value: gatedComponent[0],
-                disabled: expect.stringContaining("doesn't have access to this feature"),
-            });
-            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
-        });
-        it('enables gated components when hasFeature returns true', async () => {
-            mockHasFeature.mockResolvedValue(true);
-            const gatedComponent = [
-                {
-                    label: 'Workflow Action Tool',
-                    path: 'workflow-action-tool',
-                    type: 'workflow-action',
-                    cliSelector: 'workflow-action-tool',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const projectMetadataWithWorkflowAction = {
-                hsMetaFiles: [],
-                components: {
-                    'workflow-action': { count: 0, maxCount: 3, hsMetaFiles: [] },
-                },
-            };
-            const choices = await calculateComponentTemplateChoices(gatedComponent, 'oauth', 'private', 123, projectMetadataWithWorkflowAction);
-            expect(choices).toHaveLength(1); // no disabled components
-            expect(choices[0]).toEqual({
-                name: 'Workflow Action Tool [workflow-action-tool]',
-                value: gatedComponent[0],
-            });
-            expect(mockHasFeature).toHaveBeenCalledWith(123, expect.any(String));
-        });
-        it('handles non-gated components without calling hasFeature', async () => {
-            const nonGatedComponent = [
-                {
-                    label: 'Regular Component',
-                    path: 'regular',
-                    type: 'module',
-                    supportedAuthTypes: ['oauth'],
-                    supportedDistributions: ['private'],
-                },
-            ];
-            const choices = await calculateComponentTemplateChoices(nonGatedComponent, 'oauth', 'private', 123, mockProjectMetadataForChoices);
-            expect(choices).toHaveLength(1);
-            expect(choices[0]).toEqual({
-                name: 'Regular Component [module]',
-                value: nonGatedComponent[0],
-            });
-            // hasFeature should not be called for non-gated components
-            expect(mockHasFeature).not.toHaveBeenCalled();
-        });
-    });
-});