@squiz/dxp-cli-next 5.9.0 → 5.10.0-develop.2

package/lib/datastore/blueprint/update/update.spec.js

@@ -0,0 +1,99 @@
+"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 update_1 = __importDefault(require("./update"));
+const utils_1 = require("../../utils");
+const logSpy = jest.spyOn(global.console, 'log');
+describe('datastoreBlueprintUpdate', () => {
+    process.env.ENABLE_OVERRIDE_DATASTORE_URL = 'true';
+    it('correctly adds 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', {
+            blueprintFile: /.+/i,
+            status: {
+                code: 'Deploying',
+                message: 'Instance is deploying',
+            },
+        })
+            .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, update_1.default)();
+        yield program.parseAsync([
+            'node',
+            'dxp-cli',
+            'datastore',
+            'blueprint',
+            'update',
+            '-t',
+            'myTenant',
+            '-p',
+            './src/__tests__/datastore/blueprints/blueprint.yaml',
+            '-n',
+            'myBlueprint',
+            '-ou',
+            'http://localhost:9999',
+        ]);
+        const opts = program.opts();
+        expect(opts.tenant).toEqual('myTenant');
+        expect(opts.overrideUrl).toEqual('http://localhost:9999');
+        expect(logSpy).toHaveBeenCalledTimes(6);
+        expect(logSpy).toHaveBeenCalledWith('');
+        expect(logSpy).toHaveBeenCalledWith('');
+        expect(logSpy).toHaveBeenCalledWith('    URL: https://au-12345678.datastore.squiz.cloud');
+        expect(logSpy).toHaveBeenCalledWith('    Secret Key: secretKey');
+        expect(logSpy).toHaveBeenCalledWith('    Region: au');
+        expect(logSpy).toHaveBeenCalledWith('');
+    }));
+});

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.d.ts

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

package/lib/datastore/index.js

@@ -0,0 +1,16 @@
+"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 blueprintCommand_1 = __importDefault(require("./blueprint/blueprintCommand"));
+const bundle_1 = __importDefault(require("./bundle/bundle"));
+const simulatorCommand_1 = __importDefault(require("./simulator/simulatorCommand"));
+const datastoreCommand = new commander_1.Command('datastore');
+datastoreCommand
+    .description('Datastore Commands')
+    .addCommand((0, blueprintCommand_1.default)())
+    .addCommand((0, bundle_1.default)())
+    .addCommand((0, simulatorCommand_1.default)());
+exports.default = datastoreCommand;

package/lib/datastore/simulator/add/add.d.ts

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

package/lib/datastore/simulator/add/add.js

@@ -0,0 +1,138 @@
+"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 utils_1 = require("../../utils");
+const utils_2 = require("../utils");
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const createAddCommand = () => {
+    const addCommand = new commander_1.Command('add')
+        .name('add')
+        .description('Adds a new simulator')
+        .addOption(new commander_1.Option('-p, --port <string>', 'Port for the Datastore simulator to run on'))
+        .addOption(new commander_1.Option('-b, --blueprint <string>', 'Path to your datastore API yaml file.').makeOptionMandatory())
+        .configureOutput({
+        outputError(str, write) {
+            write(chalk_1.default.red(str));
+        },
+    })
+        .action((options) => __awaiter(void 0, void 0, void 0, function* () {
+        console.log('');
+        const spinner = (0, ora_1.default)();
+        try {
+            yield (0, utils_2.checkUpdateAvailable)();
+            spinner.start('Creating a new simulator container.');
+            yield (0, utils_2.checkDockerInstalled)();
+            const { fullPath, dirPath, yamlFile, containerName } = (0, utils_2.getSimulatorDetails)(options.blueprint);
+            const fileCheck = fs_1.default.existsSync(fullPath);
+            let errorMsg = 'There was an error starting simulator. Ask for help in our support forums.';
+            if (fileCheck === false) {
+                throw new Error('Sorry, we could not create your simulator container. Please try again using a valid path to a blueprint.');
+            }
+            else {
+                let fileExt = (0, path_1.extname)(fullPath);
+                if (fileExt.indexOf('.') === 0) {
+                    fileExt = fileExt.replace('.', '');
+                }
+                if (utils_2.allowedExtensions.includes(fileExt) === false) {
+                    errorMsg = 'Sorry, we could not create your simulator container.';
+                    errorMsg += ` Please try again using a valid path to a blueprint. Valid extensions are: ${utils_2.allowedExtensions.join(', ')}`;
+                    throw new Error(errorMsg);
+                }
+            }
+            const versionDetails = {
+                digest: '',
+                version: '',
+            };
+            // Find an available port.
+            const usedPorts = yield (0, utils_2.executeCommand)('docker ps -a --format "~{{.Labels}}~" --filter "name=datastore-sim-*"');
+            let selectedPort = '';
+            if (options.port) {
+                selectedPort = options.port;
+            }
+            else {
+                utils_2.availablePorts.forEach(port => {
+                    if (
+                    // Port is stored in label, avoid using same port.
+                    usedPorts.match(`port=${port}`) === null &&
+                        selectedPort === '') {
+                        selectedPort = port;
+                    }
+                });
+            }
+            if (selectedPort === '') {
+                throw new Error('Failed to find an available Docker port. Try again with --port parameter.');
+            }
+            try {
+                spinner.text = 'Starting the new container.';
+                const startCommand = yield (0, utils_2.executeCommand)(`docker run -l "blueprint=${fullPath.replace(/(\s+)/g, '\\$1')}" -l "port=${selectedPort}" -itd --name ${containerName}\
+          -p ${utils_2.host}:${selectedPort}:80 \
+          -e MYHOST=${utils_2.host} -e MYPORT=${selectedPort} -e BLUEPRINT=${fullPath.replace(/(\s+)/g, '\\$1')} \
+          -v "${dirPath}":/var/www/instances \
+          ${utils_2.datastoreRepo}`);
+            }
+            catch (error) {
+                if (error.message.includes('already in use') === true) {
+                    throw new Error('There is already a container running with this blueprint.');
+                }
+                else {
+                    throw new Error('Failed to start Docker container. Ask for help in our support forums.');
+                }
+            }
+            spinner.text = 'Installing and simulating new blueprint.';
+            const installCommand = yield (0, utils_2.executeCommand)(`docker exec -i ${containerName} install simulator:${yamlFile} --output=json`);
+            const obj = JSON.parse(installCommand);
+            const url = obj[0].URL;
+            const jwtUrl = obj[0].jwtURL;
+            const versionDetailsCommand = yield (0, utils_2.executeCommand)(`docker image inspect ${utils_2.datastoreRepo} --format "{{ index .RepoDigests }}"`);
+            versionDetails.digest = versionDetailsCommand.replace(/\r?\n|\r/g, '');
+            versionDetails.digest = versionDetails.digest.slice(20, -1);
+            let simulatorVersionCmd = `docker image inspect ${utils_2.datastoreRepo}`;
+            simulatorVersionCmd +=
+                ' --format \'{{ or (index .Config.Labels "squiz.datastore.version") (printf "Unknown") }}\'';
+            const imageVersion = yield (0, utils_2.executeCommand)(simulatorVersionCmd);
+            versionDetails.version = imageVersion.replace(/\r?\n|\r/g, '');
+            // Store those info in a file on container, easier to fetch.
+            const data = {
+                blueprint: `${fullPath}`,
+                container: `${containerName}`,
+                imageDigest: `${versionDetails.digest}`,
+                imageVersion: `${versionDetails.version}`,
+                jwt: `${jwtUrl}`,
+                url: `${url}`,
+            };
+            const jsonData = JSON.stringify(data, null, 4).replace(/"/g, '\\"');
+            yield (0, utils_2.executeCommand)(`docker exec -i ${containerName} bash -c "echo '${jsonData}' > /var/www/data/containerData.json"`);
+            spinner.succeed('Done! Use these details for local querying:');
+            console.log('');
+            console.log(`    URL: ${url}`);
+            console.log(`    JWT URL: ${jwtUrl}`);
+            console.log('');
+            return;
+        }
+        catch (error) {
+            (0, utils_1.logDebug)(`ERROR: ${JSON.stringify(error)}`);
+            spinner.fail();
+            (0, utils_1.handleCommandError)(addCommand, error);
+        }
+    }));
+    if (process.env.ENABLE_OVERRIDE_DATASTORE_URL === 'true') {
+        addCommand.addOption(new commander_1.Option('-i, --image <string>', 'Override the docker image'));
+    }
+    return addCommand;
+};
+exports.default = createAddCommand;

package/lib/datastore/simulator/add/add.spec.d.ts

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