@mablhq/playwright-tools 2.49.1

package/commands/datatables/datatables_cmds/list.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const list_1 = require("../../commandUtil/list");
+exports.command = 'list';
+exports.describe = 'List your DataTables';
+exports.builder = (0, list_1.getListBuilderOptions)('datatables');
+exports.handler = (0, util_1.failWrapper)(listDataTables);
+async function listDataTables(parsed) {
+    var _a;
+    const output = parsed.output;
+    const limit = parsed.limit;
+    const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const queryResult = await apiClient.queryDataTables(workspaceId, limit);
+    (0, list_1.outputEntities)((_a = queryResult.dataTables) !== null && _a !== void 0 ? _a : [], output);
+}

package/commands/datatables/datatables_cmds/scenarios.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const interfaces_1 = require("../../commandUtil/interfaces");
+const list_1 = require("../../commandUtil/list");
+const constants_1 = require("../../constants");
+exports.command = `scenarios <${constants_1.CommandArgId}>`;
+exports.describe = 'List the scenarios of a datatable';
+exports.builder = (yargs) => {
+    yargs
+        .option(constants_1.CommandArgLimitOutput, {
+        alias: constants_1.CommandArgAliases.LimitOutput,
+        describe: `The number of scenarios to return'`,
+        default: interfaces_1.DEFAULT_LISTING_RESULT_LIMIT,
+        nargs: 1,
+        type: 'string',
+    })
+        .option(constants_1.CommandArgOutput, {
+        alias: constants_1.CommandArgAliases.OutputType,
+        choices: constants_1.DefaultOutputFormatChoices,
+        describe: 'Specify result output format',
+        nargs: 1,
+    });
+};
+exports.handler = (0, util_1.failWrapper)(dataTableScenarios);
+async function dataTableScenarios(parsed) {
+    var _a;
+    const output = parsed.output;
+    const dataTableId = parsed.id;
+    const limit = parsed.limit;
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const queryResult = await apiClient.queryScenarios(dataTableId, limit);
+    (0, list_1.outputEntities)((_a = queryResult.scenarios) !== null && _a !== void 0 ? _a : [], output);
+}

package/commands/datatables/datatables_cmds/update.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpdateRequest = void 0;
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const constants_1 = require("../../constants");
+const pureUtil_1 = require("../../../util/pureUtil");
+const utils_1 = require("../utils");
+const domUtil_1 = require("../../../domUtil");
+exports.command = `update <${constants_1.CommandArgId}> <${constants_1.CommandArgInput}>`;
+exports.describe = 'Update a mabl DataTable';
+exports.builder = (yargs) => {
+    yargs
+        .positional(constants_1.CommandArgId, {
+        describe: 'ID of DataTable to update',
+        type: 'string',
+    })
+        .positional(constants_1.CommandArgInput, {
+        alias: 'file',
+        describe: 'Relative path file to create DataTable from',
+    })
+        .option(constants_1.CommandArgWorkspaceId, {
+        alias: constants_1.CommandArgAliases.WorkspaceId,
+        describe: `Workspace your DataTable is exists in`,
+        type: 'string',
+    })
+        .option(constants_1.CommandArgFormat, {
+        alias: 'fmt',
+        demandOption: false,
+        describe: `Specify the format of your input file (checks file extension type by default)`,
+        choices: [constants_1.OutputFormats.Json, constants_1.OutputFormats.Csv],
+    });
+};
+exports.handler = (0, util_1.failWrapper)(updateDataTable);
+async function updateDataTable(parsed) {
+    var _a;
+    const { id: dataTableId, input } = parsed;
+    const format = (_a = parsed.format) !== null && _a !== void 0 ? _a : (0, utils_1.inferFileFormat)(input);
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const dataTable = await apiClient.getDataTable(dataTableId);
+    let scenarios;
+    switch (format) {
+        case constants_1.OutputFormats.Json:
+            scenarios = (0, utils_1.parseJsonScenarios)(input);
+            break;
+        case constants_1.OutputFormats.Csv:
+            scenarios = await (0, utils_1.parseCsvScenarios)(input);
+            break;
+        default:
+            throw Error(`${format} is not a valid option.`);
+    }
+    const request = buildUpdateRequest(scenarios, dataTable);
+    await apiClient.updateDataTable(dataTableId, request);
+}
+function buildUpdateRequest(scenarios, dataTable) {
+    var _a, _b, _c;
+    if (scenarios.length === 0 || !scenarios) {
+        throw Error('Must have at least 1 scenario in DataTable.');
+    }
+    const validationVariables = scenarios[0].variables;
+    scenarios.forEach((scenario) => {
+        var _a, _b, _c;
+        if (scenario.id && !((_a = dataTable.scenario_ids) === null || _a === void 0 ? void 0 : _a.includes(scenario.id))) {
+            throw Error(`Scenario in input with ID ${scenario.id} does not exist in DataTable scenario_ids.`);
+        }
+        if (((_b = scenario.variables) === null || _b === void 0 ? void 0 : _b.length) === 0 || !scenario.variables) {
+            throw Error('Must have at least 1 variable in a scenario.');
+        }
+        if (scenario.variables.length !== (validationVariables === null || validationVariables === void 0 ? void 0 : validationVariables.length)) {
+            throw Error('All scenarios must have the same number of variables.');
+        }
+        (_c = scenario.variables) === null || _c === void 0 ? void 0 : _c.forEach((variable, index) => {
+            if (!(0, domUtil_1.isValidUserVariableName)(variable.name)) {
+                throw Error(`Invalid variable name: ${variable.name}. Variable names must start with a letter or underscore (_) followed by letters, numbers, and underscores and cannot be "user", "web", or "mail"`);
+            }
+            if (variable.name !== validationVariables[index].name) {
+                throw Error('All scenarios must have the same variable names and be in the same order.');
+            }
+        });
+    });
+    const parsedScenarioMap = scenarios
+        .filter((scenario) => scenario.id !== undefined)
+        .reduce((acc, scenario) => {
+        acc[scenario.id] = scenario;
+        return acc;
+    }, {});
+    const updatedRows = ((_a = dataTable.scenario_ids) === null || _a === void 0 ? void 0 : _a.filter((id) => parsedScenarioMap[id] !== undefined).map((id) => {
+        const variableRow = (0, utils_1.scenarioAsVariableRow)(parsedScenarioMap[id]);
+        return {
+            id: variableRow.id || '',
+            scenario_id: variableRow.scenario_id || '',
+            row: variableRow.row || [],
+        };
+    }).filter(pureUtil_1.isDefined)) || [];
+    const updatedRowIds = updatedRows
+        .map((row) => row.id)
+        .filter(pureUtil_1.isDefined);
+    const addedRows = scenarios
+        .filter((row) => row.id === undefined)
+        .map((scenario) => {
+        const variableRow = (0, utils_1.scenarioAsVariableRow)(scenario);
+        return {
+            id: variableRow.id,
+            scenario_id: variableRow.scenario_id,
+            row: variableRow.row,
+        };
+    });
+    const deletedRowIds = (_c = (_b = dataTable.scenario_ids) === null || _b === void 0 ? void 0 : _b.filter((id) => !updatedRowIds.includes(id))) !== null && _c !== void 0 ? _c : [];
+    const prototype = {
+        ...(0, utils_1.dataTableAsVariableTable)(dataTable),
+        row_ids: updatedRows.map((row) => row.id).filter(pureUtil_1.isDefined),
+    };
+    return {
+        prototype,
+        updatedRows,
+        deletedRowIds,
+        addedRows,
+    };
+}
+exports.buildUpdateRequest = buildUpdateRequest;

package/commands/datatables/utils.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variableRowAsScenario = exports.scenarioAsVariableRow = exports.dataTableAsVariableTable = exports.isScenarioArray = exports.inferFileFormat = exports.jsonToScenarios = exports.parseJsonScenarios = exports.csvScenarioFormatToScenarios = exports.parseCsvScenarios = exports.desanitizeCsvCellOutput = exports.sanitizeCsvCellInput = void 0;
+const constants_1 = require("../constants");
+const path_1 = require("path");
+const fs_1 = __importDefault(require("fs"));
+const csv_parser_1 = __importDefault(require("csv-parser"));
+const MALICIOUS_LINE_PREFIX_MATCHER = /^([+\-@=])/;
+const SANITIZED_LINE_PREFIX_MATCHER = /^(`[+\-@=])/;
+function sanitizeCsvCellInput(input) {
+    if (!input) {
+        return '';
+    }
+    return MALICIOUS_LINE_PREFIX_MATCHER.test(input)
+        ? `\`${input}`.trim()
+        : input.trim();
+}
+exports.sanitizeCsvCellInput = sanitizeCsvCellInput;
+function desanitizeCsvCellOutput(input) {
+    if (!input) {
+        return '';
+    }
+    return SANITIZED_LINE_PREFIX_MATCHER.test(input)
+        ? input.slice(1).trim()
+        : input.trim();
+}
+exports.desanitizeCsvCellOutput = desanitizeCsvCellOutput;
+var AllowedInputExtensions;
+(function (AllowedInputExtensions) {
+    AllowedInputExtensions["Csv"] = ".csv";
+    AllowedInputExtensions["Json"] = ".json";
+})(AllowedInputExtensions || (AllowedInputExtensions = {}));
+async function parseCsvScenarios(fileName) {
+    const readCsv = await fileToCsvScenarioFormat(fileName);
+    return csvScenarioFormatToScenarios(readCsv);
+}
+exports.parseCsvScenarios = parseCsvScenarios;
+async function fileToCsvScenarioFormat(fileName) {
+    const csvInput = [];
+    await new Promise((resolve) => {
+        fs_1.default.createReadStream(fileName)
+            .pipe((0, csv_parser_1.default)())
+            .on('data', (data) => csvInput.push(data))
+            .on('end', () => resolve());
+    });
+    return csvInput;
+}
+function csvScenarioFormatToScenarios(input) {
+    if (input.length === 0) {
+        return [];
+    }
+    return input.map((rowItem) => ({
+        id: rowItem[constants_1.SCENARIO_ID_HEADER] || undefined,
+        name: desanitizeCsvCellOutput(rowItem[constants_1.SCENARIO_NAME_HEADER]),
+        variables: Object.entries(rowItem)
+            .filter(([key, _]) => key !== constants_1.SCENARIO_NAME_HEADER && key !== constants_1.SCENARIO_ID_HEADER)
+            .map(([key, value]) => ({
+            name: desanitizeCsvCellOutput(key),
+            value: desanitizeCsvCellOutput(value),
+        })),
+    }));
+}
+exports.csvScenarioFormatToScenarios = csvScenarioFormatToScenarios;
+function parseJsonScenarios(fileName) {
+    const readJson = fs_1.default.readFileSync(fileName, 'utf-8');
+    return jsonToScenarios(readJson);
+}
+exports.parseJsonScenarios = parseJsonScenarios;
+function jsonToScenarios(input) {
+    const parsedJson = JSON.parse(input);
+    if (isScenarioArray(parsedJson)) {
+        return parsedJson;
+    }
+    throw Error('Json input was not formatted correctly');
+}
+exports.jsonToScenarios = jsonToScenarios;
+function inferFileFormat(fileName) {
+    const extension = (0, path_1.extname)(fileName);
+    switch (extension) {
+        case AllowedInputExtensions.Csv:
+            return constants_1.OutputFormats.Csv;
+        case AllowedInputExtensions.Json:
+            return constants_1.OutputFormats.Json;
+        default:
+            throw new Error('The file format could be inferred from the extension, please specify a format for your input data.');
+    }
+}
+exports.inferFileFormat = inferFileFormat;
+function isScenario(arg) {
+    return ((typeof arg.id === 'string' || arg.id === undefined) &&
+        typeof arg.name === 'string' &&
+        Array.isArray(arg.variables) &&
+        arg.variables.every((col) => typeof col.name === 'string' && typeof col.value === 'string'));
+}
+function isScenarioArray(arg) {
+    return Array.isArray(arg) && arg.every((scenario) => isScenario(scenario));
+}
+exports.isScenarioArray = isScenarioArray;
+function dataTableAsVariableTable(dataTable) {
+    return {
+        id: dataTable.id,
+        organization_id: dataTable.workspace_id,
+        name: dataTable.name,
+        created_time: dataTable.created_time,
+        created_by_id: dataTable.created_by_id,
+        last_updated_time: dataTable.last_updated_time,
+        last_updated_by_id: dataTable.last_updated_by_id,
+        row_ids: dataTable.scenario_ids,
+    };
+}
+exports.dataTableAsVariableTable = dataTableAsVariableTable;
+function scenarioAsVariableRow(scenario) {
+    return {
+        id: scenario === null || scenario === void 0 ? void 0 : scenario.id,
+        table_id: scenario === null || scenario === void 0 ? void 0 : scenario.table_id,
+        created_time: scenario === null || scenario === void 0 ? void 0 : scenario.created_time,
+        created_by_id: scenario === null || scenario === void 0 ? void 0 : scenario.created_by_id,
+        last_updated_time: scenario === null || scenario === void 0 ? void 0 : scenario.last_updated_time,
+        last_updated_by_id: scenario === null || scenario === void 0 ? void 0 : scenario.last_updated_by_id,
+        organization_id: scenario === null || scenario === void 0 ? void 0 : scenario.workspace_id,
+        scenario_id: scenario === null || scenario === void 0 ? void 0 : scenario.name,
+        row: scenario === null || scenario === void 0 ? void 0 : scenario.variables,
+    };
+}
+exports.scenarioAsVariableRow = scenarioAsVariableRow;
+function variableRowAsScenario(variableRow) {
+    if (isScenario(variableRow)) {
+        return variableRow;
+    }
+    return {
+        id: variableRow.id,
+        table_id: variableRow.table_id,
+        created_time: variableRow.created_time,
+        created_by_id: variableRow.created_by_id,
+        last_updated_time: variableRow.last_updated_time,
+        last_updated_by_id: variableRow.last_updated_by_id,
+        workspace_id: variableRow.organization_id,
+        name: variableRow.scenario_id,
+        variables: variableRow.row,
+    };
+}
+exports.variableRowAsScenario = variableRowAsScenario;

package/commands/deploy/deploy.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.command = 'deployments <command>';
+exports.describe = 'Manage mabl deployments';
+exports.builder = (yargs) => yargs.commandDir('deploy_cmds').demandCommand();

package/commands/deploy/deploy_cmds/awaitDeploymentCompletion.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitDeploymentCompletion = void 0;
+const awaitCompletion_1 = require("../../commandUtil/awaitCompletion");
+const executionResultPresenter_1 = require("./executionResultPresenter");
+const loggingProvider_1 = require("../../../providers/logging/loggingProvider");
+const timeUtil_1 = require("../../../util/timeUtil");
+const chalk = require('chalk');
+class AwaitDeploymentCompletion extends awaitCompletion_1.AwaitCompletion {
+    constructor(apiClient, exitOnFirstFailure, isSilent) {
+        super(apiClient, AwaitDeploymentCompletion.pollingTimeoutMilliseconds, AwaitDeploymentCompletion.pollingIntervalMilliseconds);
+        this.apiClient = apiClient;
+        this.resultsPresenter = new executionResultPresenter_1.ExecutionResultPresenter();
+        this.exitOnFirstFailure = !!exitOnFirstFailure;
+        this.isSilent = !!isSilent;
+    }
+    async pollingFunction(mablApi, lastEntity, seedId) {
+        var _a, _b;
+        if (!seedId) {
+            throw new Error('event id must be passed');
+        }
+        const latestResults = await mablApi.getDeploymentResults(seedId);
+        if (this.exitOnFirstFailure) {
+            if ((_b = (_a = latestResults.plan_execution_metrics) === null || _a === void 0 ? void 0 : _a.failed) !== null && _b !== void 0 ? _b : 0 > 0) {
+                this.exitOnFirstFailurePresenter(latestResults);
+                return {
+                    newEntity: latestResults,
+                    status: awaitCompletion_1.PollingOutcomeType.Complete,
+                };
+            }
+        }
+        const hasOutcomePayload = (latestResults === null || latestResults === void 0 ? void 0 : latestResults.event_status) &&
+            Object.keys(latestResults === null || latestResults === void 0 ? void 0 : latestResults.event_status).length > 0;
+        const status = hasOutcomePayload
+            ? awaitCompletion_1.PollingOutcomeType.Complete
+            : awaitCompletion_1.PollingOutcomeType.Running;
+        return {
+            newEntity: latestResults,
+            status,
+        };
+    }
+    statusPresenter(lastEntity) {
+        var _a, _b, _c, _d, _e, _f;
+        if (this.isSilent) {
+            return;
+        }
+        const elapsedTimeString = (0, timeUtil_1.elapsedTimeDurationToString)(this.getElapsedMilliseconds());
+        const passed = (_b = (_a = lastEntity.plan_execution_metrics) === null || _a === void 0 ? void 0 : _a.passed) !== null && _b !== void 0 ? _b : 0;
+        const failed = (_d = (_c = lastEntity.plan_execution_metrics) === null || _c === void 0 ? void 0 : _c.failed) !== null && _d !== void 0 ? _d : 0;
+        const total = (_f = (_e = lastEntity.plan_execution_metrics) === null || _e === void 0 ? void 0 : _e.total) !== null && _f !== void 0 ? _f : 0;
+        const passedColor = passed === 0 ? 'gray' : 'green';
+        const failedColor = failed === 0 ? 'gray' : 'red';
+        let totalColor = 'gray';
+        if (failed > 0) {
+            totalColor = 'red';
+        }
+        else if (passed > 0) {
+            totalColor = 'green';
+        }
+        loggingProvider_1.logger.info(`Plan Runs [passed: ${chalk
+            .keyword(passedColor)
+            .visible(passed.toString())}, failed: ${chalk
+            .keyword(failedColor)
+            .visible(failed.toString())}, total: ${chalk
+            .keyword(totalColor)
+            .visible(total.toString())}] elapsed ${elapsedTimeString}`);
+    }
+    completedStatusPresenter(lastEntity) {
+        if (this.isSilent) {
+            return;
+        }
+        let color = 'yellow';
+        let statusString = 'UNKNOWN';
+        if (lastEntity.event_status) {
+            const isSuccess = lastEntity.event_status.succeeded;
+            color = isSuccess ? 'green' : 'red';
+            statusString = isSuccess ? 'SUCCESS' : 'FAILED';
+        }
+        loggingProvider_1.logger.info(chalk.bold('\nTests complete with status  ') +
+            chalk.keyword(color).bold(statusString) +
+            '\n');
+        loggingProvider_1.logger.info(this.resultsPresenter.entityToString(lastEntity));
+    }
+    exitOnFirstFailurePresenter(lastEntity) {
+        if (this.isSilent) {
+            return;
+        }
+        loggingProvider_1.logger.info(chalk.bold('\nAt least one Plan Run has ') +
+            chalk.bold.red('FAILED') +
+            chalk.bold('. Failing fast and exiting.'));
+        loggingProvider_1.logger.info(chalk.bold('Additional tests may still be running. Check the mabl app for details. '));
+        loggingProvider_1.logger.info(this.resultsPresenter.entityToString(lastEntity));
+    }
+    timeoutStatusPresenter() {
+        loggingProvider_1.logger.info(chalk.yellow.bold('CLI timed out awaiting test completion.'));
+    }
+}
+exports.AwaitDeploymentCompletion = AwaitDeploymentCompletion;
+AwaitDeploymentCompletion.pollingTimeoutMilliseconds = 6 * 60 * 60 * 1000;
+AwaitDeploymentCompletion.pollingIntervalMilliseconds = 10 * 1000;