@mablhq/playwright-tools 2.49.1

package/commands/applications/applications_cmds/list.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = require("js-yaml");
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const moment = require("moment");
+const list_1 = require("../../commandUtil/list");
+const loggingProvider_1 = require("../../../providers/logging/loggingProvider");
+const constants_1 = require("../../constants");
+exports.command = 'list';
+exports.describe = 'List your applications';
+exports.builder = (0, list_1.getListBuilderOptions)('applications');
+exports.handler = (0, util_1.failWrapper)(listApplications);
+async function listApplications(parsed) {
+    const output = parsed.output;
+    const limit = parsed.limit;
+    const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const applications = await apiClient.getApplications(workspaceId, limit);
+    printApplications(applications, output);
+    return applications.length;
+}
+function printApplications(applications, output) {
+    switch (output) {
+        case 'json':
+            loggingProvider_1.logger.info(JSON.stringify(applications, null, 2));
+            break;
+        case 'yaml':
+            loggingProvider_1.logger.info((0, js_yaml_1.dump)(applications));
+            break;
+        default:
+            const table = new cli_table3_1.default({
+                head: ['ID', 'Name', 'Created time'],
+                wordWrap: true,
+            });
+            applications.forEach((application) => {
+                table.push([
+                    { rowSpan: 1, content: application.id, vAlign: 'center' },
+                    { rowSpan: 1, content: application.name, vAlign: 'center' },
+                    {
+                        rowSpan: 1,
+                        content: moment
+                            .utc(application.created_time)
+                            .format(constants_1.ListTimeFormat),
+                        vAlign: 'center',
+                    },
+                ]);
+            });
+            loggingProvider_1.logger.info(table.toString());
+            break;
+    }
+}

package/commands/auth/auth.js

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

package/commands/auth/auth_cmds/activate-key.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const authenticationProvider_1 = require("../../../providers/authenticationProvider");
+const constants_1 = require("../../constants");
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const cliConfigProvider_1 = require("../../../providers/cliConfigProvider");
+const util_1 = require("../../commandUtil/util");
+exports.command = `activate-key <${constants_1.CommandArgApiKey}>`;
+exports.describe = 'Activate auth by api key';
+exports.builder = {};
+exports.builder = (yargs) => {
+    yargs
+        .positional(constants_1.CommandArgApiKey, {
+        describe: 'API key (escape leading dashes with "\\" (e.g. "\\-yourKey")',
+        type: 'string',
+        nargs: 1,
+        demand: 'API key argument required',
+    })
+        .option('skip-workspace', {
+        describe: 'Set to skip validating and setting the workspace',
+        default: false,
+        hidden: true,
+        type: 'boolean',
+    });
+};
+exports.handler = (0, util_1.failWrapper)(activateApiKey);
+async function activateApiKey(parsed) {
+    const auth = new authenticationProvider_1.AuthenticationProvider();
+    const apiKey = parsed['api-key'];
+    const cleanApiKey = apiKey.replace(/^\\+/, '');
+    const mablApi = await mablApiClientFactory_1.MablApiClientFactory.createApiClientFromApiKey(cleanApiKey);
+    const apiKeyDetails = await mablApi.getApiKeyDetails();
+    if (!parsed['skip-workspace']) {
+        const apiKeyWorkspace = await mablApi.getWorkspace(apiKeyDetails.workspace_id);
+        await cliConfigProvider_1.CliConfigProvider.setWorkspace(apiKeyWorkspace);
+    }
+    return auth.activateApiKey(cleanApiKey);
+}

package/commands/auth/auth_cmds/clear.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const authenticationProvider_1 = require("../../../providers/authenticationProvider");
+exports.command = 'clear';
+exports.describe = 'Clear logged in user';
+exports.builder = {};
+exports.handler = exports.handler = () => {
+    const auth = new authenticationProvider_1.AuthenticationProvider();
+    return auth.clearAuthentication();
+};

package/commands/auth/auth_cmds/info.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const authenticationProvider_1 = require("../../../providers/authenticationProvider");
+exports.command = 'info';
+exports.describe = 'Display logged in user';
+exports.builder = {};
+exports.handler = () => {
+    const auth = new authenticationProvider_1.AuthenticationProvider();
+    return auth.displayInfo();
+};

package/commands/auth/auth_cmds/login.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const authenticationProvider_1 = require("../../../providers/authenticationProvider");
+exports.command = 'login';
+exports.describe = 'Authenticate the mabl CLI';
+exports.builder = {};
+exports.handler = exports.handler = () => {
+    const auth = new authenticationProvider_1.AuthenticationProvider();
+    return auth.authenticate();
+};

package/commands/branches/branches.js

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

package/commands/branches/branches_cmds/create.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const branches_1 = require("../../commandUtil/branches");
+const describe_1 = require("../../commandUtil/describe");
+const ApiError_1 = require("../../../api/ApiError");
+const constants_1 = require("../../constants");
+const loggingProvider_1 = require("../../../providers/logging/loggingProvider");
+exports.command = 'create <name>';
+exports.describe = 'Create a new mabl branch';
+exports.builder = (yargs) => {
+    yargs
+        .positional(constants_1.CommandArgName, {
+        describe: 'Name of the mabl branch to create',
+        nargs: 1,
+        type: 'string',
+        demand: 'branch name is required',
+    })
+        .option(constants_1.CommandArgOutput, {
+        alias: constants_1.CommandArgAliases.OutputType,
+        describe: 'Specify an output type for the branch data',
+        choices: constants_1.DefaultOutputFormatChoices,
+    })
+        .option(constants_1.CommandArgWorkspaceId, {
+        alias: constants_1.CommandArgAliases.WorkspaceId,
+        describe: 'The workspace ID to create a new branch',
+        nargs: 1,
+        type: 'string',
+    })
+        .check((argv) => {
+        const branchName = argv[constants_1.CommandArgName];
+        if (!(0, branches_1.isValidMablBranchName)(branchName)) {
+            throw new Error(`[${branchName}] is not a valid mabl branch name. Please specify a valid name`);
+        }
+        return true;
+    });
+};
+exports.handler = (0, util_1.failWrapper)(createBranch);
+async function createBranch(parsed) {
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+    const branchName = parsed.name;
+    loggingProvider_1.logger.info(`Creating Branch [${branchName}]`);
+    try {
+        const branch = await apiClient.createBranch(workspaceId, branchName);
+        (0, describe_1.outputEntity)(branch, parsed.output);
+        return branch.id;
+    }
+    catch (creationError) {
+        if (creationError instanceof ApiError_1.ApiError && creationError.statusCode === 400) {
+            throw new Error(`mabl branch with [${branchName}] may already exist in workspace [${workspaceId}]`);
+        }
+        throw creationError;
+    }
+}

package/commands/branches/branches_cmds/describe.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const describe_1 = require("../../commandUtil/describe");
+const constants_1 = require("../../constants");
+exports.command = 'describe <identifier>';
+exports.describe = 'Describe a specific mabl branch by id or name';
+exports.builder = (yargs) => {
+    yargs
+        .positional('identifier', {
+        describe: 'The branch ID or NAME to describe',
+        type: 'string',
+        nargs: 1,
+        demand: 'Branch identifier is required',
+    })
+        .option(constants_1.CommandArgName, {
+        alias: constants_1.CommandArgAliases.Name,
+        describe: 'Use identifier as Get branch based on name',
+        type: 'boolean',
+        default: false,
+    })
+        .option(constants_1.CommandArgOutput, {
+        alias: constants_1.CommandArgAliases.OutputType,
+        describe: 'Specify an output type for the branch data',
+        choices: constants_1.DefaultOutputFormatChoices,
+    })
+        .option(constants_1.CommandArgWorkspaceId, {
+        alias: constants_1.CommandArgAliases.WorkspaceId,
+        describe: 'The workspace ID to create a new branch',
+        nargs: 1,
+        type: 'string',
+    });
+};
+exports.handler = (0, util_1.failWrapper)(getBranch);
+async function getBranch(parsed) {
+    const branchIdentifier = parsed.identifier;
+    const lookupByName = parsed.name;
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    let branch;
+    if (lookupByName) {
+        const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+        branch = await apiClient.getBranchByName(workspaceId, branchIdentifier);
+    }
+    else {
+        branch = await apiClient.getBranchById(branchIdentifier);
+    }
+    (0, describe_1.outputEntity)(branch, parsed.output);
+    return branch.id;
+}

package/commands/branches/branches_cmds/list.js

@@ -0,0 +1,84 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_yaml_1 = require("js-yaml");
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const moment = require("moment");
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const interfaces_1 = require("../../commandUtil/interfaces");
+const constants_1 = require("../../constants");
+const loggingProvider_1 = require("../../../providers/logging/loggingProvider");
+exports.command = 'list';
+exports.describe = 'List mabl branches';
+exports.builder = {
+    [constants_1.CommandArgLimitOutput]: {
+        alias: constants_1.CommandArgAliases.LimitOutput,
+        describe: 'Item return limit',
+        nargs: 1,
+        default: interfaces_1.DEFAULT_LISTING_RESULT_LIMIT,
+    },
+    [constants_1.CommandArgOutput]: {
+        alias: constants_1.CommandArgAliases.OutputType,
+        describe: 'Specify result output format',
+        choices: constants_1.DefaultOutputFormatChoices,
+        nargs: 1,
+    },
+    status: {
+        alias: constants_1.CommandArgAliases.Status,
+        describe: 'filter results by status',
+        choices: ['open', 'merged'],
+        nargs: 1,
+    },
+    [constants_1.CommandArgWorkspaceId]: {
+        alias: constants_1.CommandArgAliases.WorkspaceId,
+        describe: 'The workspace ID to list branches for',
+        nargs: 1,
+    },
+};
+exports.handler = (0, util_1.failWrapper)(listBranches);
+async function listBranches(parsed) {
+    const output = parsed.output;
+    const limit = parsed.limit;
+    const statusFilter = parsed.status;
+    const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const branches = await apiClient.getBranches(workspaceId, limit, statusFilter);
+    printBranches(branches, output);
+    return branches.length;
+}
+function printBranches(branches, output) {
+    switch (output) {
+        case 'json':
+            loggingProvider_1.logger.info(JSON.stringify(branches, null, 2));
+            break;
+        case 'yaml':
+            loggingProvider_1.logger.info((0, js_yaml_1.dump)(branches));
+            break;
+        default:
+            const table = new cli_table3_1.default({
+                head: ['ID', 'Name', 'Status', 'Created'],
+            });
+            branches.forEach((branch) => {
+                table.push([
+                    { rowSpan: 1, content: branch.id, vAlign: 'center' },
+                    { rowSpan: 1, content: branch.name, vAlign: 'center' },
+                    {
+                        rowSpan: 1,
+                        content: branch.status,
+                        vAlign: 'center',
+                        hAlign: 'center',
+                    },
+                    {
+                        rowSpan: 1,
+                        content: moment.utc(branch.created_time).format(constants_1.ListTimeFormat),
+                        vAlign: 'center',
+                    },
+                ]);
+            });
+            loggingProvider_1.logger.info(table.toString());
+            break;
+    }
+}

package/commands/branches/branches_cmds/merge.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mablApiClientFactory_1 = require("../../../api/mablApiClientFactory");
+const util_1 = require("../../commandUtil/util");
+const branches_1 = require("../../commandUtil/branches");
+const describe_1 = require("../../commandUtil/describe");
+const constants_1 = require("../../constants");
+const CommandArgFrom = 'from';
+const CommandArgTo = 'to';
+exports.command = 'merge';
+exports.describe = 'Merge mabl branches';
+exports.builder = (yargs) => {
+    yargs
+        .option(CommandArgFrom, {
+        alias: constants_1.CommandArgAliases.BranchFrom,
+        describe: 'Name of the mabl branch to merge from',
+        type: 'string',
+        demand: `a mabl from branch [--${CommandArgFrom}] is required`,
+        nargs: 1,
+    })
+        .option(CommandArgTo, {
+        alias: constants_1.CommandArgAliases.BranchTo,
+        describe: 'Name of the mabl branch to merge to',
+        type: 'string',
+        default: 'master',
+        nargs: 1,
+    })
+        .option(constants_1.CommandArgOutput, {
+        alias: constants_1.CommandArgAliases.OutputType,
+        describe: 'Specify an output type for the branch data',
+        choices: constants_1.DefaultOutputFormatChoices,
+    })
+        .option(constants_1.CommandArgWorkspaceId, {
+        alias: constants_1.CommandArgAliases.WorkspaceId,
+        describe: 'The workspace ID to create a new branch',
+        nargs: 1,
+        type: 'string',
+    })
+        .check((argv) => {
+        const fromBranchName = argv[CommandArgFrom];
+        if (!(0, branches_1.isValidMablBranchName)(fromBranchName)) {
+            throw new Error(`[${fromBranchName}] is not a valid mabl branch name. Please specify a valid name`);
+        }
+        return true;
+    });
+};
+exports.handler = (0, util_1.failWrapper)(mergeBranch);
+async function mergeBranch(parsed) {
+    const apiClient = await mablApiClientFactory_1.MablApiClientFactory.createApiClient();
+    const workspaceId = await (0, util_1.getWorkspaceId)(parsed);
+    const fromBranchName = parsed.from;
+    const toBranchName = parsed.to;
+    const branch = await apiClient.mergeBranch(workspaceId, fromBranchName, toBranchName);
+    (0, describe_1.outputEntity)(branch, parsed.output);
+    return branch.id;
+}

package/commands/browserTypes.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultBrowserProperties = exports.SupportedBrowserTypeProperties = exports.BrowserType = void 0;
+var BrowserType;
+(function (BrowserType) {
+    BrowserType["Chrome"] = "chrome";
+    BrowserType["Edge"] = "edge";
+    BrowserType["Firefox"] = "firefox";
+    BrowserType["Webkit"] = "webkit";
+})(BrowserType || (exports.BrowserType = BrowserType = {}));
+exports.SupportedBrowserTypeProperties = {
+    chrome: { browserName: 'chrome', browserReleaseChannel: 'chrome' },
+    edge: { browserName: 'edge', browserReleaseChannel: 'msedge' },
+    firefox: { browserName: 'firefox', browserReleaseChannel: 'firefox' },
+    webkit: {
+        browserName: 'webkit',
+        browserReleaseChannel: 'webkit',
+    },
+};
+exports.DefaultBrowserProperties = exports.SupportedBrowserTypeProperties.chrome;

package/commands/commandUtil/awaitCompletion.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AwaitCompletion = exports.PollingOutcomeType = void 0;
+var PollingOutcomeType;
+(function (PollingOutcomeType) {
+    PollingOutcomeType[PollingOutcomeType["Queued"] = 0] = "Queued";
+    PollingOutcomeType[PollingOutcomeType["Running"] = 1] = "Running";
+    PollingOutcomeType[PollingOutcomeType["Terminated"] = 2] = "Terminated";
+    PollingOutcomeType[PollingOutcomeType["Complete"] = 3] = "Complete";
+    PollingOutcomeType[PollingOutcomeType["Timeout"] = 4] = "Timeout";
+})(PollingOutcomeType || (exports.PollingOutcomeType = PollingOutcomeType = {}));
+const completeStates = Object.freeze([
+    PollingOutcomeType.Complete,
+    PollingOutcomeType.Timeout,
+]);
+class AwaitCompletion {
+    constructor(apiClient, pollingTimeoutMilliseconds, pollingIntervalMilliseconds) {
+        this.apiClient = apiClient;
+        this.defaultPollingTimeoutMilliseconds = 10 * 60 * 1000;
+        this.defaultPollingIntervalMilliseconds = 1000;
+        this.pollingTimeoutMilliseconds =
+            pollingTimeoutMilliseconds || this.defaultPollingTimeoutMilliseconds;
+        this.pollingIntervalMilliseconds =
+            pollingIntervalMilliseconds || this.defaultPollingIntervalMilliseconds;
+        this.startedEpochMilliseconds = Date.now();
+    }
+    setPollingInterval(milliseconds) {
+        this.pollingIntervalMilliseconds = milliseconds;
+    }
+    isComplete(status) {
+        return completeStates.includes(status);
+    }
+    getElapsedMilliseconds() {
+        return Date.now() - this.startedEpochMilliseconds;
+    }
+    isTimedOut() {
+        const millisecondsElapsed = this.getElapsedMilliseconds();
+        return millisecondsElapsed >= this.pollingTimeoutMilliseconds;
+    }
+    async awaitCompletion(seedId) {
+        if (!seedId) {
+            throw new Error('Seed is undefined');
+        }
+        const pollingResult = await this.pollingFunction(this.apiClient, undefined, seedId);
+        this.statusPresenter(pollingResult.newEntity, pollingResult.status);
+        if (this.isTimedOut()) {
+            this.timeoutStatusPresenter(pollingResult.newEntity);
+            return {
+                newEntity: pollingResult.newEntity,
+                status: PollingOutcomeType.Timeout,
+            };
+        }
+        if (this.isComplete(pollingResult.status)) {
+            this.completedStatusPresenter(pollingResult.newEntity);
+            return {
+                newEntity: pollingResult.newEntity,
+                status: PollingOutcomeType.Complete,
+            };
+        }
+        return new Promise((resolve, reject) => {
+            setTimeout(() => this.awaitCompletion(seedId)
+                .then((result) => resolve(result))
+                .catch((error) => reject(error)), this.pollingIntervalMilliseconds);
+        });
+    }
+}
+exports.AwaitCompletion = AwaitCompletion;

package/commands/commandUtil/branches.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isValidMablBranchName = exports.crossCheckBranchWithTest = exports.printBranchRunningInfo = exports.checkBranchNameAndAutoBranchMaybe = void 0;
+const constants_1 = require("../constants");
+const loggingProvider_1 = require("../../providers/logging/loggingProvider");
+const chalk = require('chalk');
+async function checkBranchNameAndAutoBranchMaybe(workspaceId, apiClient, branchName, autoBranch) {
+    if (branchName) {
+        try {
+            await apiClient.getBranchByName(workspaceId, branchName);
+        }
+        catch (error) {
+            if (autoBranch) {
+                await apiClient.createBranch(workspaceId, branchName);
+            }
+            else {
+                loggingProvider_1.logger.error(chalk.red.bold(`mabl branch [${branchName}] does not exist.\n` +
+                    'Please specify an existing branch or provide the [--auto-branch] argument to create a new branch'));
+                process.exit(1);
+            }
+        }
+    }
+}
+exports.checkBranchNameAndAutoBranchMaybe = checkBranchNameAndAutoBranchMaybe;
+function printBranchRunningInfo(branchName) {
+    loggingProvider_1.logger.info(chalk.yellow('Running test(s) on the', chalk.magenta(branchName), chalk.yellow('branch')));
+}
+exports.printBranchRunningInfo = printBranchRunningInfo;
+function crossCheckBranchWithTest(branchName, test) {
+    var _a, _b;
+    if (((_a = test.source_control_tags) === null || _a === void 0 ? void 0 : _a[branchName]) === undefined &&
+        ((_b = test.source_control_tags) === null || _b === void 0 ? void 0 : _b[constants_1.DefaultBranchName]) === undefined) {
+        loggingProvider_1.logger.info(chalk.red('ERROR: Test does not exist on the branch:', chalk.magenta(branchName), 'Use the --mabl-branch flag to specify a branch'));
+        process.exit(1);
+    }
+}
+exports.crossCheckBranchWithTest = crossCheckBranchWithTest;
+function isValidMablBranchName(branchName) {
+    if (branchName) {
+        return /^[A-Za-z0-9._/-]+$/.test(branchName.trim());
+    }
+    return false;
+}
+exports.isValidMablBranchName = isValidMablBranchName;