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

package/README.md

@@ -24,4 +24,5 @@ Commands:
   cmp            Component Service Commands
   job-runner     Job Runner Service Commands
   datastore      Datastore Service Commands
+  cdp            Customer Data Platform Service Commands
 ```

package/lib/__tests__/integration/main.spec.js

@@ -16,6 +16,7 @@ describe('dxp', () => {
             'cmp            Component Service Commands',
             'job-runner     Job Runner Service Commands',
             'datastore      Datastore Commands',
+            'cdp            CDP Commands',
         ]);
     });
 });

package/lib/cdp/constants.d.ts

@@ -0,0 +1 @@
+export declare const SCV_DEPLOY_SERVICE_NAME = "scv-deploy";

package/lib/cdp/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SCV_DEPLOY_SERVICE_NAME = void 0;
+exports.SCV_DEPLOY_SERVICE_NAME = 'scv-deploy';

package/lib/cdp/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare const cdpCommand: Command;
+export default cdpCommand;

package/lib/cdp/index.js

@@ -0,0 +1,10 @@
+"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 schemaCommand_1 = __importDefault(require("./schema/schemaCommand"));
+const cdpCommand = new commander_1.Command('cdp');
+cdpCommand.description('CDP Commands').addCommand((0, schemaCommand_1.default)());
+exports.default = cdpCommand;

package/lib/cdp/schema/deploy/deploy.const.d.ts

@@ -0,0 +1,5 @@
+export declare const CDP_DEPLOY_STATUS_ERROR = "error";
+export declare const CDP_DEPLOY_STATUS_DEPLOYED = "deployed";
+export declare const CDP_DEPLOY_STATUS_DELETED = "deleted";
+export declare const CDP_DEPLOY_STATUS_DELETING = "deleting";
+export declare const CDP_DEPLOY_STATUS_DEPLOYING = "deploying";

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CDP_DEPLOY_STATUS_DEPLOYING = exports.CDP_DEPLOY_STATUS_DELETING = exports.CDP_DEPLOY_STATUS_DELETED = exports.CDP_DEPLOY_STATUS_DEPLOYED = exports.CDP_DEPLOY_STATUS_ERROR = void 0;
+exports.CDP_DEPLOY_STATUS_ERROR = 'error';
+exports.CDP_DEPLOY_STATUS_DEPLOYED = 'deployed';
+exports.CDP_DEPLOY_STATUS_DELETED = 'deleted';
+exports.CDP_DEPLOY_STATUS_DELETING = 'deleting';
+exports.CDP_DEPLOY_STATUS_DEPLOYING = 'deploying';

package/lib/cdp/schema/deploy/deploy.d.ts

@@ -0,0 +1,4 @@
+import { Command } from 'commander';
+export declare const handleDeployError: (status: number, body: any) => void;
+declare const createDeployCommand: () => Command;
+export default createDeployCommand;

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

@@ -0,0 +1,105 @@
+"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.handleDeployError = 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 fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const handleDeployError = (status, body) => {
+    let message = '';
+    if (body.title === 'Invalid schema') {
+        message += `${body.title}\n`;
+        message += body['invalid-params']
+            // @ts-ignore.
+            .map(({ name, reason }) => {
+            return `${name} - ${reason}`;
+        })
+            .join('\n');
+    }
+    else {
+        // Catch all error message.
+        message = `Status code: ${status}\n${JSON.stringify(body, null, '    ')}`;
+    }
+    throw new Error(message);
+};
+exports.handleDeployError = handleDeployError;
+const createDeployCommand = () => {
+    const deployCommand = new commander_1.Command('deploy')
+        .name('deploy')
+        .description('Deploy an SCV schema')
+        .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('-p, --path <string>', 'Path to your schema json file e.g. templates/scv.json').makeOptionMandatory())
+        .addOption(new commander_1.Option('-r, --region <string>', 'Region for your schema to be deployed 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)(deployCommand);
+        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((status) => {
+                return status < 400;
+            });
+            const scvDeployBaseUrl = yield (0, utils_1.buildDXPUrl)(constants_1.SCV_DEPLOY_SERVICE_NAME, options.tenant, options.overrideUrl, options.region);
+            const schemaFilePath = path_1.default.resolve(process.cwd(), options.path);
+            if (!(0, fs_1.existsSync)(schemaFilePath)) {
+                throw new Error('Schema file not found.');
+            }
+            // Pre-parse the schema.
+            const schema = JSON.parse((0, fs_1.readFileSync)(schemaFilePath).toString('utf-8'));
+            const apiUrl = `${scvDeployBaseUrl.dxpUrl}/${scvDeployBaseUrl.tenant}`;
+            (0, utils_1.logDebug)(`PUT ${apiUrl}`);
+            const deploySchemaResponse = (yield apiService.client
+                .put(apiUrl, JSON.stringify(schema), {
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            })
+                .catch(err => {
+                (0, utils_1.logDebug)(`RAW ERROR: ${JSON.stringify(err)}`);
+                (0, exports.handleDeployError)(err.response.status, err.response.data);
+            }));
+            (0, utils_1.logDebug)(`Deploy schema response: ${JSON.stringify(deploySchemaResponse.data)}`);
+            if (deploySchemaResponse.status === 409) {
+                throw new Error('Schema is currently deploying. Please try again later.');
+            }
+            yield (0, utils_1.pollForDeployedSchema)(apiUrl, apiService);
+            spinner.succeed('Done!');
+            console.log('');
+            console.log('Your Schema has been deployed.');
+            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') {
+        deployCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire DXP url with a custom value'));
+    }
+    return deployCommand;
+};
+exports.default = createDeployCommand;

package/lib/cdp/schema/deploy/deploy.spec.d.ts

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

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

@@ -0,0 +1,139 @@
+"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 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}`;
+}
+function createMockArgs(region, tenantID, filePath, mockDomain) {
+    return [
+        'node',
+        'dxp-cli',
+        'cdp',
+        'schema',
+        'deploy',
+        '-t',
+        tenantID,
+        '-p',
+        filePath,
+        '-r',
+        region,
+        '-ou',
+        'http://localhost:9999',
+    ];
+}
+describe('cdpSchemaCommand', () => {
+    let mockTenant;
+    let mockRegion;
+    let mockFilePath;
+    let mockDomain;
+    let logSpy;
+    let errorSpy;
+    beforeEach(() => {
+        mockTenant = 'myTenant';
+        mockRegion = 'us';
+        mockFilePath = './src/__tests__/cdp/scv/schema.json';
+        mockDomain = 'http://localhost:9999';
+        process.env.ENABLE_OVERRIDE_CDP_SCHEMA_URL = 'true';
+        logSpy = jest.spyOn(console, 'log');
+        errorSpy = jest.spyOn(console, 'error');
+        if (!nock_1.default.isActive()) {
+            nock_1.default.activate();
+        }
+        // Removes mocks between unit tests so they run in isolation.
+        // Note: this does not currently work.
+        nock_1.default.cleanAll();
+    });
+    afterEach(() => {
+        jest.clearAllMocks(); // Clear all spies
+    });
+    it('correctly handles command arguments', () => __awaiter(void 0, void 0, void 0, function* () {
+        const mockPath = 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, {
+            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, deploy_1.default)();
+        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        const opts = program.opts();
+        expect(opts.tenant).toEqual(mockTenant);
+        expect(opts.overrideUrl).toEqual(mockDomain);
+    }));
+    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);
+        expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
+        (0, nock_1.default)(mockDomain)
+            .get(mockPath)
+            .reply(200, {
+            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYED,
+        })
+            .put(mockPath, schemaFileContent)
+            .reply(400, {
+            title: 'Invalid schema',
+            'invalid-params': [
+                {
+                    name: 'Name 1',
+                    reason: 'Reason 1',
+                },
+                {
+                    name: 'Name 2',
+                    reason: 'Reason 2',
+                },
+            ],
+        });
+        const program = (0, deploy_1.default)();
+        yield program.parseAsync(createMockArgs(mockRegion, mockTenant, mockFilePath, mockDomain));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid schema'));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Name 1 - Reason 1'));
+        expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Name 2 - Reason 2'));
+    }));
+    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);
+        expect(`${mockDomain}${mockPath}`).toEqual('http://localhost:9999/__dxp/us/scv-deploy/myTenant');
+        (0, nock_1.default)(mockDomain)
+            .get(mockPath)
+            .reply(200, {
+            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYED,
+        })
+            .put(mockPath, schemaFileContent)
+            .reply(200, {
+            tenantid: 'myTenant',
+            version: 'unknown',
+            stack: 'stackName',
+            status: deploy_const_1.CDP_DEPLOY_STATUS_DEPLOYING,
+        });
+        const program = (0, deploy_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.');
+        expect(logSpy).toHaveBeenNthCalledWith(4, '');
+        expect(errorSpy).not.toHaveBeenCalled();
+    }));
+});

package/lib/cdp/schema/schemaCommand.d.ts

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

package/lib/cdp/schema/schemaCommand.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 deploy_1 = __importDefault(require("./deploy/deploy"));
+const schemaCommand = () => {
+    const cdpSchemaCommands = new commander_1.Command('schema');
+    cdpSchemaCommands
+        .description('CDP Schema Commands')
+        .addCommand((0, deploy_1.default)());
+    return cdpSchemaCommands;
+};
+exports.default = schemaCommand;

package/lib/cdp/utils.d.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import { ApiService } from '../ApiService';
+export interface tenantDetails {
+    tenantid: string;
+    version: string;
+    stack?: string;
+    status: string;
+    tags?: any;
+}
+export declare function logDebug(message: string): void;
+export declare function throwErrorIfNotLoggedIn(command: Command): Promise<void>;
+export declare function buildDXPUrl(serviceName: string, tenantID?: string, override?: string, region?: string): Promise<{
+    dxpUrl: string;
+    tenant: string | undefined;
+}>;
+export declare function handleCommandError(error: Error): void;
+/**
+ * Poll the schema to be deployed.
+ */
+export declare function pollForDeployedSchema(endpointUrl: string, apiService: ApiService): Promise<unknown>;

package/lib/cdp/utils.js

@@ -0,0 +1,123 @@
+"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.pollForDeployedSchema = 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");
+const axios_1 = __importDefault(require("axios"));
+const API_TIMEOUT = 300000;
+/* istanbul ignore next */
+const sleep = (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+/* istanbul ignore next */
+function logDebug(message) {
+    if (!!process.env.DEBUG) {
+        console.log(message);
+    }
+}
+exports.logDebug = logDebug;
+function throwErrorIfNotLoggedIn(command) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(yield (0, ApplicationStore_1.getApplicationFile)(ApplicationStore_1.STORE_FILES.sessionCookie))) {
+            command.error(chalk_1.default.red('You must login to interact with this command. See `dxp-next auth login`'));
+        }
+    });
+}
+exports.throwErrorIfNotLoggedIn = throwErrorIfNotLoggedIn;
+function buildDXPUrl(serviceName, tenantID, override, region) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!override) {
+            const existingConfig = yield (0, ApplicationConfig_1.fetchApplicationConfig)(tenantID);
+            logDebug(`existingConfig: ${JSON.stringify(existingConfig)}`);
+            return {
+                dxpUrl: `${existingConfig.baseUrl}/__dxp/${region || existingConfig.region}/${serviceName}`,
+                tenant: existingConfig.tenant,
+            };
+        }
+        else {
+            logDebug(`Using override URL: ${override}`);
+            return {
+                dxpUrl: `${override}/__dxp/${region || 'au'}/${serviceName}`,
+                tenant: tenantID,
+            };
+        }
+    });
+}
+exports.buildDXPUrl = buildDXPUrl;
+function handleCommandError(error) {
+    var _a, _b, _c, _d;
+    if (axios_1.default.isAxiosError(error)) {
+        let message = `${error.message}`;
+        if ((_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.message) {
+            message += `: ${error.response.data.message}`;
+        }
+        if ((_d = (_c = error.response) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.details) {
+            message += ` - ${error.response.data.details}`;
+        }
+        console.error(chalk_1.default.red(message));
+    }
+    else {
+        if (!!process.env.DEBUG && error.stack) {
+            console.error(error.stack);
+        }
+        if (error.message) {
+            console.error(chalk_1.default.red(error.message));
+        }
+        else {
+            console.error(chalk_1.default.red('An unknown error occurred'));
+        }
+    }
+}
+exports.handleCommandError = handleCommandError;
+/**
+ * Poll the schema to be deployed.
+ */
+function pollForDeployedSchema(endpointUrl, apiService) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const errHandler = (err) => {
+                reject(err);
+            };
+            const checkSessionTimeout = setTimeout(() => {
+                reject('Timed out waiting for api, please try again.');
+            }, API_TIMEOUT);
+            const poll = () => __awaiter(this, void 0, void 0, function* () {
+                logDebug(`GET ${endpointUrl}`);
+                const { data, status } = yield apiService.client.get(endpointUrl);
+                logDebug(`Response: ${JSON.stringify(data)}`);
+                if (status !== 200) {
+                    return reject(`Unexpected poll request status: ${status}`);
+                }
+                if (data.status === 'deploying') {
+                    setTimeout(() => {
+                        poll().catch(errHandler);
+                    }, 2000);
+                    return;
+                }
+                else if (data.status === 'deployed') {
+                    clearTimeout(checkSessionTimeout);
+                    resolve(true);
+                }
+                else {
+                    clearTimeout(checkSessionTimeout);
+                    reject(`Unexpected deployment status code: "${data.status}"`);
+                }
+            });
+            poll().catch(errHandler);
+        });
+    });
+}
+exports.pollForDeployedSchema = pollForDeployedSchema;

package/lib/dxp.js

@@ -15,6 +15,7 @@ const auth_1 = __importDefault(require("./auth"));
 const cmp_1 = __importDefault(require("./cmp"));
 const job_runner_1 = __importDefault(require("./job-runner"));
 const datastore_1 = __importDefault(require("./datastore"));
+const cdp_1 = __importDefault(require("./cdp"));
 const program = new commander_1.default.Command();
 const packageJson = require('../package.json');
 const version = packageJson.version;
@@ -26,6 +27,7 @@ program
     .addCommand(cmp_1.default)
     .addCommand(job_runner_1.default)
     .addCommand(datastore_1.default)
+    .addCommand(cdp_1.default)
     .action(() => {
     program.help();
 })

package/package.json

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