@squiz/dxp-cli-next 5.24.0-develop.3 → 5.24.0-develop.4

package/lib/cdp/index.js

@@ -5,8 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const schemaCommand_1 = __importDefault(require("./schema/schemaCommand"));
+const instanceCommand_1 = __importDefault(require("./instance/instanceCommand"));
 const cdpCommand = new commander_1.Command('cdp');
 cdpCommand
     .description('Customer Data Platform Service Commands')
     .addCommand((0, schemaCommand_1.default)());
+if (process.env.ENABLE_CDP_ADMIN === 'true') {
+    cdpCommand.addCommand((0, instanceCommand_1.default)());
+}
 exports.default = cdpCommand;

package/lib/cdp/instance/activate/activate.d.ts

@@ -0,0 +1,5 @@
+import { Command } from 'commander';
+export declare const handleActivateError: (status: number, body: any) => void;
+export declare const errorMessage = "Cannot activate instance as instance is already active";
+declare const createActivateCommand: () => Command | null;
+export default createActivateCommand;

package/lib/cdp/instance/activate/activate.js

@@ -0,0 +1,102 @@
+"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 });
+exports.errorMessage = exports.handleActivateError = void 0;
+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 handleActivateError = (status, body) => {
+    const message = `Status code: ${status}\n${JSON.stringify(body, null, '    ')}`;
+    throw new Error(message);
+};
+exports.handleActivateError = handleActivateError;
+exports.errorMessage = 'Cannot activate instance as instance is already active';
+const createActivateCommand = () => {
+    if (!process.env.ENABLE_CDP_ADMIN) {
+        return null; // Skip command registration if the env var is not set
+    }
+    const activateCommand = new commander_1.Command('deploy')
+        .name('activate')
+        .description('Activate a CDP instance')
+        .addOption(new commander_1.Option('-t, --tenant <string>', 'Tenant ID to run against. If not provided will use configured tenant from login'))
+        .addOption(new commander_1.Option('-r, --region <string>', 'Region for your instance to be activated e.g. au')
+        .choices(['au', 'uk', 'us'])
+        .makeOptionMandatory())
+        .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)(activateCommand);
+        console.log('');
+        const spinner = (0, ora_1.default)('Please wait a few minutes while our cloud builds this for you.').start();
+        try {
+            const apiService = new ApiService_1.ApiService({
+                validateStatus: (status) => {
+                    return status < 400 || status === 404;
+                },
+            });
+            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME, options.tenant, options.overrideUrl, options.region);
+            const apiUrl = `${scvDeployBaseUrl.dxpUrl}/${scvDeployBaseUrl.tenant}`;
+            const getDeployResponse = (yield apiService.client
+                .get(apiUrl)
+                .catch((err) => {
+                (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
+                if (err.response && err.response.status != 404) {
+                    (0, exports.handleActivateError)(err.response.status, err.response.data);
+                }
+            }));
+            if (getDeployResponse.status === 200) {
+                throw new Error(exports.errorMessage);
+            }
+            (0, utils_1.logDebug)(`PUT ${apiUrl}`);
+            const activateInstanceAndDeploySchemaResponse = (yield apiService.client
+                .put(apiUrl, null, {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            })
+                .catch((err) => {
+                (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
+                if (err.response) {
+                    (0, exports.handleActivateError)(err.response.status, err.response.data);
+                }
+            }));
+            (0, utils_1.logDebug)(`Activate instance response: ${JSON.stringify(activateInstanceAndDeploySchemaResponse.data)}`);
+            if (activateInstanceAndDeploySchemaResponse.status === 409) {
+                throw new Error('Currently activating instance. Please try again later.');
+            }
+            yield (0, utils_1.pollForDeployedSchema)(apiUrl, apiService);
+            spinner.succeed('Done!');
+            console.log('');
+            console.log('Your Schema has been deployed and instance has been activated.');
+            console.log('');
+            return;
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${JSON.stringify(error)}`);
+            spinner.fail();
+            (0, utils_1.handleCommandError)(error);
+        }
+    }));
+    if (process.env.ENABLE_OVERRIDE_CDP_SCHEMA_URL === 'true') {
+        activateCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire DXP url with a custom value'));
+    }
+    return activateCommand;
+};
+exports.default = createActivateCommand;

package/lib/cdp/instance/activate/activate.spec.d.ts

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

package/lib/cdp/instance/activate/activate.spec.js

@@ -0,0 +1,141 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nock_1 = __importDefault(require("nock"));
+const activate_1 = __importStar(require("./activate"));
+const deploy_const_1 = require("../../schema/deploy/deploy.const");
+const utils_1 = require("../../utils");
+const activate = __importStar(require("./activate"));
+const mockDomainWithPath = 'http://localhost:9999/__dxp/us/scv-deploy/myTenant';
+function createMockArgs(region, tenantID, filePath, mockDomain) {
+    return [
+        'node',
+        'dxp-cli',
+        'cdp',
+        'instance',
+        'activate',
+        '-t',
+        tenantID,
+        '-r',
+        region,
+        '-ou',
+        'http://localhost:9999',
+    ];
+}
+describe('cdpInstanceCommand', () => {
+    let mockTenant;
+    let mockRegion;
+    let mockFilePath;
+    let mockDomain;
+    let logSpy;
+    let errorSpy;
+    let activateErrorSpy;
+    beforeEach(() => {
+        process.env.ENABLE_CDP_ADMIN = 'true';
+        process.env.ENABLE_OVERRIDE_CDP_SCHEMA_URL = 'true';
+        mockTenant = 'myTenant';
+        mockRegion = 'us';
+        mockFilePath = './src/__tests__/cdp/scv/schema.json';
+        mockDomain = 'http://localhost:9999';
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
+        errorSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
+        activateErrorSpy = jest
+            .spyOn(activate, 'handleActivateError')
+            .mockImplementation(() => { });
+        if (!nock_1.default.isActive()) {
+            nock_1.default.activate();
+        }
+        nock_1.default.cleanAll(); // Ensures each test runs in isolation
+    });
+    afterEach(() => {
+        jest.clearAllMocks(); // Clear all spies after each test
+        nock_1.default.cleanAll(); // Clear all HTTP mocks
+    });
+    it('should throw error when tenant exists', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+        (0, nock_1.default)(mockDomain)
+            .get(mockPath)
+            .reply(200, { status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR });
+        const program = (0, activate_1.default)();
+        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining(activate_1.errorMessage));
+    }));
+    it('should throw error when get tenant returns 403', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+        (0, nock_1.default)(mockDomain).get(mockPath).reply(403, {
+            title: 'Forbidden',
+            status: 403,
+        });
+        const program = (0, activate_1.default)();
+        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        expect(activateErrorSpy).toHaveBeenCalledWith(403, {
+            status: 403,
+            title: 'Forbidden',
+        });
+    }));
+    it('deploys a default schema and activate an instance', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
+        expect(`${mockDomain}${mockPath}`).toEqual(mockDomainWithPath);
+        (0, nock_1.default)(mockDomain)
+            .get(mockPath)
+            .reply(404, {
+            status: deploy_const_1.CDP_DEPLOY_STATUS_ERROR,
+        })
+            .put(mockPath)
+            .reply(200, {
+            tenantid: 'myTenant',
+            version: 'unknown',
+            stack: 'stackName',
+            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+        })
+            .get(mockPath)
+            .reply(200, {
+            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYED,
+        });
+        const program = (0, activate_1.default)();
+        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        // Note the output from the spinner doesn't seem to appear here but this still tests that it
+        // ran without displaying an error.
+        expect(logSpy).toHaveBeenNthCalledWith(1, '');
+        expect(logSpy).toHaveBeenNthCalledWith(2, '');
+        expect(logSpy).toHaveBeenNthCalledWith(3, 'Your Schema has been deployed and instance has been activated.');
+        expect(logSpy).toHaveBeenNthCalledWith(4, '');
+        expect(errorSpy).not.toHaveBeenCalled();
+    }));
+});

package/lib/cdp/instance/instanceCommand.d.ts

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

package/lib/cdp/instance/instanceCommand.js

@@ -0,0 +1,15 @@
+"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 activate_1 = __importDefault(require("./activate/activate"));
+const instanceCommand = () => {
+    const cdpSchemaCommands = new commander_1.Command('instance');
+    cdpSchemaCommands
+        .description('CDP Instance Commands')
+        .addCommand((0, activate_1.default)());
+    return cdpSchemaCommands;
+};
+exports.default = instanceCommand;

package/lib/cdp/schema/deploy/deploy.spec.js

@@ -16,9 +16,7 @@ const nock_1 = __importDefault(require("nock"));
 const deploy_1 = __importDefault(require("./deploy"));
 const deploy_const_1 = require("./deploy.const");
 const path_1 = __importDefault(require("path"));
-function createMockUrl(region, path) {
-    return `/__dxp/${region}/scv-deploy/${path}`;
-}
+const utils_1 = require("../../utils");
 function createMockArgs(region, tenantID, filePath, mockDomain) {
     return [
         'node',
@@ -62,7 +60,7 @@ describe('cdpSchemaCommand', () => {
         jest.clearAllMocks(); // Clear all spies
     });
     it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
-        const mockPath = createMockUrl(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
         (0, nock_1.default)(mockDomain)
             .put(mockPath, require(path_1.default.resolve(process.cwd(), './src/__tests__/cdp/scv/schema.json')))
             .reply(200, {
@@ -83,7 +81,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('presents a formatted invalid schema message', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = createMockUrl(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)
@@ -112,7 +110,7 @@ describe('cdpSchemaCommand', () => {
     }));
     it('deploys a schema', () => __awaiter(void 0, void 0, void 0, function* () {
         const schemaFileContent = require(path_1.default.resolve(process.cwd(), mockFilePath));
-        const mockPath = createMockUrl(mockRegion, mockTenant);
+        const mockPath = (0, utils_1.createMockUrl)(mockRegion, mockTenant);
         expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
         (0, nock_1.default)(mockDomain)
             .get(mockPath)

package/lib/cdp/utils.d.ts

@@ -14,6 +14,7 @@ export declare function buildDXPUrl(serviceName: string, tenantID?: string, over
     tenant: string | undefined;
 }>;
 export declare function handleCommandError(error: Error): void;
+export declare function createMockUrl(region: string, path: string): string;
 /**
  * Poll the schema to be deployed.
  */

package/lib/cdp/utils.js

@@ -12,7 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pollForDeployedSchema = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
+exports.pollForDeployedSchema = exports.createMockUrl = exports.handleCommandError = exports.buildDXPUrl = exports.throwErrorIfNotLoggedIn = exports.logDebug = void 0;
 const ApplicationStore_1 = require("../ApplicationStore");
 const chalk_1 = __importDefault(require("chalk"));
 const ApplicationConfig_1 = require("../ApplicationConfig");
@@ -82,6 +82,10 @@ function handleCommandError(error) {
     }
 }
 exports.handleCommandError = handleCommandError;
+function createMockUrl(region, path) {
+    return `/__dxp/${region}/scv-deploy/${path}`;
+}
+exports.createMockUrl = createMockUrl;
 /**
  * Poll the schema to be deployed.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/dxp-cli-next",
-  "version": "5.24.0-develop.3",
+  "version": "5.24.0-develop.4",
   "repository": {
     "url": "https://gitlab.squiz.net/dxp/dxp-cli-next"
   },