@hubspot/cli 8.1.0 → 8.1.1-experimental.0

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();
-        });
-    });
-});

package/lib/projects/platformVersion.d.ts

@@ -1,9 +0,0 @@
-/**
- * Used to surface warnings when users attempt to interact with new platform versions
- * that were released after this version of the CLI was released.
- *
- * We are unable to reliably support versions of projects that are newer than any given CLI release
- * */
-export declare const LATEST_SUPPORTED_PLATFORM_VERSION = "2026.03";
-export declare function isV2Project(platformVersion?: string | null): boolean;
-export declare function isUnsupportedPlatformVersion(platformVersion?: string | null): boolean;

package/lib/projects/platformVersion.js

@@ -1,39 +0,0 @@
-/**
- * Used to surface warnings when users attempt to interact with new platform versions
- * that were released after this version of the CLI was released.
- *
- * We are unable to reliably support versions of projects that are newer than any given CLI release
- * */
-export const LATEST_SUPPORTED_PLATFORM_VERSION = '2026.03';
-function parsePlatformVersion(platformVersion) {
-    const [year, minor] = platformVersion.split(/[.-]/);
-    return {
-        year: Number(year),
-        minor: Number(minor),
-    };
-}
-export function isV2Project(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return true;
-    }
-    const { year, minor } = parsePlatformVersion(platformVersion);
-    return (year === 2025 && minor >= 2) || year > 2025;
-}
-export function isUnsupportedPlatformVersion(platformVersion) {
-    if (!platformVersion || typeof platformVersion !== 'string') {
-        return false;
-    }
-    if (platformVersion.toLowerCase() === 'unstable') {
-        return false;
-    }
-    const { year, minor } = parsePlatformVersion(platformVersion);
-    if (isNaN(year) || isNaN(minor)) {
-        return false;
-    }
-    const { year: latestSupportedYear, minor: latestSupportedMinor } = parsePlatformVersion(LATEST_SUPPORTED_PLATFORM_VERSION);
-    return (year > latestSupportedYear ||
-        (year === latestSupportedYear && minor > latestSupportedMinor));
-}

package/lib/prompts/__tests__/createDeveloperTestAccountConfigPrompt.test.d.ts

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

package/lib/prompts/__tests__/createDeveloperTestAccountConfigPrompt.test.js

@@ -1,157 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createDeveloperTestAccountConfigPrompt } from '../createDeveloperTestAccountConfigPrompt.js';
-import * as promptUtils from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-describe('createDeveloperTestAccountConfigPrompt', () => {
-    describe('with name and description provided via args', () => {
-        it('should skip name and description prompts when provided', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            mockPromptUser.mockResolvedValueOnce({}); // name/description prompts skipped
-            mockPromptUser.mockResolvedValueOnce({
-                useDefaultAccountLevels: 'default',
-            }); // tier selection
-            const result = await createDeveloperTestAccountConfigPrompt({
-                name: 'TestAccount',
-                description: 'Test description',
-            });
-            expect(result).toEqual({
-                accountName: 'TestAccount',
-                description: 'Test description',
-                marketingLevel: 'ENTERPRISE',
-                opsLevel: 'ENTERPRISE',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'ENTERPRISE',
-                contentLevel: 'ENTERPRISE',
-                commerceLevel: 'ENTERPRISE',
-            });
-            expect(mockPromptUser).toHaveBeenCalledTimes(2);
-        });
-    });
-    describe('with tier flags provided', () => {
-        it('should skip tier prompts and use provided values with defaults', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            mockPromptUser.mockResolvedValueOnce({}); // name/description prompts skipped
-            const result = await createDeveloperTestAccountConfigPrompt({
-                name: 'TestAccount',
-                description: 'Test',
-                marketingLevel: 'PROFESSIONAL',
-                salesLevel: 'STARTER',
-            });
-            expect(result).toEqual({
-                accountName: 'TestAccount',
-                description: 'Test',
-                marketingLevel: 'PROFESSIONAL',
-                opsLevel: 'ENTERPRISE',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'STARTER',
-                contentLevel: 'ENTERPRISE',
-                commerceLevel: 'ENTERPRISE',
-            });
-            // Should only call promptUser once (for name/description which are skipped)
-            expect(mockPromptUser).toHaveBeenCalledTimes(1);
-        });
-        it('should default unprovided tiers to ENTERPRISE', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            mockPromptUser.mockResolvedValueOnce({
-                description: 'Test',
-            }); // description prompt (name provided via args, description not provided)
-            const result = await createDeveloperTestAccountConfigPrompt({
-                name: 'TestAccount',
-                contentLevel: 'FREE',
-            });
-            expect(result).toEqual({
-                accountName: 'TestAccount',
-                description: 'Test',
-                marketingLevel: 'ENTERPRISE',
-                opsLevel: 'ENTERPRISE',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'ENTERPRISE',
-                contentLevel: 'FREE',
-                commerceLevel: 'ENTERPRISE',
-            });
-        });
-    });
-    describe('with no flags provided', () => {
-        it('should prompt for name, description, and tier selection', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            // First call: name/description prompts
-            mockPromptUser.mockResolvedValueOnce({
-                accountName: 'PromptedAccount',
-                description: 'Prompted description',
-            });
-            // Second call: tier selection
-            mockPromptUser.mockResolvedValueOnce({
-                useDefaultAccountLevels: 'default',
-            });
-            const result = await createDeveloperTestAccountConfigPrompt({});
-            expect(result).toEqual({
-                accountName: 'PromptedAccount',
-                description: 'Prompted description',
-                marketingLevel: 'ENTERPRISE',
-                opsLevel: 'ENTERPRISE',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'ENTERPRISE',
-                contentLevel: 'ENTERPRISE',
-                commerceLevel: 'ENTERPRISE',
-            });
-            expect(mockPromptUser).toHaveBeenCalledTimes(2);
-        });
-        it('should allow manual tier selection', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            mockPromptUser.mockResolvedValueOnce({
-                accountName: 'TestAccount',
-                description: 'Test',
-            }); // name/description
-            mockPromptUser.mockResolvedValueOnce({
-                useDefaultAccountLevels: 'manual',
-            }); // tier choice
-            mockPromptUser.mockResolvedValueOnce({
-                testAccountLevels: [
-                    { hub: 'MARKETING', tier: 'PROFESSIONAL' },
-                    { hub: 'OPS', tier: 'STARTER' },
-                    { hub: 'SERVICE', tier: 'ENTERPRISE' },
-                    { hub: 'SALES', tier: 'FREE' },
-                    { hub: 'CONTENT', tier: 'ENTERPRISE' },
-                    { hub: 'COMMERCE', tier: 'STARTER' },
-                ],
-            }); // manual tier selection
-            const result = await createDeveloperTestAccountConfigPrompt({});
-            expect(result).toEqual({
-                accountName: 'TestAccount',
-                description: 'Test',
-                marketingLevel: 'PROFESSIONAL',
-                opsLevel: 'STARTER',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'FREE',
-                contentLevel: 'ENTERPRISE',
-                commerceLevel: 'STARTER',
-            });
-            expect(mockPromptUser).toHaveBeenCalledTimes(3);
-        });
-    });
-    describe('with only name provided', () => {
-        it('should skip name prompt but show description and tier prompts', async () => {
-            const mockPromptUser = vi.mocked(promptUtils.promptUser);
-            mockPromptUser.mockResolvedValueOnce({
-                description: 'Prompted description',
-            }); // description prompt (name skipped)
-            mockPromptUser.mockResolvedValueOnce({
-                useDefaultAccountLevels: 'default',
-            }); // tier selection
-            const result = await createDeveloperTestAccountConfigPrompt({
-                name: 'TestAccount',
-            });
-            expect(result).toEqual({
-                accountName: 'TestAccount',
-                description: 'Prompted description',
-                marketingLevel: 'ENTERPRISE',
-                opsLevel: 'ENTERPRISE',
-                serviceLevel: 'ENTERPRISE',
-                salesLevel: 'ENTERPRISE',
-                contentLevel: 'ENTERPRISE',
-                commerceLevel: 'ENTERPRISE',
-            });
-            expect(mockPromptUser).toHaveBeenCalledTimes(2);
-        });
-    });
-});

package/lib/prompts/__tests__/createFunctionPrompt.test.d.ts

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

package/lib/prompts/__tests__/createFunctionPrompt.test.js

@@ -1,129 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createFunctionPrompt } from '../createFunctionPrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-const mockPromptUser = vi.mocked(promptUser);
-describe('createFunctionPrompt', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('when all parameters are provided', () => {
-        it('should return provided values without prompting', async () => {
-            const commandArgs = {
-                functionsFolder: 'my-functions',
-                filename: 'my-function',
-                endpointMethod: 'POST',
-                endpointPath: '/api/test',
-            };
-            const result = await createFunctionPrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                functionsFolder: 'my-functions',
-                filename: 'my-function',
-                endpointMethod: 'POST',
-                endpointPath: '/api/test',
-            });
-        });
-        it('should use default GET method when endpointMethod not provided', async () => {
-            const commandArgs = {
-                functionsFolder: 'my-functions',
-                filename: 'my-function',
-                endpointPath: '/api/test',
-            };
-            const result = await createFunctionPrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                functionsFolder: 'my-functions',
-                filename: 'my-function',
-                endpointMethod: 'GET',
-                endpointPath: '/api/test',
-            });
-        });
-    });
-    describe('when some parameters are missing', () => {
-        it('should only prompt for missing parameters', async () => {
-            const commandArgs = {
-                functionsFolder: 'my-functions',
-                endpointMethod: 'POST',
-            };
-            mockPromptUser.mockResolvedValue({
-                filename: 'prompted-function',
-                endpointPath: '/prompted-path',
-            });
-            const result = await createFunctionPrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'filename' }),
-                expect.objectContaining({ name: 'endpointPath' }),
-            ]);
-            expect(result).toEqual({
-                functionsFolder: 'my-functions',
-                filename: 'prompted-function',
-                endpointMethod: 'POST',
-                endpointPath: '/prompted-path',
-            });
-        });
-    });
-    describe('when no parameters are provided', () => {
-        it('should prompt for all parameters', async () => {
-            mockPromptUser.mockResolvedValue({
-                functionsFolder: 'prompted-functions',
-                filename: 'prompted-function',
-                endpointMethod: 'GET',
-                endpointPath: '/prompted-path',
-            });
-            const result = await createFunctionPrompt();
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'functionsFolder' }),
-                expect.objectContaining({ name: 'filename' }),
-                expect.objectContaining({ name: 'endpointMethod' }),
-                expect.objectContaining({ name: 'endpointPath' }),
-            ]);
-            expect(result).toEqual({
-                functionsFolder: 'prompted-functions',
-                filename: 'prompted-function',
-                endpointMethod: 'GET',
-                endpointPath: '/prompted-path',
-            });
-        });
-    });
-    describe('parameter precedence', () => {
-        it('should prioritize command args over prompted values', async () => {
-            const commandArgs = {
-                functionsFolder: 'arg-functions',
-            };
-            mockPromptUser.mockResolvedValue({
-                filename: 'prompted-function',
-                endpointMethod: 'POST',
-                endpointPath: '/prompted-path',
-            });
-            const result = await createFunctionPrompt(commandArgs);
-            expect(result).toEqual({
-                functionsFolder: 'arg-functions', // from commandArgs
-                filename: 'prompted-function', // from prompt
-                endpointMethod: 'POST', // from prompt
-                endpointPath: '/prompted-path', // from prompt
-            });
-        });
-        it('should handle mixed scenario with partial command args and prompting', async () => {
-            const commandArgs = {
-                functionsFolder: 'my-funcs',
-                endpointMethod: 'DELETE',
-            };
-            mockPromptUser.mockResolvedValue({
-                filename: 'delete-handler',
-                endpointPath: '/api/delete',
-            });
-            const result = await createFunctionPrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'filename' }),
-                expect.objectContaining({ name: 'endpointPath' }),
-            ]);
-            expect(result).toEqual({
-                functionsFolder: 'my-funcs', // from commandArgs
-                filename: 'delete-handler', // from prompt
-                endpointMethod: 'DELETE', // from commandArgs
-                endpointPath: '/api/delete', // from prompt
-            });
-        });
-    });
-});

package/lib/prompts/__tests__/createModulePrompt.test.d.ts

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