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

package/commands/project/validate.js

@@ -1,156 +0,0 @@
-import path from 'path';
-import { getConfigAccountById } from '@hubspot/local-dev-lib/config';
-import { isV2Project } from '../../lib/projects/platformVersion.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-import { validateSourceDirectory, handleTranslate, } from '../../lib/projects/upload.js';
-import { commands } from '../../lang/en.js';
-import { validateProjectForProfile } from '../../lib/projects/projectProfiles.js';
-import { logError } from '../../lib/errorHandlers/index.js';
-import { getAllHsProfiles } from '@hubspot/project-parsing-lib/profiles';
-import SpinniesManager from '../../lib/ui/SpinniesManager.js';
-const command = 'validate';
-const describe = commands.project.validate.describe;
-async function handler(args) {
-    const { derivedAccountId, profile } = args;
-    const { projectConfig, projectDir } = await getProjectConfig();
-    const accountConfig = getConfigAccountById(derivedAccountId);
-    const accountType = accountConfig && accountConfig.accountType;
-    trackCommandUsage('project-validate', { type: accountType }, derivedAccountId);
-    if (!projectConfig || !projectDir) {
-        uiLogger.error(commands.project.validate.mustBeRanWithinAProject);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    if (!isV2Project(projectConfig?.platformVersion)) {
-        uiLogger.error(commands.project.validate.badVersion);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        validateProjectConfig(projectConfig, projectDir);
-    }
-    catch (error) {
-        logError(error);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    let validationSucceeded = true;
-    const srcDir = path.resolve(projectDir, projectConfig.srcDir);
-    const profiles = await getAllHsProfiles(path.join(projectDir, projectConfig.srcDir));
-    // If a profile is specified, only validate that profile
-    if (profile) {
-        const validationErrors = await validateProjectForProfile({
-            projectConfig,
-            projectDir,
-            profileName: profile,
-            derivedAccountId,
-        });
-        if (validationErrors.length) {
-            logValidationErrors(validationErrors);
-            validationSucceeded = false;
-        }
-    }
-    else if (profiles.length > 0) {
-        // If no profile was specified and the project has profiles, validate all of them
-        SpinniesManager.add('validatingAllProfiles', {
-            text: commands.project.validate.spinners.validatingAllProfiles,
-        });
-        const errors = [];
-        for (const profileName of profiles) {
-            const validationErrors = await validateProjectForProfile({
-                projectConfig,
-                projectDir,
-                profileName,
-                derivedAccountId,
-                indentSpinners: true,
-            });
-            if (validationErrors.length) {
-                errors.push(...validationErrors);
-                validationSucceeded = false;
-            }
-        }
-        if (validationSucceeded) {
-            SpinniesManager.succeed('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationSucceeded,
-            });
-        }
-        else {
-            SpinniesManager.fail('validatingAllProfiles', {
-                text: commands.project.validate.spinners.allProfilesValidationFailed,
-            });
-        }
-        logValidationErrors(errors);
-    }
-    else if (profiles.length === 0) {
-        // If the project has no profiles, validate the project without a profile
-        try {
-            await handleTranslate({
-                projectDir: projectDir,
-                projectConfig,
-                accountId: derivedAccountId,
-                skipValidation: false,
-            });
-        }
-        catch (e) {
-            uiLogger.error(commands.project.validate.failure(projectConfig.name));
-            logError(e);
-            validationSucceeded = false;
-            uiLogger.log('');
-        }
-    }
-    if (!validationSucceeded) {
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        await validateSourceDirectory(srcDir, projectConfig, projectDir);
-    }
-    catch (e) {
-        logError(e);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    uiLogger.success(commands.project.validate.success(projectConfig.name));
-    process.exit(EXIT_CODES.SUCCESS);
-}
-function projectValidateBuilder(yargs) {
-    yargs.options({
-        profile: {
-            type: 'string',
-            alias: 'p',
-            describe: commands.project.validate.options.profile.describe,
-        },
-    });
-    yargs.conflicts('profile', 'account');
-    yargs.example([
-        ['$0 project validate', commands.project.validate.examples.default],
-        [
-            '$0 project validate --profile=profileName',
-            commands.project.validate.examples.withProfile,
-        ],
-    ]);
-    return yargs;
-}
-function logValidationErrors(validationErrors) {
-    uiLogger.log('');
-    validationErrors.forEach(error => {
-        if (error instanceof Error) {
-            logError(error);
-        }
-        else {
-            uiLogger.log(error);
-        }
-    });
-}
-const builder = makeYargsBuilder(projectValidateBuilder, command, describe, {
-    useGlobalOptions: true,
-    useConfigOptions: true,
-    useAccountOptions: true,
-    useEnvironmentOptions: true,
-});
-const projectValidateCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default projectValidateCommand;

package/commands/project/watch.d.ts

@@ -1,6 +0,0 @@
-import { CommonArgs, AccountArgs, ConfigArgs, EnvironmentArgs, YargsCommandModule } from '../../types/Yargs.js';
-type ProjectWatchArgs = CommonArgs & ConfigArgs & AccountArgs & EnvironmentArgs & {
-    initialUpload?: boolean;
-};
-declare const projectWatchCommand: YargsCommandModule<unknown, ProjectWatchArgs>;
-export default projectWatchCommand;

package/commands/project/watch.js

@@ -1,152 +0,0 @@
-import { cancelStagedBuild, fetchProjectBuilds, } from '@hubspot/local-dev-lib/api/projects';
-import { isSpecifiedError } from '@hubspot/local-dev-lib/errors/index';
-import { isV2Project } from '../../lib/projects/platformVersion.js';
-import { commands } from '../../lang/en.js';
-import { createWatcher } from '../../lib/projects/watch.js';
-import { logError, ApiErrorContext } from '../../lib/errorHandlers/index.js';
-import { uiLogger } from '../../lib/ui/logger.js';
-import { PROJECT_ERROR_TYPES } from '../../lib/constants.js';
-import { trackCommandUsage } from '../../lib/usageTracking.js';
-import { getProjectConfig, validateProjectConfig, } from '../../lib/projects/config.js';
-import { logFeedbackMessage } from '../../lib/projects/ui.js';
-import { handleProjectUpload } from '../../lib/projects/upload.js';
-import { pollBuildStatus, pollDeployStatus, } from '../../lib/projects/pollProjectBuildAndDeploy.js';
-import { EXIT_CODES } from '../../lib/enums/exitCodes.js';
-import { handleKeypress, handleExit } from '../../lib/process.js';
-import { makeYargsBuilder } from '../../lib/yargsUtils.js';
-const command = 'watch';
-const describe = commands.project.watch.describe;
-async function handleBuildStatus(accountId, projectName, buildId) {
-    const { isAutoDeployEnabled, deployStatusTaskLocator } = await pollBuildStatus(accountId, projectName, buildId, null);
-    if (isAutoDeployEnabled && deployStatusTaskLocator) {
-        await pollDeployStatus(accountId, projectName, Number(deployStatusTaskLocator.id), buildId);
-    }
-    logFeedbackMessage(buildId);
-}
-function handleUserInput(accountId, projectName, currentBuildId) {
-    const onTerminate = async () => {
-        uiLogger.log(commands.project.watch.logs.processExited);
-        if (currentBuildId) {
-            try {
-                await cancelStagedBuild(accountId, projectName);
-                process.exit(EXIT_CODES.SUCCESS);
-            }
-            catch (err) {
-                if (isSpecifiedError(err, {
-                    subCategory: PROJECT_ERROR_TYPES.BUILD_NOT_IN_PROGRESS,
-                })) {
-                    process.exit(EXIT_CODES.SUCCESS);
-                }
-                else {
-                    logError(err, new ApiErrorContext({ accountId }));
-                    process.exit(EXIT_CODES.ERROR);
-                }
-            }
-        }
-        else {
-            process.exit(EXIT_CODES.SUCCESS);
-        }
-    };
-    handleExit(onTerminate);
-    handleKeypress(key => {
-        if ((key.ctrl && key.name === 'c') || key.name === 'q') {
-            onTerminate();
-        }
-    });
-}
-async function handler(args) {
-    const { initialUpload, derivedAccountId } = args;
-    trackCommandUsage('project-watch', undefined, derivedAccountId);
-    const { projectConfig, projectDir } = await getProjectConfig();
-    if (!projectConfig || !projectDir) {
-        uiLogger.error(commands.project.watch.errors.projectConfigNotFound);
-        return process.exit(EXIT_CODES.ERROR);
-    }
-    if (isV2Project(projectConfig.platformVersion)) {
-        uiLogger.error(projectConfig.platformVersion);
-        return process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        validateProjectConfig(projectConfig, projectDir);
-    }
-    catch (error) {
-        logError(error);
-        process.exit(EXIT_CODES.ERROR);
-    }
-    try {
-        const { data: { results: builds }, } = await fetchProjectBuilds(derivedAccountId, projectConfig.name);
-        const hasNoBuilds = !builds || !builds.length;
-        const handleWatchTermination = (error) => {
-            if (error) {
-                logError(error, new ApiErrorContext({ accountId: derivedAccountId }));
-                process.exit(EXIT_CODES.ERROR);
-            }
-            else {
-                process.exit(EXIT_CODES.SUCCESS);
-            }
-        };
-        const startWatching = async () => {
-            await createWatcher(derivedAccountId, projectConfig, projectDir, handleBuildStatus, handleUserInput, handleWatchTermination);
-        };
-        // Upload all files if no build exists for this project yet
-        if (initialUpload || hasNoBuilds) {
-            const { uploadError, projectNotFound } = await handleProjectUpload({
-                accountId: derivedAccountId,
-                projectConfig,
-                projectDir,
-                callbackFunc: startWatching,
-                isUploadCommand: false,
-            });
-            if (projectNotFound) {
-                process.exit(EXIT_CODES.ERROR);
-            }
-            if (uploadError) {
-                if (isSpecifiedError(uploadError, {
-                    subCategory: PROJECT_ERROR_TYPES.PROJECT_LOCKED,
-                })) {
-                    uiLogger.log('');
-                    uiLogger.error(commands.project.watch.errors.projectLockedError);
-                    uiLogger.log('');
-                }
-                else {
-                    logError(uploadError, new ApiErrorContext({
-                        accountId: derivedAccountId,
-                        request: 'project upload',
-                    }));
-                }
-                process.exit(EXIT_CODES.ERROR);
-            }
-        }
-        else {
-            await startWatching();
-        }
-    }
-    catch (e) {
-        logError(e, new ApiErrorContext({ accountId: derivedAccountId }));
-        process.exit(EXIT_CODES.ERROR);
-    }
-}
-function projectWatchBuilder(yargs) {
-    yargs.option('initial-upload', {
-        alias: 'i',
-        describe: commands.project.watch.options.initialUpload.describe,
-        type: 'boolean',
-    });
-    yargs.example([
-        ['$0 project watch', commands.project.watch.examples.default],
-    ]);
-    return yargs;
-}
-const builder = makeYargsBuilder(projectWatchBuilder, command, describe, {
-    useGlobalOptions: true,
-    useAccountOptions: true,
-    useConfigOptions: true,
-    useEnvironmentOptions: true,
-});
-const projectWatchCommand = {
-    command,
-    describe,
-    handler,
-    builder,
-};
-export default projectWatchCommand;

package/commands/project.d.ts

@@ -1,3 +0,0 @@
-import { YargsCommandModuleBucket } from '../types/Yargs.js';
-declare const projectCommand: YargsCommandModuleBucket;
-export default projectCommand;

package/commands/project.js

@@ -1,72 +0,0 @@
-import { pkg } from '../lib/jsonLoader.js';
-import { commands, lib } from '../lang/en.js';
-import deploy from './project/deploy.js';
-import create from './project/create.js';
-import upload from './project/upload.js';
-import listBuilds from './project/listBuilds.js';
-import logs from './project/logs.js';
-import watch from './project/watch.js';
-import download from './project/download.js';
-import open from './project/open.js';
-import dev from './project/dev/index.js';
-import add from './project/add.js';
-import migrate from './project/migrate.js';
-import installDeps from './project/installDeps.js';
-import lint from './project/lint.js';
-import updateDeps from './project/updateDeps.js';
-import profile from './project/profile.js';
-import projectValidate from './project/validate.js';
-import list from './project/list.js';
-import { makeYargsBuilder } from '../lib/yargsUtils.js';
-import { getProjectConfig } from '../lib/projects/config.js';
-import { isUnsupportedPlatformVersion, LATEST_SUPPORTED_PLATFORM_VERSION, } from '../lib/projects/platformVersion.js';
-import { uiLogger } from '../lib/ui/logger.js';
-import { debugError } from '../lib/errorHandlers/index.js';
-const command = ['project', 'projects'];
-const describe = commands.project.describe;
-// Warn users when they are interacting with a version of projects that this version of
-// the CLI is not officially compatible with
-async function validatePlatformVersion() {
-    try {
-        const { projectConfig } = await getProjectConfig();
-        if (isUnsupportedPlatformVersion(projectConfig?.platformVersion)) {
-            uiLogger.warn(lib.projects.platformVersion.unsupported(pkg.version, LATEST_SUPPORTED_PLATFORM_VERSION, projectConfig?.platformVersion));
-            uiLogger.log('');
-        }
-    }
-    catch (error) {
-        // Silently fail. We don't want this to interrupt command execution
-        debugError(error);
-    }
-}
-function projectBuilder(yargs) {
-    yargs.middleware([validatePlatformVersion]);
-    yargs
-        .command(create)
-        .command(add)
-        .command(watch)
-        .command(list)
-        .command(dev)
-        .command(upload)
-        .command(deploy)
-        .command(logs)
-        .command(listBuilds)
-        .command(download)
-        .command(open)
-        .command(migrate)
-        .command(installDeps)
-        .command(lint)
-        .command(updateDeps)
-        .command(profile)
-        .command(projectValidate)
-        .demandCommand(1, '');
-    return yargs;
-}
-const builder = makeYargsBuilder(projectBuilder, command, describe);
-const projectCommand = {
-    command,
-    describe,
-    builder,
-    handler: () => { },
-};
-export default projectCommand;

package/commands/sandbox/__tests__/create.test.d.ts

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

package/commands/sandbox/__tests__/create.test.js

@@ -1,245 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
-import sandboxCreateCommand from '../create.js';
-import { hasFeature } from '../../../lib/hasFeature.js';
-import * as sandboxPrompts from '../../../lib/prompts/sandboxesPrompt.js';
-import * as accountNamePrompt from '../../../lib/prompts/accountNamePrompt.js';
-import * as configUtils from '@hubspot/local-dev-lib/config';
-import * as promptUtils from '../../../lib/prompts/promptUtils.js';
-import { trackCommandUsage } from '../../../lib/usageTracking.js';
-import { HUBSPOT_ACCOUNT_TYPES } from '@hubspot/local-dev-lib/constants/config';
-import * as buildAccount from '../../../lib/buildAccount.js';
-import { EXIT_CODES } from '../../../lib/enums/exitCodes.js';
-import { uiLogger } from '../../../lib/ui/logger.js';
-import * as sandboxesLib from '../../../lib/sandboxes.js';
-import * as sandboxSync from '../../../lib/sandboxSync.js';
-import { vi } from 'vitest';
-import { ENVIRONMENTS } from '@hubspot/local-dev-lib/constants/environments';
-vi.mock('@hubspot/local-dev-lib/config');
-vi.mock('../../../lib/commonOpts');
-vi.mock('../../../lib/hasFeature');
-vi.mock('../../../lib/prompts/sandboxesPrompt');
-vi.mock('../../../lib/prompts/promptUtils');
-vi.mock('../../../lib/prompts/accountNamePrompt');
-vi.mock('../../../lib/sandboxes');
-vi.mock('../../../lib/buildAccount');
-vi.mock('../../../lib/sandboxes');
-vi.mock('../../../lib/commonOpts');
-const getConfigAccountByIdSpy = vi.spyOn(configUtils, 'getConfigAccountById');
-const promptUserSpy = vi.spyOn(promptUtils, 'promptUser');
-const sandboxTypePromptSpy = vi.spyOn(sandboxPrompts, 'sandboxTypePrompt');
-const processExitSpy = vi.spyOn(process, 'exit');
-const buildSandboxSpy = vi.spyOn(buildAccount, 'buildSandbox');
-const buildV2SandboxSpy = vi.spyOn(buildAccount, 'buildV2Sandbox');
-const getConfigAccountEnvironmentSpy = vi.spyOn(configUtils, 'getConfigAccountEnvironment');
-const getAvailableSyncTypesSpy = vi.spyOn(sandboxesLib, 'getAvailableSyncTypes');
-const syncSandboxSpy = vi.spyOn(sandboxSync, 'syncSandbox');
-const validateSandboxUsageLimitsSpy = vi.spyOn(sandboxesLib, 'validateSandboxUsageLimits');
-const hubspotAccountNamePromptSpy = vi.spyOn(accountNamePrompt, 'hubspotAccountNamePrompt');
-const mockedHasFeatureV2Sandboxes = hasFeature;
-const mockedHasFeatureV2Cli = hasFeature;
-describe('commands/sandbox/create', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(sandboxCreateCommand.command).toEqual('create');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(sandboxCreateCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            sandboxCreateCommand.builder(yargsMock);
-            expect(yargsMock.example).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-    });
-    describe('handler', () => {
-        let args;
-        const sandboxNameFromPrompt = 'sandbox name from prompt';
-        const mockSandbox = {
-            sandboxHubId: 56789,
-            parentHubId: 123456,
-            createdAt: '2025-01-01',
-            type: 'DEVELOPER',
-            archived: false,
-            version: 'V1',
-            status: 'PENDING',
-            name: 'Test Sandbox',
-            domain: 'test-sandbox.hubspot.com',
-            createdByUser: {
-                userId: 11111,
-                email: 'test@test.com',
-                firstName: 'Test',
-                lastName: 'User',
-            },
-        };
-        beforeEach(() => {
-            args = {
-                derivedAccountId: 1234567890,
-            };
-            getConfigAccountByIdSpy.mockReturnValue({
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-                env: 'prod',
-            });
-            hubspotAccountNamePromptSpy.mockResolvedValue({
-                name: sandboxNameFromPrompt,
-            });
-            sandboxTypePromptSpy.mockResolvedValue({
-                type: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-            });
-            promptUserSpy.mockResolvedValue({
-                contactRecordsSyncPrompt: false,
-            });
-            validateSandboxUsageLimitsSpy.mockResolvedValue(undefined);
-            mockedHasFeatureV2Sandboxes.mockResolvedValue(false);
-            mockedHasFeatureV2Cli.mockResolvedValue(false);
-            getConfigAccountEnvironmentSpy.mockReturnValue(ENVIRONMENTS.PROD);
-            buildSandboxSpy.mockResolvedValue({
-                sandbox: mockSandbox,
-                personalAccessKey: 'mock-personal-access-key',
-                name: sandboxNameFromPrompt,
-            });
-            buildV2SandboxSpy.mockResolvedValue({
-                sandbox: { ...mockSandbox, version: 'V2' },
-            });
-            getAvailableSyncTypesSpy.mockResolvedValue([
-                { type: 'object-schemas' },
-                { type: 'workflows' },
-            ]);
-            syncSandboxSpy.mockResolvedValue(undefined);
-            // Spy on process.exit so our tests don't close when it's called
-            // @ts-expect-error Doesn't match the actual signature because then the linter complains about unused variables
-            processExitSpy.mockImplementation(() => { });
-        });
-        it('should load the account config for the correct account id', async () => {
-            await sandboxCreateCommand.handler(args);
-            expect(getConfigAccountByIdSpy).toHaveBeenCalledTimes(2); // 1st is for parent account, 2nd is for sandbox account
-            expect(getConfigAccountByIdSpy).toHaveBeenCalledWith(args.derivedAccountId);
-        });
-        it('should track the command usage', async () => {
-            await sandboxCreateCommand.handler(args);
-            expect(trackCommandUsage).toHaveBeenCalledTimes(1);
-            expect(trackCommandUsage).toHaveBeenCalledWith('sandbox-create', {}, args.derivedAccountId);
-        });
-        it('should validate sandbox usage limits', async () => {
-            await sandboxCreateCommand.handler(args);
-            expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledTimes(1);
-            expect(validateSandboxUsageLimitsSpy).toHaveBeenCalledWith({
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-                env: 'prod',
-            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod');
-        });
-        it('should prompt for the sandbox type if no type is provided in options', async () => {
-            await sandboxCreateCommand.handler(args);
-            expect(sandboxTypePromptSpy).toHaveBeenCalledTimes(1);
-        });
-        it('should not prompt for the sandbox type if type is provided in options', async () => {
-            await sandboxCreateCommand.handler({
-                ...args,
-                type: 'developer',
-            });
-            expect(sandboxTypePromptSpy).toHaveBeenCalledTimes(0);
-        });
-        it('should not prompt for contact records sync if the sandbox type is developer', async () => {
-            await sandboxCreateCommand.handler({
-                ...args,
-                type: 'developer',
-            });
-            expect(promptUserSpy).toHaveBeenCalledTimes(0);
-        });
-        it('should prompt for the contact records sync if the sandbox type is standard', async () => {
-            await sandboxCreateCommand.handler({
-                ...args,
-                type: 'standard',
-            });
-            expect(promptUserSpy).toHaveBeenCalledTimes(1);
-        });
-        it('should build a v1 sandbox if the parent account is not ungated for sandboxes:v2:enabled and not ungated for sandboxes:v2:cliEnabled', async () => {
-            await sandboxCreateCommand.handler(args);
-            expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
-            expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-                env: 'prod',
-            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
-            );
-            expect(getAvailableSyncTypesSpy).toHaveBeenCalledTimes(1);
-            expect(syncSandboxSpy).toHaveBeenCalledTimes(1);
-        });
-        it('should build a v1 sandbox if the parent account is ungated for sandboxes:v2:enabled but not ungated for sandboxes:v2:cliEnabled', async () => {
-            mockedHasFeatureV2Sandboxes.mockResolvedValue(true);
-            mockedHasFeatureV2Cli.mockResolvedValue(false);
-            await sandboxCreateCommand.handler(args);
-            expect(buildSandboxSpy).toHaveBeenCalledTimes(1);
-            expect(buildSandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-                env: 'prod',
-            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, 'prod', undefined // force
-            );
-            expect(getAvailableSyncTypesSpy).toHaveBeenCalledTimes(1);
-            expect(syncSandboxSpy).toHaveBeenCalledTimes(1);
-        });
-        it('should build a v2 sandbox if the parent account is ungated for both sandboxes:v2:enabled and sandboxes:v2:cliEnabled', async () => {
-            mockedHasFeatureV2Sandboxes.mockResolvedValue(true);
-            mockedHasFeatureV2Cli.mockResolvedValue(true);
-            await sandboxCreateCommand.handler(args);
-            expect(buildV2SandboxSpy).toHaveBeenCalledTimes(1);
-            expect(buildV2SandboxSpy).toHaveBeenCalledWith(sandboxNameFromPrompt, {
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.STANDARD,
-                env: 'prod',
-            }, HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX, false, // syncObjectRecords
-            'prod', undefined // force
-            );
-        });
-        it('should log an error and exit when force is used and invalid sandbox type is provided', async () => {
-            await sandboxCreateCommand.handler({
-                ...args,
-                name: sandboxNameFromPrompt,
-                type: 'invalid',
-                force: true,
-            });
-            expect(uiLogger.error).toHaveBeenCalledTimes(1);
-            expect(processExitSpy).toHaveBeenCalled();
-            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-        });
-        it('should log an error and exit when force is used and no sandbox name is provided', async () => {
-            await sandboxCreateCommand.handler({
-                ...args,
-                type: 'standard',
-                force: true,
-            });
-            expect(uiLogger.error).toHaveBeenCalled();
-            expect(processExitSpy).toHaveBeenCalled();
-            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-        });
-        it('should error out if the default account type is not standard', async () => {
-            getConfigAccountByIdSpy.mockReturnValue({
-                accountId: 1234567890,
-                accountType: HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX,
-                env: 'prod',
-            });
-            await sandboxCreateCommand.handler({
-                ...args,
-                type: 'developer',
-            });
-            expect(uiLogger.error).toHaveBeenCalled();
-            expect(processExitSpy).toHaveBeenCalled();
-            expect(processExitSpy).toHaveBeenCalledWith(EXIT_CODES.ERROR);
-        });
-    });
-});

package/commands/sandbox/__tests__/delete.test.d.ts

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

package/commands/sandbox/__tests__/delete.test.js

@@ -1,31 +0,0 @@
-import yargs from 'yargs';
-import { addAccountOptions, addConfigOptions, addUseEnvironmentOptions, addTestingOptions, } from '../../../lib/commonOpts.js';
-import sandboxDeleteCommand from '../delete.js';
-vi.mock('../../../lib/commonOpts');
-describe('commands/sandbox/delete', () => {
-    const yargsMock = yargs;
-    describe('command', () => {
-        it('should have the correct command structure', () => {
-            expect(sandboxDeleteCommand.command).toEqual('delete');
-        });
-    });
-    describe('describe', () => {
-        it('should provide a description', () => {
-            expect(sandboxDeleteCommand.describe).toBeDefined();
-        });
-    });
-    describe('builder', () => {
-        it('should support the correct options', () => {
-            sandboxDeleteCommand.builder(yargsMock);
-            expect(yargsMock.example).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledTimes(1);
-            expect(addTestingOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addAccountOptions).toHaveBeenCalledTimes(1);
-            expect(addAccountOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addConfigOptions).toHaveBeenCalledTimes(1);
-            expect(addConfigOptions).toHaveBeenCalledWith(yargsMock);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
-            expect(addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
-        });
-    });
-});