@squiz/dxp-cli-next 5.14.0 → 5.15.0-develop.2

package/lib/porter/port/get/get.js

@@ -0,0 +1,94 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const ApiService_1 = require("../../../ApiService");
+const utils_1 = require("../../utils");
+const constants_1 = require("../../constants");
+const dxp_porter_shared_1 = require("@squiz/dxp-porter-shared");
+const createGetPortCommand = () => {
+    const getCommand = new commander_1.Command('getPort')
+        .description('Gets the information about a specified website port')
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .addArgument(new commander_1.Argument('UUID', 'ID of the port').argParser((portId) => {
+        const trimmedPortId = portId.trim();
+        if (!trimmedPortId) {
+            throw new commander_1.InvalidArgumentError(constants_1.PORTER_ERRORS.portIdBlankError);
+        }
+        return trimmedPortId;
+    }))
+        .action((uuid) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a, _b, _c, _d;
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(getCommand);
+        const baseUrl = yield (0, utils_1.buildPorterUrl)();
+        const portId = uuid;
+        let projectName = '';
+        const spinner = (0, ora_1.default)();
+        try {
+            projectName = yield (0, utils_1.getProjectName)();
+            spinner.start('Retrieving port..');
+            const apiService = new ApiService_1.ApiService(utils_1.validateAxiosStatus, baseUrl);
+            const response = yield apiService.client.get(`/projects/${projectName}/ports/${portId}`);
+            const jsonResponse = response.data;
+            (0, utils_1.logDebug)(JSON.stringify(jsonResponse));
+            const { portid, stages, 'stage-settings': stageSettings, status, } = jsonResponse;
+            const artifactsLink = (_a = jsonResponse['artifacts-link']) !== null && _a !== void 0 ? _a : 'Not generated';
+            const reportLink = (_b = jsonResponse['report-link']) !== null && _b !== void 0 ? _b : 'Not generated';
+            spinner.succeed();
+            console.log('');
+            console.log(`Port ID: ${portid}`);
+            console.log(`Status: ${status}`);
+            console.log(`Download report: ${reportLink}`);
+            console.log(`Download artifacts: ${artifactsLink}`);
+            console.log('');
+            for (const stage of Object.values(dxp_porter_shared_1.Stage)) {
+                if (stage === dxp_porter_shared_1.Stage['component-transform'] ||
+                    stage === dxp_porter_shared_1.Stage['design-dedupe']) {
+                    continue;
+                }
+                const stageString = stage.replace(/-/, ' ');
+                console.log(`Stage ${stageString} status: ${stages[stage].status}`);
+            }
+            console.log('');
+            for (const stage of Object.values(dxp_porter_shared_1.Stage)) {
+                if (stage === dxp_porter_shared_1.Stage['component-transform'] ||
+                    stage === dxp_porter_shared_1.Stage['design-dedupe']) {
+                    continue;
+                }
+                const stageString = stage.replace(/-/, ' ');
+                console.log(`Stage ${stageString} settings:`, stageSettings[stage]);
+            }
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${error instanceof Error ? `${error.message}` : JSON.stringify(error)}`);
+            if (spinner.isSpinning) {
+                spinner.fail();
+            }
+            if (((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.status) === 404) {
+                (0, utils_1.logDebug)(error.response.data);
+                const errorMessage = 'Website port execution not found';
+                return (0, utils_1.handleError)(getCommand, errorMessage);
+            }
+            (0, utils_1.handleCommandError)(getCommand, error);
+        }
+    }));
+    return getCommand;
+};
+exports.default = createGetPortCommand;

package/lib/porter/port/get/get.spec.d.ts

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

package/lib/porter/port/get/get.spec.js

@@ -0,0 +1,255 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const ApiService = __importStar(require("../../../ApiService"));
+const PorterUtils = __importStar(require("../../utils"));
+const constants_1 = require("../../constants");
+const dxp_porter_shared_1 = require("@squiz/dxp-porter-shared");
+const logSpy = jest.spyOn(global.console, 'log');
+jest.mock('../../utils');
+describe('getPort', () => {
+    let projectName;
+    let portId;
+    let baseUrl;
+    let mockHandleCommandError;
+    let mockHandleError;
+    let mockBuildPorterUrl;
+    let mockResponse;
+    let mockClient;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.clearAllMocks();
+        projectName = 'mock-project';
+        portId = '1234-5678-1234-5678';
+        baseUrl = 'mock-url';
+        mockHandleCommandError = jest.fn(() => Promise.resolve());
+        mockHandleError = jest.fn();
+        mockBuildPorterUrl = jest.fn(() => Promise.resolve(baseUrl));
+        mockResponse = {
+            data: {},
+            status: 200,
+        };
+        mockClient = {
+            get: jest.fn().mockImplementationOnce(() => mockResponse),
+        };
+        jest.spyOn(PorterUtils, 'throwErrorIfNotLoggedIn').mockImplementation();
+        jest
+            .spyOn(PorterUtils, 'buildPorterUrl')
+            .mockImplementationOnce(mockBuildPorterUrl);
+        jest
+            .spyOn(PorterUtils, 'getProjectName')
+            .mockImplementation(() => Promise.resolve(projectName));
+        jest
+            .spyOn(PorterUtils, 'handleCommandError')
+            .mockImplementationOnce(mockHandleCommandError);
+        jest
+            .spyOn(PorterUtils, 'handleError')
+            .mockImplementationOnce(mockHandleError);
+        jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(ApiService, 'ApiService').mockImplementationOnce(() => {
+            return {
+                client: mockClient,
+            };
+        });
+    });
+    it('should throw an error if port id is invalid', () => __awaiter(void 0, void 0, void 0, function* () {
+        const portIdInvalid = ' ';
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield expect(() => program.parseAsync(['port', 'getPort', portIdInvalid])).rejects.toThrow(constants_1.PORTER_ERRORS.portIdBlankError);
+    }));
+    it('should throw an error if not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockError = new Error('Error not logged in');
+        jest
+            .spyOn(PorterUtils, 'throwErrorIfNotLoggedIn')
+            .mockImplementationOnce(() => {
+            throw mockError;
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield expect(() => program.parseAsync(['port', 'getPort', portId])).rejects.toThrow(mockError);
+        const opts = program.opts();
+        expect(opts).toStrictEqual({});
+        expect(PorterUtils.buildPorterUrl).not.toHaveBeenCalled();
+    }));
+    it('should throw an error if project name could not be found', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(PorterUtils, 'getProjectName').mockImplementationOnce(() => {
+            throw new Error();
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['port', 'getPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should handle 404 error when port cannot be found for project', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.get = jest.fn(() => {
+            throw new axios_1.AxiosError('Port does not exist', '404', undefined, undefined, {
+                data: { status: 404 },
+            });
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['port', 'getPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalledWith(`/projects/${projectName}/ports/${portId}`);
+        expect(PorterUtils.handleError).toHaveBeenCalled();
+    }));
+    it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.get = jest.fn(() => {
+            throw new axios_1.AxiosError('Internal server error', '500', undefined, undefined, {
+                data: { status: 500 },
+            });
+        });
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['port', 'getPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalledWith(`/projects/${projectName}/ports/${portId}`);
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should successfully retrieve the port details and log this to the console', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockStatus = dxp_porter_shared_1.PortStatus.complete;
+        const mockGetResponse = {
+            portid: portId,
+            'artifacts-link': null,
+            'report-link': null,
+            'stage-settings': {
+                crawl: { run: true, start_urls: [] },
+                index: { run: false },
+                'component-transform': { run: false },
+                'design-dedupe': { run: false },
+                'template-dedupe': { run: false },
+                validation: { run: false },
+                report: { run: false },
+            },
+            stages: {
+                crawl: { status: dxp_porter_shared_1.PortStatus.complete },
+                index: { status: dxp_porter_shared_1.PortStatus.skipped },
+                'component-transform': { status: dxp_porter_shared_1.PortStatus.skipped },
+                'design-dedupe': { status: dxp_porter_shared_1.PortStatus.skipped },
+                'template-dedupe': { status: dxp_porter_shared_1.PortStatus.skipped },
+                validation: { status: dxp_porter_shared_1.PortStatus.skipped },
+                report: { status: dxp_porter_shared_1.PortStatus.skipped },
+            },
+            status: mockStatus,
+        };
+        mockResponse = {
+            data: mockGetResponse,
+            status: 200,
+        };
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['port', 'getPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalledWith(`/projects/${projectName}/ports/${portId}`);
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenNthCalledWith(2, `Port ID: ${portId}`);
+        expect(logSpy).toHaveBeenNthCalledWith(3, `Status: ${mockStatus}`);
+        expect(logSpy).toHaveBeenNthCalledWith(4, 'Download report: Not generated');
+        expect(logSpy).toHaveBeenNthCalledWith(5, 'Download artifacts: Not generated');
+        expect(logSpy).toHaveBeenNthCalledWith(6, '');
+        expect(logSpy).toHaveBeenNthCalledWith(7, 'Stage crawl status: complete');
+        expect(logSpy).toHaveBeenNthCalledWith(8, 'Stage index status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(9, 'Stage template dedupe status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(10, 'Stage validation status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(11, 'Stage report status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(12, '');
+        expect(logSpy).toHaveBeenNthCalledWith(13, 'Stage crawl settings:', mockGetResponse['stage-settings'].crawl);
+        expect(logSpy).toHaveBeenNthCalledWith(14, 'Stage index settings:', mockGetResponse['stage-settings'].index);
+        expect(logSpy).toHaveBeenNthCalledWith(15, 'Stage template dedupe settings:', mockGetResponse['stage-settings']['template-dedupe']);
+        expect(logSpy).toHaveBeenNthCalledWith(16, 'Stage validation settings:', mockGetResponse['stage-settings'].validation);
+        expect(logSpy).toHaveBeenNthCalledWith(17, 'Stage report settings:', mockGetResponse['stage-settings'].report);
+    }));
+    it('should successfully retrieve the port details and log this to the console with non-null links', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockStatus = dxp_porter_shared_1.PortStatus.complete;
+        const mockReportLink = 'report-link';
+        const mockArtifactsLink = 'artifacts-link';
+        const mockGetResponse = {
+            portid: portId,
+            'artifacts-link': mockArtifactsLink,
+            'report-link': mockReportLink,
+            'stage-settings': {
+                crawl: { run: true, start_urls: [] },
+                index: { run: false },
+                'component-transform': { run: false },
+                'design-dedupe': { run: false },
+                'template-dedupe': { run: false },
+                validation: { run: false },
+                report: { run: false },
+            },
+            stages: {
+                crawl: { status: dxp_porter_shared_1.PortStatus.complete },
+                index: { status: dxp_porter_shared_1.PortStatus.skipped },
+                'component-transform': { status: dxp_porter_shared_1.PortStatus.skipped },
+                'design-dedupe': { status: dxp_porter_shared_1.PortStatus.skipped },
+                'template-dedupe': { status: dxp_porter_shared_1.PortStatus.skipped },
+                validation: { status: dxp_porter_shared_1.PortStatus.skipped },
+                report: { status: dxp_porter_shared_1.PortStatus.skipped },
+            },
+            status: mockStatus,
+        };
+        mockResponse = {
+            data: mockGetResponse,
+            status: 200,
+        };
+        const { default: createGetCommand } = require('./get');
+        const program = createGetCommand();
+        yield program.parseAsync(['port', 'getPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.get).toHaveBeenCalledWith(`/projects/${projectName}/ports/${portId}`);
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+        expect(logSpy).toHaveBeenNthCalledWith(2, `Port ID: ${portId}`);
+        expect(logSpy).toHaveBeenNthCalledWith(3, `Status: ${mockStatus}`);
+        expect(logSpy).toHaveBeenNthCalledWith(4, `Download report: ${mockReportLink}`);
+        expect(logSpy).toHaveBeenNthCalledWith(5, `Download artifacts: ${mockArtifactsLink}`);
+        expect(logSpy).toHaveBeenNthCalledWith(6, '');
+        expect(logSpy).toHaveBeenNthCalledWith(7, 'Stage crawl status: complete');
+        expect(logSpy).toHaveBeenNthCalledWith(8, 'Stage index status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(9, 'Stage template dedupe status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(10, 'Stage validation status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(11, 'Stage report status: skipped');
+        expect(logSpy).toHaveBeenNthCalledWith(12, '');
+        expect(logSpy).toHaveBeenNthCalledWith(13, 'Stage crawl settings:', mockGetResponse['stage-settings'].crawl);
+        expect(logSpy).toHaveBeenNthCalledWith(14, 'Stage index settings:', mockGetResponse['stage-settings'].index);
+        expect(logSpy).toHaveBeenNthCalledWith(15, 'Stage template dedupe settings:', mockGetResponse['stage-settings']['template-dedupe']);
+        expect(logSpy).toHaveBeenNthCalledWith(16, 'Stage validation settings:', mockGetResponse['stage-settings'].validation);
+        expect(logSpy).toHaveBeenNthCalledWith(17, 'Stage report settings:', mockGetResponse['stage-settings'].report);
+    }));
+});

package/lib/porter/port/portCommand.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createPortCommand: () => Command;
+export default createPortCommand;

package/lib/porter/port/portCommand.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const abort_1 = __importDefault(require("./abort/abort"));
+const get_1 = __importDefault(require("./get/get"));
+const start_1 = __importDefault(require("./start/start"));
+const createPortCommand = () => {
+    const portCommand = new commander_1.Command('port');
+    portCommand
+        .description('Porter port commands')
+        .addCommand((0, start_1.default)())
+        .addCommand((0, get_1.default)())
+        .addCommand((0, abort_1.default)());
+    return portCommand;
+};
+exports.default = createPortCommand;

package/lib/porter/port/start/start.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createStartPortCommand: () => Command;
+export default createStartPortCommand;

package/lib/porter/port/start/start.js

@@ -0,0 +1,79 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const ora_1 = __importDefault(require("ora"));
+const ApiService_1 = require("../../../ApiService");
+const utils_1 = require("../../utils");
+const createStartPortCommand = () => {
+    const getCommand = new commander_1.Command('startPort')
+        .description('Start porting a website using the local project configuration')
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        yield (0, utils_1.throwErrorIfNotLoggedIn)(getCommand);
+        const baseUrl = yield (0, utils_1.buildPorterUrl)();
+        let projectName = '';
+        const spinner = (0, ora_1.default)();
+        try {
+            projectName = yield (0, utils_1.getProjectName)();
+            spinner.start('Starting port..');
+            const apiService = new ApiService_1.ApiService(utils_1.validateAxiosStatus, baseUrl);
+            // Read the stage directories for project configuration
+            const stageConfigDir = path_1.default.resolve('stage-configs');
+            const stageDirs = yield promises_1.default.readdir(stageConfigDir);
+            // Currently, skip component-transform and design-dedupe
+            const portSettings = {
+                'component-transform': { run: false },
+                'design-dedupe': { run: false },
+            };
+            // Read the config files for each stage, and construct the overall port settings
+            yield Promise.all(stageDirs.map((stage) => __awaiter(void 0, void 0, void 0, function* () {
+                const stageConfigFile = path_1.default.resolve(stageConfigDir, stage, 'config.json');
+                const stageConfig = yield promises_1.default.readFile(stageConfigFile, {
+                    encoding: 'utf-8',
+                });
+                const config = JSON.parse(stageConfig);
+                const updatedConfig = Object.assign(Object.assign({}, portSettings[stage]), config);
+                portSettings[stage] = updatedConfig;
+            })));
+            (0, utils_1.logDebug)(`Port settings to use: ${JSON.stringify(portSettings)}`);
+            const portRequest = {
+                ['stage-settings']: portSettings,
+            };
+            const response = yield apiService.client.post(`/projects/${projectName}/ports`, portRequest);
+            const jsonResponse = response.data;
+            (0, utils_1.logDebug)(JSON.stringify(jsonResponse));
+            const { portid } = jsonResponse;
+            spinner.succeed();
+            console.log('');
+            console.log(`Website porting in progress with ID: ${portid}`);
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${error instanceof Error ? `${error.message}` : JSON.stringify(error)}`);
+            if (spinner.isSpinning) {
+                spinner.fail();
+            }
+            (0, utils_1.handleCommandError)(getCommand, error);
+        }
+    }));
+    return getCommand;
+};
+exports.default = createStartPortCommand;

package/lib/porter/port/start/start.spec.d.ts

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

package/lib/porter/port/start/start.spec.js

@@ -0,0 +1,198 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = require("axios");
+const ApiService = __importStar(require("../../../ApiService"));
+const PorterUtils = __importStar(require("../../utils"));
+const fsp = __importStar(require("fs/promises"));
+// const logSpy = jest.spyOn(global.console, 'log');
+jest.mock('../../utils');
+jest.mock('fs/promises');
+describe('startPort', () => {
+    let projectName;
+    let portId;
+    let baseUrl;
+    let mockHandleCommandError;
+    let mockHandleError;
+    let mockBuildPorterUrl;
+    let mockResponse;
+    let mockClient;
+    beforeEach(() => {
+        jest.resetAllMocks();
+        jest.clearAllMocks();
+        projectName = 'mock-project';
+        portId = '1234-5678-1234-5678';
+        baseUrl = 'mock-url';
+        mockHandleCommandError = jest.fn(() => Promise.resolve());
+        mockHandleError = jest.fn();
+        mockBuildPorterUrl = jest.fn(() => Promise.resolve(baseUrl));
+        mockResponse = {
+            data: {},
+            status: 200,
+        };
+        mockClient = {
+            post: jest.fn().mockImplementationOnce(() => mockResponse),
+        };
+        jest.spyOn(PorterUtils, 'throwErrorIfNotLoggedIn').mockImplementation();
+        jest
+            .spyOn(PorterUtils, 'buildPorterUrl')
+            .mockImplementationOnce(mockBuildPorterUrl);
+        jest
+            .spyOn(PorterUtils, 'getProjectName')
+            .mockImplementation(() => Promise.resolve(projectName));
+        jest
+            .spyOn(fsp, 'readdir')
+            .mockImplementationOnce(() => Promise.resolve([
+            'crawl',
+            'index',
+            'template-dedupe',
+            'validation',
+            'report',
+        ]));
+        jest
+            .spyOn(fsp, 'readFile')
+            .mockImplementation(() => Promise.resolve(JSON.stringify({ run: true })));
+        jest
+            .spyOn(PorterUtils, 'handleCommandError')
+            .mockImplementationOnce(mockHandleCommandError);
+        jest
+            .spyOn(PorterUtils, 'handleError')
+            .mockImplementationOnce(mockHandleError);
+        jest.spyOn(process, 'exit').mockImplementation();
+        jest.spyOn(ApiService, 'ApiService').mockImplementationOnce(() => {
+            return {
+                client: mockClient,
+            };
+        });
+    });
+    it('should throw an error if not logged in', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockError = new Error('Error not logged in');
+        jest
+            .spyOn(PorterUtils, 'throwErrorIfNotLoggedIn')
+            .mockImplementationOnce(() => {
+            throw mockError;
+        });
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield expect(() => program.parseAsync(['port', 'startPort', portId])).rejects.toThrow(mockError);
+        const opts = program.opts();
+        expect(opts).toStrictEqual({});
+        expect(PorterUtils.buildPorterUrl).not.toHaveBeenCalled();
+    }));
+    it('should throw an error if project name could not be found', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest.spyOn(PorterUtils, 'getProjectName').mockImplementationOnce(() => {
+            throw new Error();
+        });
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield program.parseAsync(['port', 'startPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.post).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should handle errors reading stage config files', () => __awaiter(void 0, void 0, void 0, function* () {
+        jest
+            .spyOn(fsp, 'readdir')
+            .mockReset()
+            .mockImplementationOnce(() => {
+            throw new Error('ENOENT: no such file or directory');
+        });
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield program.parseAsync(['port', 'startPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.post).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should handle 400 error from the porter service', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.post = jest.fn(() => {
+            throw new axios_1.AxiosError('Bad request', '400', undefined, undefined, {
+                data: {
+                    status: 400,
+                    title: 'Bad request',
+                    'invalid-params': [
+                        { name: 'crawl.run', reason: 'crawl.run is required in the body' },
+                    ],
+                },
+            });
+        });
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield program.parseAsync(['port', 'startPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.post).toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should handle unexpected errors', () => __awaiter(void 0, void 0, void 0, function* () {
+        mockClient.post = jest.fn(() => {
+            throw new axios_1.AxiosError('Internal server error', '500', undefined, undefined, {
+                data: { status: 500 },
+            });
+        });
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield program.parseAsync(['port', 'startPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.post).toHaveBeenCalled();
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).toHaveBeenCalled();
+    }));
+    it('should successfully start a website port and log to the console', () => __awaiter(void 0, void 0, void 0, function* () {
+        const uuid = '1234-1234-1234-1234';
+        const mockPostResponse = {
+            portid: uuid,
+        };
+        mockResponse = {
+            data: mockPostResponse,
+            status: 200,
+        };
+        const { default: createStartCommand } = require('./start');
+        const program = createStartCommand();
+        yield program.parseAsync(['port', 'startPort', portId]);
+        expect(PorterUtils.buildPorterUrl).toHaveBeenCalled();
+        expect(mockClient.post).toHaveBeenCalledWith(`/projects/${projectName}/ports`, {
+            'stage-settings': {
+                crawl: { run: true },
+                index: { run: true },
+                'component-transform': { run: false },
+                'design-dedupe': { run: false },
+                'template-dedupe': { run: true },
+                validation: { run: true },
+                report: { run: true },
+            },
+        });
+        expect(PorterUtils.handleError).not.toHaveBeenCalled();
+        expect(PorterUtils.handleCommandError).not.toHaveBeenCalled();
+    }));
+});

package/lib/porter/project/add/add.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const createAddProjectCommand: () => Command;
+export default createAddProjectCommand;