@squiz/dxp-cli-next 5.9.0-develop.43 → 5.9.0-develop.44

package/lib/datastore/bundle/bundle.d.ts

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

package/lib/datastore/bundle/bundle.js

@@ -0,0 +1,174 @@
+"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 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 fs_1 = require("fs");
+const path_1 = require("path");
+const YAML = __importStar(require("yaml"));
+const createBundleCommand = () => {
+    const datastoreBundleCommand = new commander_1.Command('bundle')
+        .name('bundle')
+        .description('Datastore Bundle Commands')
+        .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('-blueprint, --blueprint <string>', 'Path to your blueprint API yaml file e.g. documents/inputs/blueprint.yaml').makeOptionMandatory())
+        .addOption(new commander_1.Option('-name, --name <string>', 'Name for your blueprint e.g. MyFirstBlueprint'))
+        .addOption(new commander_1.Option('-output, --output <string>', 'Output for your output file path').makeOptionMandatory())
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        if (options.name) {
+            yield (0, utils_1.throwErrorIfNotLoggedIn)(datastoreBundleCommand);
+        }
+        console.log('');
+        const path = options.blueprint;
+        const blueprintPath = (0, path_1.resolve)(path);
+        const outputPath = (0, path_1.resolve)(options.output);
+        const outputDirectory = (0, path_1.dirname)(outputPath);
+        let blueprintFile;
+        const spinner = (0, ora_1.default)('Please wait while we bundle your blueprint.').start();
+        let input;
+        try {
+            if ((0, fs_1.existsSync)(blueprintPath) === false) {
+                throw new Error('No blueprint exists at that path, please specify a correct path.');
+            }
+            if ((0, fs_1.existsSync)(outputDirectory) === false) {
+                throw new Error("Output directory doesn't exist.");
+            }
+            let outputExt = (0, path_1.extname)(outputPath);
+            if (outputExt.indexOf('.') === 0) {
+                outputExt = outputExt.replace('.', '');
+            }
+            const allowedExtensions = ['yaml', 'yml'];
+            if (allowedExtensions.includes(outputExt) === false) {
+                const errorMsg = 'Please specify a valid output file. Valid extensions are: ' +
+                    allowedExtensions.join(', ');
+                throw new Error(errorMsg);
+            }
+            const apiService = new ApiService_1.ApiService(utils_1.validateAxiosStatus);
+            let datastoreInstance;
+            if (options.name) {
+                (0, utils_1.logDebug)('Checking current blueprints');
+                // Check if we are at the blueprint limit.
+                const datastoreInstancesResp = yield apiService.client.get(yield (0, utils_1.buildDatastoreInstancesUrl)(options.tenant, options.overrideUrl));
+                (0, utils_1.logDebug)(`Finding blueprint with name: ${options.name}`);
+                const datastoreInstances = datastoreInstancesResp.data.filter((instance) => {
+                    return instance.name === options.name;
+                });
+                if (datastoreInstances.length > 1) {
+                    throw new Error('Unexpected error. Ask for help in our support forums.');
+                }
+                datastoreInstance = datastoreInstances[0];
+            }
+            // Bundle the blueprint.
+            input = yield (0, utils_1.bundleBlueprint)(path, true);
+            const blueprintFile = input;
+            const blueprint = YAML.parse(blueprintFile, { maxAliasCount: -1 });
+            if (options.name &&
+                datastoreInstance &&
+                datastoreInstance.deploymentUrl) {
+                //  Add the servers tag to the blueprint if not already there.
+                if (blueprint.servers) {
+                    const currentDatastoreServer = blueprint.servers.filter((server) => server.description === 'Datastore production');
+                    if (currentDatastoreServer.length === 0) {
+                        blueprint.servers.push({
+                            description: 'Datastore production',
+                            url: datastoreInstance.deploymentUrl,
+                        });
+                    }
+                }
+                else {
+                    blueprint.servers = [
+                        {
+                            description: 'Datastore production',
+                            url: datastoreInstance.deploymentUrl,
+                        },
+                    ];
+                }
+            }
+            if (!blueprint.components) {
+                blueprint.components = {};
+            }
+            if (!blueprint.components.securitySchemes) {
+                blueprint.components.securitySchemes = {};
+            }
+            if (!blueprint.components.securitySchemes.bearerAuth) {
+                blueprint.components.securitySchemes.bearerAuth = {
+                    bearerFormat: 'JWT',
+                    scheme: 'bearer',
+                    type: 'http',
+                };
+            }
+            // Check that the paths that need a JWT have the bearerAuth added.
+            for (const i in blueprint.paths) {
+                for (const j in blueprint.paths[i]) {
+                    if (blueprint.paths[i][j]['x-datastore-acl'] &&
+                        blueprint.paths[i][j]['x-datastore-acl'].toLowerCase() !==
+                            'public') {
+                        if (!blueprint.paths[i][j].security) {
+                            blueprint.paths[i][j].security = [{ bearerAuth: [] }];
+                        }
+                    }
+                }
+            }
+            const updatedBlueprint = YAML.stringify(blueprint);
+            (0, fs_1.writeFile)(`${outputPath}`, updatedBlueprint, err => {
+                if (err) {
+                    throw new Error(`Error: ${err.message}`);
+                }
+            });
+            spinner.succeed(`Blueprint bundled at: ${outputPath}`);
+            return;
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${JSON.stringify(error)}`);
+            spinner.fail();
+            (0, utils_1.handleCommandError)(datastoreBundleCommand, error);
+        }
+    }));
+    if (process.env.ENABLE_OVERRIDE_DATASTORE_URL === 'true') {
+        datastoreBundleCommand.addOption(new commander_1.Option('-ou, --overrideUrl <string>', 'Developer option to override the entire DXP url with a custom value'));
+    }
+    return datastoreBundleCommand;
+};
+exports.default = createBundleCommand;

package/lib/datastore/bundle/bundle.spec.d.ts

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

package/lib/datastore/bundle/bundle.spec.js

@@ -0,0 +1,93 @@
+"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 bundle_1 = __importDefault(require("./bundle"));
+const utils_1 = require("../utils");
+const logSpy = jest.spyOn(global.console, 'log');
+describe('bundleJobContexts', () => {
+    process.env.ENABLE_OVERRIDE_DATASTORE_URL = 'true';
+    it('correctly bundles a blueprint', () => __awaiter(void 0, void 0, void 0, function* () {
+        (0, nock_1.default)('http://localhost:9999')
+            .get('/__dxp/au/dxp/tenants/myTenant/instances?type=datastore')
+            .reply(200, [
+            {
+                status: {
+                    code: utils_1.CONSOLE_STATUS_CODE_LIVE,
+                },
+                deploymentUrl: 'https://au-asdfghj.datastore.squiz.cloud',
+                secretKey: 'secretKey',
+                region: 'au',
+                name: 'secondBlueprint',
+                instanceId: '1234',
+            },
+            {
+                status: {
+                    code: utils_1.CONSOLE_STATUS_CODE_LIVE,
+                },
+                deploymentUrl: 'https://au-12345678.datastore.squiz.cloud',
+                secretKey: 'secretKey',
+                region: 'au',
+                name: 'myBlueprint',
+                instanceId: 'mock-instance-id',
+            },
+        ]);
+        (0, nock_1.default)('http://localhost:9999')
+            .patch('/__dxp/au/dxp/tenants/myTenant/instances/mock-instance-id', {
+            name: 'myRenamedBlueprint',
+        })
+            .reply(200, {
+            instanceId: 'mock-instance-id',
+        });
+        (0, nock_1.default)('http://localhost:9999')
+            .post('/__dxp/au/dxp/tenants/myTenant/instances/mock-instance-id/_deploy')
+            .reply(200, {
+            instanceId: 'mock-instance-id',
+        });
+        (0, nock_1.default)('http://localhost:9999')
+            .get('/__dxp/au/dxp/tenants/myTenant/instances/mock-instance-id')
+            .reply(200, {
+            status: {
+                code: utils_1.CONSOLE_STATUS_CODE_LIVE,
+            },
+            deploymentUrl: 'https://au-12345678.datastore.squiz.cloud',
+            secretKey: 'secretKey',
+            region: 'au',
+        });
+        const program = (0, bundle_1.default)();
+        yield program.parseAsync([
+            'node',
+            'dxp-cli',
+            'datastore',
+            'bundle',
+            '-t',
+            'myTenant',
+            '-blueprint',
+            './src/__tests__/datastore/blueprints/blueprint.yaml',
+            '-name',
+            'myRenamedBlueprint',
+            '-output',
+            './src/__tests__/datastore/blueprints.yaml',
+            '-ou',
+            'http://localhost:9999',
+        ]);
+        const opts = program.opts();
+        expect(opts.tenant).toEqual('myTenant');
+        expect(opts.overrideUrl).toEqual('http://localhost:9999');
+        expect(logSpy).toHaveBeenCalledTimes(1);
+        expect(logSpy).toHaveBeenCalledWith('');
+        expect(logSpy).toHaveBeenCalledWith('');
+        expect(logSpy).toHaveBeenCalledWith('');
+    }));
+});

package/lib/datastore/index.js

@@ -5,8 +5,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const blueprintCommand_1 = __importDefault(require("./blueprint/blueprintCommand"));
+const bundle_1 = __importDefault(require("./bundle/bundle"));
 const datastoreCommand = new commander_1.Command('datastore');
 datastoreCommand
     .description('Datastore Commands')
-    .addCommand((0, blueprintCommand_1.default)());
+    .addCommand((0, blueprintCommand_1.default)())
+    .addCommand((0, bundle_1.default)());
 exports.default = datastoreCommand;

package/package.json

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