@mablhq/mabl-cli 2.19.13 → 2.20.7

package/README.md

@@ -195,8 +195,8 @@ Use the:
 - `--auto-branch` flag to automatically create the specified branch if it
   doesn't exist already
 - `--width` and `--height` flags to specify the viewport sizes of the browser
-- `--creds` or `--credentials` flag to specify a testing credential set to use
-  during edit (`mabl credentials list` to see available ones)
+- `--creds` or `--credentials-id` flag to specify a testing credential set to
+  use during edit (`mabl credentials list` to see available ones)
 
 _Note: required IDs can be found by using the CLI list commands or on the test
 details or test output pages inside the mabl web app_

package/api/mablApiClient.js

@@ -843,14 +843,14 @@ class MablApiClient extends basicApiClient_1.BasicApiClient {
             timeout: 3600000,
         });
     }
-    async getEffectiveFeaturesByWorkspaceId(workspaceId) {
+    async getEnabledAccountFeaturesByWorkspaceId(workspaceId) {
         var _a;
         try {
             const account = await this.getAccountByWorkspaceId(workspaceId);
             return new featureSet_1.FeatureSet(new Set((_a = account.effective_features) !== null && _a !== void 0 ? _a : []));
         }
         catch (error) {
-            throw toApiError(`Failed to get feature flags for workspace ${workspaceId}`, error);
+            throw toApiError(`Failed to get effective account features for workspace ${workspaceId}`, error);
         }
     }
     async getEnabledLabsFeaturesForWorkspace(workspaceId) {

package/commands/tests/tests_cmds/run-cloud.js

@@ -223,7 +223,7 @@ async function executeRunCloudTest(test, browsers, branchName, apiClient, maybeD
         ? test === null || test === void 0 ? void 0 : test.url
         : undefined);
     const effectiveApiUrl = apiUrl !== null && apiUrl !== void 0 ? apiUrl : (test.test_type && test.test_type !== mablApi_1.TestTypeEnum.Browser
-        ? test === null || test === void 0 ? void 0 : test.url
+        ? test === null || test === void 0 ? void 0 : test.api_url
         : undefined);
     const workspaceId = test.organization_id;
     const testId = test.invariant_id;

package/core/execution/PostmanUtils.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeExportedVariables = exports.exportVariables = exports.convertVariablesSummaryToPostmanFormat = void 0;
+const VariableUtils_1 = require("./VariableUtils");
+const domUtil_1 = require("../../domUtil");
+function convertVariablesSummaryToPostmanFormat(summary) {
+    const effectiveVariables = { ...summary.effective };
+    const values = Object.keys(effectiveVariables).map((key) => ({
+        key,
+        value: effectiveVariables[key],
+    }));
+    return {
+        values,
+    };
+}
+exports.convertVariablesSummaryToPostmanFormat = convertVariablesSummaryToPostmanFormat;
+function exportVariables(postmanResult) {
+    const variablePrecedence = [
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.globals.values,
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.collection.variables,
+        postmanResult === null || postmanResult === void 0 ? void 0 : postmanResult.environment.values,
+    ].filter((variables) => !!variables);
+    const exportedVariables = {};
+    variablePrecedence
+        .map((variableList) => variableList.all())
+        .forEach((variables) => variables.forEach((variable) => (exportedVariables[variable.key] = variable.value)));
+    return exportedVariables;
+}
+exports.exportVariables = exportVariables;
+function sanitizeExportedVariables(variables) {
+    const normalized = {};
+    if (variables) {
+        return normalizeExportedVariables(filterExportedVariables(variables));
+    }
+    return normalized;
+}
+exports.sanitizeExportedVariables = sanitizeExportedVariables;
+function normalizeExportedVariables(variables) {
+    const normalized = {};
+    Object.keys(variables).forEach((name) => {
+        normalized[(0, VariableUtils_1.addUserNamespace)(name)] = variables[name];
+    });
+    return normalized;
+}
+function filterExportedVariables(variables) {
+    const filtered = {};
+    Object.keys(variables)
+        .filter((name) => (0, domUtil_1.isValidUserVariableName)(name))
+        .forEach((name) => {
+        filtered[name] = variables[name];
+    });
+    return filtered;
+}

package/core/execution/VariableUtils.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addUserNamespace = exports.generateVariablesSummaryForExport = exports.generateVariablesSummaryForImport = exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME = exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME = exports.API_CREDENTIALS_NAMESPACE = exports.API_URL_VARIABLE_NAME = exports.API_NAMESPACE = exports.FLOW_NAMESPACE = exports.USER_NAMESPACE = void 0;
+const domUtil_1 = require("../../domUtil");
+exports.USER_NAMESPACE = 'user.';
+exports.FLOW_NAMESPACE = 'flow.';
+exports.API_NAMESPACE = 'api.';
+exports.API_URL_VARIABLE_NAME = `${exports.API_NAMESPACE}url`;
+exports.API_CREDENTIALS_NAMESPACE = `${exports.API_NAMESPACE}credentials.`;
+exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME = `${exports.API_CREDENTIALS_NAMESPACE}username`;
+exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME = `${exports.API_CREDENTIALS_NAMESPACE}password`;
+function generateVariablesSummaryForImport(variableSources) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { environment, scenario, url, credentials, plan, flow, journeyRun, previousFlowVariables, } = variableSources;
+    const summary = {
+        dataDriven: {},
+        effective: {},
+        environment: {},
+        flow: {},
+        journey: {},
+        parameters: {},
+    };
+    const environmentVariables = (environment === null || environment === void 0 ? void 0 : environment.variables) || {};
+    Object.keys(environmentVariables).forEach((key) => (summary.environment[removeUserNamespace(key)] =
+        environmentVariables[key]));
+    const planParameters = extractValueParameters(plan === null || plan === void 0 ? void 0 : plan.parameters);
+    planParameters.forEach((parameter) => (summary.parameters[removeUserNamespace(parameter.name)] =
+        parameter.value));
+    const journeyParameters = extractValueParameters(journeyRun &&
+        (plan === null || plan === void 0 ? void 0 : plan.execution_stages) &&
+        ((_c = (_b = (_a = plan.execution_stages[journeyRun.stage_index]) === null || _a === void 0 ? void 0 : _a.journeys) === null || _b === void 0 ? void 0 : _b.find((journey) => journey.journey_id)) === null || _c === void 0 ? void 0 : _c.parameters));
+    journeyParameters.forEach((parameter) => (summary.parameters[removeUserNamespace(parameter.name)] =
+        parameter.value));
+    const journeyInputs = ((_d = journeyRun === null || journeyRun === void 0 ? void 0 : journeyRun.journey_parameters) === null || _d === void 0 ? void 0 : _d.imported_variables) || {};
+    Object.keys(journeyInputs).forEach((key) => (summary.journey[removeUserNamespace(key)] = journeyInputs[key]));
+    const ddtVariables = ((_f = (_e = journeyRun === null || journeyRun === void 0 ? void 0 : journeyRun.journey_parameters) === null || _e === void 0 ? void 0 : _e.user_variables) === null || _f === void 0 ? void 0 : _f.row) ||
+        (scenario === null || scenario === void 0 ? void 0 : scenario.variables) ||
+        [];
+    ddtVariables.forEach((variable) => (summary.dataDriven[removeUserNamespace(variable.name)] =
+        variable.value));
+    const precedence = [
+        summary.environment,
+        summary.parameters,
+        summary.journey,
+        summary.dataDriven,
+    ];
+    precedence.forEach((variables) => Object.keys(variables).forEach((name) => (summary.effective[name] = variables[name])));
+    if (flow === null || flow === void 0 ? void 0 : flow.parameters) {
+        flow.parameters.forEach((parameter) => {
+            const parameterName = removePrefix(parameter.name, exports.FLOW_NAMESPACE);
+            summary.flow[parameterName] = parameter.default_value;
+            if (!summary.effective[parameterName]) {
+                summary.effective[parameterName] = parameter.default_value;
+            }
+        });
+    }
+    const exportedVariables = previousFlowVariables || {};
+    Object.keys(exportedVariables).forEach((key) => {
+        summary.dataDriven[key] = exportedVariables[key];
+        summary.effective[key] = exportedVariables[key];
+    });
+    if (url) {
+        summary.effective[exports.API_URL_VARIABLE_NAME] = url;
+    }
+    if (credentials) {
+        summary.effective[exports.API_CREDENTIALS_USERNAME_VARIABLE_NAME] =
+            (_g = credentials.properties) === null || _g === void 0 ? void 0 : _g.username;
+        summary.effective[exports.API_CREDENTIALS_PASSWORD_VARIABLE_NAME] =
+            (_h = credentials.properties) === null || _h === void 0 ? void 0 : _h.password;
+    }
+    return summary;
+}
+exports.generateVariablesSummaryForImport = generateVariablesSummaryForImport;
+function generateVariablesSummaryForExport(testContext, plan, flow, journeyRun, exportedVariables) {
+    return normalizeVariablesSummaryForExport(generateVariablesSummaryForImport({
+        environment: testContext.environment,
+        url: testContext.url,
+        credentials: testContext.credentials,
+        scenario: testContext.getScenario(),
+        plan,
+        flow,
+        journeyRun,
+        previousFlowVariables: exportedVariables,
+    }));
+}
+exports.generateVariablesSummaryForExport = generateVariablesSummaryForExport;
+function normalizeVariablesSummaryForExport(summary) {
+    return {
+        dataDriven: addUserNamespaceToVariableNames(sanitizeVariables(summary.dataDriven)),
+        effective: sanitizeVariables(summary.effective),
+        environment: addUserNamespaceToVariableNames(sanitizeVariables(summary.environment)),
+        flow: addPrefixToVariableNames(sanitizeVariables(summary.flow), exports.FLOW_NAMESPACE),
+        journey: addUserNamespaceToVariableNames(sanitizeVariables(summary.journey)),
+        parameters: addUserNamespaceToVariableNames(sanitizeVariables(summary.parameters)),
+    };
+}
+function sanitizeVariables(variables) {
+    const sanitizedVariables = {};
+    Object.keys(variables)
+        .filter((name) => (0, domUtil_1.isValidUserVariableName)(name))
+        .forEach((name) => (sanitizedVariables[name] = variables[name]));
+    return sanitizedVariables;
+}
+function addUserNamespaceToVariableNames(variables) {
+    return addPrefixToVariableNames(variables, exports.USER_NAMESPACE);
+}
+function addPrefixToVariableNames(variables, prefix) {
+    return mapVariables(variables, (variable) => ({
+        name: addPrefix(variable.name, prefix),
+        value: variable.value,
+    }));
+}
+function mapVariables(variables, mapper) {
+    const mappedVariables = {};
+    Object.keys(variables)
+        .map((name) => mapper({ name, value: variables[name] }))
+        .forEach((variable) => (mappedVariables[variable.name] = variable.value));
+    return mappedVariables;
+}
+function extractValueParameters(parameters) {
+    if (!parameters) {
+        return [];
+    }
+    return parameters.filter((parameter) => { var _a; return ((_a = parameter.type) === null || _a === void 0 ? void 0 : _a.toString()) === 'value'; });
+}
+function removeUserNamespace(variableName) {
+    return removePrefix(variableName, exports.USER_NAMESPACE);
+}
+function removePrefix(variableName, prefix) {
+    if (variableName.startsWith(prefix)) {
+        return variableName.substring(prefix.length);
+    }
+    return variableName;
+}
+function addUserNamespace(variableName) {
+    return addPrefix(variableName, exports.USER_NAMESPACE);
+}
+exports.addUserNamespace = addUserNamespace;
+function addPrefix(variableName, prefix) {
+    if (variableName.startsWith(prefix)) {
+        return variableName;
+    }
+    return `${prefix}${variableName}`;
+}