@hubspot/cli 7.7.19-experimental.2 → 7.7.20-experimental.0

package/commands/project/__tests__/devUnifiedFlow.test.js

@@ -0,0 +1,419 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const config_1 = require("@hubspot/local-dev-lib/constants/config");
+const project_parsing_lib_1 = require("@hubspot/project-parsing-lib");
+const config_2 = require("@hubspot/local-dev-lib/config");
+const environment_1 = require("@hubspot/local-dev-lib/environment");
+const errorHandlers_1 = require("../../../lib/errorHandlers");
+const ensureProjectExists_1 = require("../../../lib/projects/ensureProjectExists");
+const helpers_1 = require("../../../lib/projects/localDev/helpers");
+const projectDevTargetAccountPrompt_1 = require("../../../lib/prompts/projectDevTargetAccountPrompt");
+const SpinniesManager_1 = __importDefault(require("../../../lib/ui/SpinniesManager"));
+const LocalDevProcess_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevProcess"));
+const LocalDevWatcher_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWatcher"));
+const LocalDevWebsocketServer_1 = __importDefault(require("../../../lib/projects/localDev/LocalDevWebsocketServer"));
+const process_1 = require("../../../lib/process");
+const accountTypes_1 = require("../../../lib/accountTypes");
+const ui_1 = require("../../../lib/ui");
+const logger_1 = require("../../../lib/ui/logger");
+const en_1 = require("../../../lang/en");
+const unifiedFlow_1 = require("../dev/unifiedFlow");
+const environments_1 = require("@hubspot/local-dev-lib/constants/environments");
+const vitest_1 = require("vitest");
+// Mock @hubspot/ui-extensions-dev-server
+vitest_1.vi.mock('@hubspot/ui-extensions-dev-server', () => ({
+    DevModeUnifiedInterface: {
+        setup: vitest_1.vi.fn().mockResolvedValue(undefined),
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        fileChange: vitest_1.vi.fn().mockResolvedValue(undefined),
+        cleanup: vitest_1.vi.fn().mockResolvedValue(undefined),
+    },
+}));
+// Mock all dependencies
+vitest_1.vi.mock('@hubspot/project-parsing-lib');
+vitest_1.vi.mock('@hubspot/local-dev-lib/config');
+vitest_1.vi.mock('@hubspot/local-dev-lib/environment');
+vitest_1.vi.mock('../../../lib/errorHandlers');
+vitest_1.vi.mock('../../../lib/projects/ensureProjectExists');
+vitest_1.vi.mock('../../../lib/projects/localDev/helpers');
+vitest_1.vi.mock('../../../lib/prompts/projectDevTargetAccountPrompt');
+vitest_1.vi.mock('../../../lib/ui/SpinniesManager');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevProcess');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWatcher');
+vitest_1.vi.mock('../../../lib/projects/localDev/LocalDevWebsocketServer');
+vitest_1.vi.mock('../../../lib/process');
+vitest_1.vi.mock('../../../lib/accountTypes');
+vitest_1.vi.mock('../../../lib/ui');
+vitest_1.vi.mock('../../../lib/ui/logger');
+describe('unifiedProjectDevFlow', () => {
+    const mockArgs = {
+        profile: 'test-profile',
+        d: false,
+        debug: false,
+        derivedAccountId: 123,
+        userProvidedAccount: undefined,
+        testingAccount: undefined,
+        projectAccount: undefined,
+        _: [],
+        $0: 'hs',
+    };
+    const mockProjectConfig = {
+        name: 'test-project',
+        srcDir: 'src',
+        platformVersion: '1.0.0',
+    };
+    const mockProjectDir = '/test/project';
+    const mockTargetProjectAccountId = 123;
+    const mockProvidedTargetTestingAccountId = 456;
+    const mockProfileConfig = {
+        accountId: 789,
+    };
+    const mockAccountConfig = {
+        accountId: 123,
+        name: 'test-account',
+        accountType: config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD,
+    };
+    const mockProject = {
+        id: 1,
+        name: 'test-project',
+        deployedBuild: {
+            buildId: 123,
+            status: 'SUCCESS',
+        },
+        sourceIntegration: null,
+    };
+    const mockProjectNodes = {
+        component1: {
+            uid: 'component1',
+            componentType: 'APP',
+            localDev: {
+                componentRoot: '/test/path',
+                componentConfigPath: '/test/path/config.json',
+                configUpdatedSinceLastUpload: false,
+            },
+        },
+    };
+    const mockLocalDevProcess = {
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
+    };
+    const mockLocalDevWatcher = {
+        start: vitest_1.vi.fn(),
+        stop: vitest_1.vi.fn().mockResolvedValue(undefined),
+    };
+    const mockWebsocketServer = {
+        start: vitest_1.vi.fn().mockResolvedValue(undefined),
+        shutdown: vitest_1.vi.fn().mockResolvedValue(undefined),
+    };
+    beforeEach(() => {
+        vitest_1.vi.clearAllMocks();
+        // Mock process.exit
+        vitest_1.vi.spyOn(global.process, 'exit').mockImplementation((code) => {
+            throw new Error(`Process.exit called with code ${code}`);
+        });
+        // Setup default mocks
+        environment_1.getValidEnv.mockReturnValue(environments_1.ENVIRONMENTS.PROD);
+        project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+            intermediateNodesIndexedByUid: mockProjectNodes,
+        });
+        config_2.getAccountConfig.mockReturnValue(mockAccountConfig);
+        config_2.getConfigAccounts.mockReturnValue([mockAccountConfig]);
+        accountTypes_1.isUnifiedAccount.mockResolvedValue(true);
+        accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+        ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+            projectExists: true,
+            project: mockProject,
+        });
+        SpinniesManager_1.default.init.mockImplementation(() => { });
+        LocalDevProcess_1.default.mockImplementation(() => mockLocalDevProcess);
+        LocalDevWatcher_1.default.mockImplementation(() => mockLocalDevWatcher);
+        LocalDevWebsocketServer_1.default.mockImplementation(() => mockWebsocketServer);
+        process_1.handleKeypress.mockImplementation(() => { });
+        process_1.handleExit.mockImplementation(() => { });
+        logger_1.uiLogger.debug.mockImplementation(() => { });
+        logger_1.uiLogger.error.mockImplementation(() => { });
+        logger_1.uiLogger.log.mockImplementation(() => { });
+        ui_1.uiLine.mockImplementation(() => { });
+    });
+    describe('successful flow', () => {
+        it('should complete successfully with existing project and provided testing account', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(project_parsing_lib_1.translateForLocalDev).toHaveBeenCalledWith({
+                projectSourceDir: path_1.default.join(mockProjectDir, mockProjectConfig.srcDir),
+                platformVersion: mockProjectConfig.platformVersion,
+                accountId: mockTargetProjectAccountId,
+            }, { profile: mockArgs.profile });
+            expect(mockLocalDevProcess.start).toHaveBeenCalled();
+            expect(mockLocalDevWatcher.start).toHaveBeenCalled();
+            expect(mockWebsocketServer.start).toHaveBeenCalled();
+        });
+        it('should complete successfully with profile config', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                profileConfig: mockProfileConfig,
+            });
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                targetTestingAccountId: mockProfileConfig.accountId,
+            }));
+        });
+        it('should use target project account as testing account when it is a test account', async () => {
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(true);
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                targetTestingAccountId: mockTargetProjectAccountId,
+            }));
+        });
+    });
+    describe('error handling', () => {
+        it('should exit with error code when translation fails', async () => {
+            const translationError = new Error('Translation failed');
+            project_parsing_lib_1.translateForLocalDev.mockRejectedValue(translationError);
+            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            })).rejects.toThrow('Process.exit called with code 1');
+            expect(errorHandlers_1.logError).toHaveBeenCalledWith(translationError);
+        });
+        it('should exit with success when no runnable components found', async () => {
+            project_parsing_lib_1.translateForLocalDev.mockResolvedValue({
+                intermediateNodesIndexedByUid: {},
+            });
+            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            })).rejects.toThrow('Process.exit called with code 0');
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.noRunnableComponents);
+        });
+        it('should exit with error when account config not found', async () => {
+            config_2.getAccountConfig.mockReturnValue(null);
+            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            })).rejects.toThrow('Process.exit called with code 1');
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.noAccount(mockTargetProjectAccountId));
+        });
+        it('should exit with error when account is not combined and no profile', async () => {
+            accountTypes_1.isUnifiedAccount.mockResolvedValue(false);
+            await expect((0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            })).rejects.toThrow('Process.exit called with code 1');
+            expect(logger_1.uiLogger.error).toHaveBeenCalledWith(en_1.commands.project.dev.errors.accountNotCombined);
+        });
+    });
+    describe('account type selection and prompting', () => {
+        beforeEach(() => {
+            // Reset to require prompting
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+        });
+        it('should prompt for account type when no testing account provided', async () => {
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+                targetAccountId: 456,
+            });
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(helpers_1.selectAccountTypePrompt).toHaveBeenCalledWith(mockAccountConfig);
+            expect(projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt).toHaveBeenCalled();
+        });
+        it('should handle developer test account creation', async () => {
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+                createNestedAccount: true,
+            });
+            helpers_1.createDeveloperTestAccountForLocalDev.mockResolvedValue(999);
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(helpers_1.createDeveloperTestAccountForLocalDev).toHaveBeenCalledWith(mockTargetProjectAccountId, mockAccountConfig, environments_1.ENVIRONMENTS.PROD);
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                targetTestingAccountId: 999,
+            }));
+        });
+        it('should handle existing developer test account not in config', async () => {
+            const notInConfigAccount = { accountId: 777, name: 'external-account' };
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPER_TEST);
+            projectDevTargetAccountPrompt_1.selectDeveloperTestTargetAccountPrompt.mockResolvedValue({
+                notInConfigAccount,
+            });
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(helpers_1.useExistingDevTestAccount).toHaveBeenCalledWith(environments_1.ENVIRONMENTS.PROD, notInConfigAccount);
+        });
+        it('should handle sandbox account selection', async () => {
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.DEVELOPMENT_SANDBOX);
+            projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt.mockResolvedValue({
+                targetAccountId: 888,
+            });
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(projectDevTargetAccountPrompt_1.selectSandboxTargetAccountPrompt).toHaveBeenCalled();
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                targetTestingAccountId: 888,
+            }));
+        });
+    });
+    describe('project creation', () => {
+        it('should create new project when project does not exist', async () => {
+            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+                projectExists: false,
+                project: null,
+            });
+            helpers_1.createNewProjectForLocalDev.mockResolvedValue(mockProject);
+            helpers_1.createInitialBuildForNewProject.mockResolvedValue({
+                buildId: 456,
+            });
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(helpers_1.createNewProjectForLocalDev).toHaveBeenCalledWith(mockProjectConfig, mockTargetProjectAccountId, false, false);
+            expect(helpers_1.createInitialBuildForNewProject).toHaveBeenCalledWith(mockProjectConfig, mockProjectDir, mockTargetProjectAccountId, true, mockArgs.profile);
+        });
+        it('should use existing project and build when project exists', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(helpers_1.createNewProjectForLocalDev).not.toHaveBeenCalled();
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                deployedBuild: mockProject.deployedBuild,
+                projectId: mockProject.id,
+                projectName: mockProject.name,
+            }));
+        });
+        it('should detect GitHub linked projects', async () => {
+            const githubLinkedProject = {
+                ...mockProject,
+                sourceIntegration: { source: 'GITHUB' },
+            };
+            ensureProjectExists_1.ensureProjectExists.mockResolvedValue({
+                projectExists: true,
+                project: githubLinkedProject,
+            });
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith(expect.objectContaining({
+                isGithubLinked: true,
+            }));
+        });
+    });
+    describe('local dev process setup', () => {
+        it('should initialize LocalDevProcess with correct parameters', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(LocalDevProcess_1.default).toHaveBeenCalledWith({
+                initialProjectNodes: mockProjectNodes,
+                debug: mockArgs.debug,
+                deployedBuild: mockProject.deployedBuild,
+                isGithubLinked: false,
+                profile: mockArgs.profile,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                targetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+                projectName: mockProject.name,
+                projectId: mockProject.id,
+                env: environments_1.ENVIRONMENTS.PROD,
+            });
+        });
+        it('should set up keypress and exit handlers', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(process_1.handleKeypress).toHaveBeenCalledWith(expect.any(Function));
+            expect(process_1.handleExit).toHaveBeenCalledWith(expect.any(Function));
+        });
+        it('should start all required services', async () => {
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                providedTargetTestingAccountId: mockProvidedTargetTestingAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(mockLocalDevProcess.start).toHaveBeenCalled();
+            expect(mockLocalDevWatcher.start).toHaveBeenCalled();
+            expect(mockWebsocketServer.start).toHaveBeenCalled();
+            expect(SpinniesManager_1.default.init).toHaveBeenCalled();
+        });
+    });
+    describe('UI messaging', () => {
+        beforeEach(() => {
+            accountTypes_1.isTestAccountOrSandbox.mockReturnValue(false);
+        });
+        it('should display account type information when prompting', async () => {
+            helpers_1.selectAccountTypePrompt.mockResolvedValue(config_1.HUBSPOT_ACCOUNT_TYPES.STANDARD);
+            await (0, unifiedFlow_1.unifiedProjectDevFlow)({
+                args: mockArgs,
+                targetProjectAccountId: mockTargetProjectAccountId,
+                projectConfig: mockProjectConfig,
+                projectDir: mockProjectDir,
+            });
+            expect(ui_1.uiLine).toHaveBeenCalled();
+            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.accountTypeInformation);
+            expect(logger_1.uiLogger.log).toHaveBeenCalledWith(en_1.commands.project.dev.logs.learnMoreMessage);
+        });
+    });
+});

package/commands/project/__tests__/download.test.d.ts

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

package/commands/project/__tests__/download.test.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yargs_1 = __importDefault(require("yargs"));
+const commonOpts_1 = require("../../../lib/commonOpts");
+const download_1 = __importDefault(require("../download"));
+vi.mock('../../../lib/commonOpts');
+describe('commands/project/download', () => {
+    const yargsMock = yargs_1.default;
+    describe('command', () => {
+        it('should have the correct command structure', () => {
+            expect(download_1.default.command).toEqual('download');
+        });
+    });
+    describe('describe', () => {
+        it('should provide a description', () => {
+            expect(download_1.default.describe).toBeDefined();
+        });
+    });
+    describe('builder', () => {
+        it('should support the correct options', () => {
+            download_1.default.builder(yargsMock);
+            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.addAccountOptions).toHaveBeenCalledWith(yargsMock);
+            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.addConfigOptions).toHaveBeenCalledWith(yargsMock);
+            expect(commonOpts_1.addUseEnvironmentOptions).toHaveBeenCalledTimes(1);
+            expect(commonOpts_1.addUseEnvironmentOptions).toHaveBeenCalledWith(yargsMock);
+        });
+        it('should define project, dest, and build options', () => {
+            const optionsSpy = vi.spyOn(yargsMock, 'options');
+            const exampleSpy = vi.spyOn(yargsMock, 'example');
+            download_1.default.builder(yargsMock);
+            expect(optionsSpy).toHaveBeenCalledWith(expect.objectContaining({
+                project: expect.any(Object),
+                dest: expect.any(Object),
+                build: expect.any(Object),
+            }));
+            expect(exampleSpy).toHaveBeenCalled();
+        });
+    });
+});

package/commands/project/__tests__/fixtures/exampleProject.json

@@ -0,0 +1,33 @@
+{
+    "latestBuild": {
+        "activitySource": {
+            "userId": 123,
+            "type": "HUBSPOT"
+        },
+        "buildId": 8,
+        "createdAt": "123456",
+        "deployableState": "DEPLOYABLE",
+        "deployStatusTaskLocator": {
+            "id": "123",
+            "links": []
+        },
+        "enqueuedAt": "123456",
+        "finishedAt": "123456",
+        "isAutoDeployEnabled": true,
+        "portalId": 123,
+        "projectName": "project name",
+        "startedAt": "123456",
+        "status": "SUCCESS",
+        "subbuildStatuses": [],
+        "uploadMessage": "Upload message",
+        "autoDeployId": 123
+    },
+    "deployedBuildId": 1,
+    "createdAt": 123456,
+    "deletedAt": 123456,
+    "updatedAt": 123456,
+    "id": 123,
+    "isLocked": false,
+    "name": "project name",
+    "portalId": 123
+}

package/commands/project/__tests__/installDeps.test.d.ts

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