@hubspot/cli 8.3.0 → 8.4.0-beta.0

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 {};

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

@@ -1,187 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createModulePrompt } from '../createModulePrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-const mockPromptUser = vi.mocked(promptUser);
-describe('createModulePrompt', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('when all parameters are provided', () => {
-        it('should return provided values without prompting', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: 'LANDING_PAGE,SITE_PAGE',
-                global: false,
-                availableForNewContent: true,
-            };
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: ['LANDING_PAGE', 'SITE_PAGE'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-        it('should use default values when optional parameters not provided', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-        it('should parse contentTypes string correctly', async () => {
-            const commandArgs = {
-                moduleLabel: 'Test Module',
-                contentTypes: 'BLOG_POST, EMAIL, LANDING_PAGE',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(result.contentTypes).toEqual([
-                'BLOG_POST',
-                'EMAIL',
-                'LANDING_PAGE',
-            ]);
-        });
-    });
-    describe('when some parameters are missing', () => {
-        it('should only prompt for missing parameters', async () => {
-            const commandArgs = {
-                moduleLabel: 'My Module',
-                reactType: true,
-            };
-            mockPromptUser.mockResolvedValue({
-                contentTypes: ['SITE_PAGE'],
-                global: true,
-                availableForNewContent: false,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'My Module',
-                reactType: true,
-                contentTypes: ['SITE_PAGE'],
-                global: true,
-                availableForNewContent: false,
-            });
-        });
-    });
-    describe('when no parameters are provided', () => {
-        it('should prompt for all parameters', async () => {
-            mockPromptUser.mockResolvedValue({
-                moduleLabel: 'Prompted Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt();
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'moduleLabel' }),
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'contentTypes' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'Prompted Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: true,
-            });
-        });
-    });
-    describe('parameter precedence', () => {
-        it('should prioritize command args over prompted values', async () => {
-            const commandArgs = {
-                moduleLabel: 'Args Module',
-                global: true,
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: false,
-                contentTypes: ['EMAIL'],
-                availableForNewContent: false,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(result).toEqual({
-                moduleLabel: 'Args Module', // from commandArgs
-                reactType: false, // from prompt
-                contentTypes: ['EMAIL'], // from prompt
-                global: true, // from commandArgs
-                availableForNewContent: false, // from prompt
-            });
-        });
-        it('should handle boolean false values correctly', async () => {
-            const commandArgs = {
-                moduleLabel: 'Test Module',
-                reactType: false,
-                contentTypes: 'ANY',
-                global: false,
-                availableForNewContent: false,
-            };
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                moduleLabel: 'Test Module',
-                reactType: false,
-                contentTypes: ['ANY'],
-                global: false,
-                availableForNewContent: false,
-            });
-        });
-        it('should handle mixed scenario with partial command args and prompting', async () => {
-            const commandArgs = {
-                moduleLabel: 'Partial Module',
-                contentTypes: 'BLOG_POST,BLOG_LISTING',
-            };
-            mockPromptUser.mockResolvedValue({
-                reactType: true,
-                global: false,
-                availableForNewContent: true,
-            });
-            const result = await createModulePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'reactType' }),
-                expect.objectContaining({ name: 'global' }),
-                expect.objectContaining({ name: 'availableForNewContent' }),
-            ]);
-            expect(result).toEqual({
-                moduleLabel: 'Partial Module', // from commandArgs
-                reactType: true, // from prompt
-                contentTypes: ['BLOG_POST', 'BLOG_LISTING'], // from commandArgs (parsed)
-                global: false, // from prompt
-                availableForNewContent: true, // from prompt
-            });
-        });
-    });
-});

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

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

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

@@ -1,102 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { createTemplatePrompt } from '../createTemplatePrompt.js';
-import { promptUser } from '../promptUtils.js';
-vi.mock('../promptUtils.js');
-const mockPromptUser = vi.mocked(promptUser);
-describe('createTemplatePrompt', () => {
-    beforeEach(() => {
-        vi.resetAllMocks();
-    });
-    describe('when templateType is provided', () => {
-        it('should return provided templateType without prompting', async () => {
-            const commandArgs = {
-                templateType: 'page-template',
-            };
-            const result = await createTemplatePrompt(commandArgs);
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            expect(result).toEqual({
-                templateType: 'page-template',
-            });
-        });
-        it('should work with different template types', async () => {
-            const testCases = [
-                'email-template',
-                'partial',
-                'global-partial',
-                'blog-listing-template',
-                'blog-post-template',
-                'search-template',
-                'section',
-            ];
-            for (const templateType of testCases) {
-                const commandArgs = { templateType };
-                const result = await createTemplatePrompt(commandArgs);
-                expect(mockPromptUser).not.toHaveBeenCalled();
-                expect(result).toEqual({ templateType });
-                vi.resetAllMocks();
-            }
-        });
-    });
-    describe('when templateType is not provided', () => {
-        it('should prompt for templateType', async () => {
-            mockPromptUser.mockResolvedValue({
-                templateType: 'page-template',
-            });
-            const result = await createTemplatePrompt();
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({
-                    name: 'templateType',
-                    type: 'list',
-                    choices: expect.any(Array),
-                }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'page-template',
-            });
-        });
-        it('should prompt when commandArgs is empty', async () => {
-            mockPromptUser.mockResolvedValue({
-                templateType: 'email-template',
-            });
-            const result = await createTemplatePrompt({});
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'templateType' }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'email-template',
-            });
-        });
-        it('should prompt when templateType is undefined', async () => {
-            const commandArgs = {
-                templateType: undefined,
-            };
-            mockPromptUser.mockResolvedValue({
-                templateType: 'partial',
-            });
-            const result = await createTemplatePrompt(commandArgs);
-            expect(mockPromptUser).toHaveBeenCalledWith([
-                expect.objectContaining({ name: 'templateType' }),
-            ]);
-            expect(result).toEqual({
-                templateType: 'partial',
-            });
-        });
-    });
-    describe('integration scenarios', () => {
-        it('should handle mixed usage patterns', async () => {
-            // First call with templateType provided
-            let result = await createTemplatePrompt({
-                templateType: 'blog-post-template',
-            });
-            expect(result.templateType).toBe('blog-post-template');
-            expect(mockPromptUser).not.toHaveBeenCalled();
-            // Second call without templateType
-            mockPromptUser.mockResolvedValue({
-                templateType: 'section',
-            });
-            result = await createTemplatePrompt();
-            expect(result.templateType).toBe('section');
-            expect(mockPromptUser).toHaveBeenCalledTimes(1);
-        });
-    });
-});

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

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

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

@@ -1,31 +0,0 @@
-import { getConfigAccountIfExists } from '@hubspot/local-dev-lib/config';
-import { fetchProjects } from '@hubspot/local-dev-lib/api/projects';
-import { downloadProjectPrompt } from '../downloadProjectPrompt.js';
-vi.mock('../promptUtils', () => ({
-    promptUser: vi.fn().mockResolvedValue({ project: 'test-project' }),
-}));
-vi.mock('@hubspot/local-dev-lib/api/projects', () => ({
-    fetchProjects: vi.fn().mockResolvedValue({
-        data: { results: [] },
-    }),
-}));
-vi.mock('@hubspot/local-dev-lib/config', () => ({
-    getConfigAccountIfExists: vi
-        .fn()
-        .mockImplementation(() => ({ accountId: 123456789 })),
-    globalConfigFileExists: vi.fn().mockReturnValue(true),
-}));
-describe('lib/prompts/downloadProjectPrompt', () => {
-    it('should honor the account passed as an option', async () => {
-        const account = 'Prod';
-        await downloadProjectPrompt({ account });
-        expect(getConfigAccountIfExists).toHaveBeenCalledTimes(1);
-        expect(getConfigAccountIfExists).toHaveBeenCalledWith(account);
-    });
-    it('should fetch the projects for the correct accountId', async () => {
-        const account = 'Prod';
-        await downloadProjectPrompt({ account });
-        expect(fetchProjects).toHaveBeenCalledTimes(1);
-        expect(fetchProjects).toHaveBeenCalledWith(123456789);
-    });
-});

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

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