@mablhq/mabl-cli 2.72.4 → 2.72.12

package/http/requestInterceptor.js

@@ -1,12 +1,8 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestInterceptor = exports.MAX_SERIALIZED_BODY_SIZE_BYTES = void 0;
 exports.headerStringToHeaders = headerStringToHeaders;
 exports.headerStringToProtocol = headerStringToProtocol;
-const axios_1 = __importDefault(require("axios"));
 const loggingProvider_1 = require("../providers/logging/loggingProvider");
 const uuid_1 = require("uuid");
 const httpUtil_1 = require("./httpUtil");
@@ -91,7 +87,7 @@ class RequestInterceptor {
     }
     registerInterceptors(axiosInstance) {
         this.requestInterceptorId = axiosInstance.interceptors.request.use(this.handleRequest, this.handleError);
-        this.responseInterceptorId = axios_1.default.interceptors.response.use(this.handleResponse, this.handleError);
+        this.responseInterceptorId = axiosInstance.interceptors.response.use(this.handleResponse, this.handleError);
     }
     ejectInterceptors(axiosInstance) {
         try {
@@ -171,6 +167,15 @@ class RequestInterceptor {
                 chainEntry =
                     this.interceptedRequests[this.interceptedRequests.length - 1];
             }
+            const anyError = error;
+            if (anyError?.name === 'AggregateError' &&
+                (!error.message || error.message.trim() === '') &&
+                Array.isArray(anyError.errors)) {
+                const underlying = anyError.errors.find((e) => e?.message);
+                if (underlying?.message) {
+                    anyError.message = underlying.message;
+                }
+            }
             if (chainEntry) {
                 chainEntry.error = {
                     code: error.code ?? httpUtil_1.GENERAL_API_STEP_EXECUTION_ERROR_CODE,

package/index.d.ts

@@ -2,6 +2,7 @@ import {BrowserContext, Locator, Page, Frame} from 'playwright-core';
 import {TestType} from '@playwright/test';
 
 declare module '@mablhq/mabl-cli' {
+  export type AuthServerPolicy = 'off' | 'none' | 'all';
   export enum TestResultStatus {
     passed = 'passed',
     skipped = 'skipped',
@@ -38,6 +39,7 @@ declare module '@mablhq/mabl-cli' {
   }
   export interface TestRunConfig {
     authToken?: string;
+    authServerPolicy?: AuthServerPolicy;
     basicAuthCredentialsId?: string;
     branchName?: string;
     branchChangesOnly?: boolean;

package/mablscript/MablStepV2.js

@@ -10,43 +10,73 @@ class MablStepV2 extends MablStep_1.MablStep {
         super(name, [], [], actionCode);
         this.stepVersion = 2;
         this.descriptor = descriptor;
+        this.descriptor.actionCode = actionCode;
+        this.description = descriptor.description;
+        this.disabled = descriptor.disabled;
     }
     stepId() {
-        return this.descriptor.id;
+        return this.descriptor.id ?? super.stepId();
     }
     setStepId(id) {
+        super.setStepId(id);
         this.descriptor.id = id;
     }
     static fromYaml(stepName, stepDescriptor, actionCode) {
         return new MablStepV2(stepName, stepDescriptor, actionCode);
     }
+    static fromLegacyMablscript(_args, _actions) {
+        throw new Error('Legacy mablscript conversion not supported for MablStepV2 base class');
+    }
     getStepName() {
         return this.name;
     }
+    getActionName() {
+        return this.actionCode ?? super.getActionName();
+    }
     toStepDescriptor() {
         return this.descriptor;
     }
     getFormattedStep(_fullLocatorsOn) {
+        const { descriptorToActionMap, ...stepDescriptor } = this.toStepDescriptor();
+        const result = {
+            description: this.getDescription(),
+            ...stepDescriptor,
+        };
+        if (this.annotation?.description || this.annotation?.note) {
+            result.annotation = this.annotation;
+        }
+        if (this.isDisabled()) {
+            result.disabled = true;
+        }
         return {
-            [this.getStepName()]: {
-                description: this.stepDescription(),
-                ...this.descriptor,
-            },
+            [this.getStepName()]: result,
         };
     }
+    getDescription() {
+        return (this.description ?? this.descriptor.description ?? this.stepDescription());
+    }
+    setDescription(description) {
+        this.description = description;
+        this.descriptor.description = description;
+    }
     stepDescription() {
         throw new Error('Step description not implemented');
     }
     isDisabled() {
-        return !!this.descriptor.disabled;
+        return !!this.disabled;
     }
     setDisabled(disabled) {
+        this.disabled = disabled;
         this.descriptor.disabled = disabled;
     }
+    canContinueOnFailure() {
+        return false;
+    }
+    canFailAtEnd() {
+        return false;
+    }
     getDescriptionForLogging() {
-        return (this.annotation?.description ||
-            this.stepDescription() ||
-            this.getStepName());
+        return this.annotation?.description ?? this.getDescription();
     }
     toLineDiffFormat() {
         const lineDiffProperties = {
@@ -61,7 +91,7 @@ exports.MablStepV2 = MablStepV2;
 MablStepV2.mablScriptStepNames = [];
 MablStepV2.yamlMablScriptNames = ['MablStepV2'];
 function isMablStepV2(value) {
-    if (value === undefined || value === null) {
+    if (!value) {
         return false;
     }
     const mablStep = value;

package/mablscript/MablStepWithFindAction.js

@@ -2,10 +2,134 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MablStepWithFindAction = void 0;
 exports.isStepWithFindAction = isStepWithFindAction;
-const MablStep_1 = require("./MablStep");
-class MablStepWithFindAction extends MablStep_1.MablStep {
+exports.humanizeFindDescriptor = humanizeFindDescriptor;
+exports.humanizeCustomFind = humanizeCustomFind;
+exports.humanizeQuery = humanizeQuery;
+exports.humanizeFindEmail = humanizeFindEmail;
+exports.humanizeFindCookie = humanizeFindCookie;
+exports.humanizeFindTab = humanizeFindTab;
+exports.getTagNameFromFoundSelectors = getTagNameFromFoundSelectors;
+exports.isCustomFindDescriptor = isCustomFindDescriptor;
+exports.isEmailFindDescriptor = isEmailFindDescriptor;
+exports.isCookieFindDescriptor = isCookieFindDescriptor;
+exports.isTabFindDescriptor = isTabFindDescriptor;
+const MablStepV2_1 = require("./MablStepV2");
+const domUtil_1 = require("../domUtil");
+const mablscriptFind_1 = require("../mablscriptFind");
+const stepUtil_1 = require("./mobile/steps/stepUtil");
+class MablStepWithFindAction extends MablStepV2_1.MablStepV2 {
+    constructor(name, descriptor, actionCode, findAction) {
+        super(name, descriptor, actionCode);
+        this.findAction = findAction;
+    }
+    humanizeFind() {
+        const findDescriptor = this.findAction.toDescriptor();
+        return humanizeFindDescriptor(findDescriptor);
+    }
 }
 exports.MablStepWithFindAction = MablStepWithFindAction;
 function isStepWithFindAction(step) {
     return step instanceof MablStepWithFindAction || 'findAction' in step;
 }
+function humanizeFindDescriptor(findDescriptor) {
+    switch (findDescriptor.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ALL:
+            return humanizeCustomFind(findDescriptor);
+        case domUtil_1.FindType.FIND_ONE:
+            const maybeMobileFindDescriptor = (0, domUtil_1.isMobileFindSpecification)(findDescriptor.findTarget)
+                ? {
+                    findTarget: { ...findDescriptor.findTarget },
+                    findType: findDescriptor.findType,
+                }
+                : findDescriptor;
+            if ((0, domUtil_1.isMobileFindDescriptor)(maybeMobileFindDescriptor)) {
+                return (0, stepUtil_1.getElementDescriptionFromMobileFindDescriptor)(maybeMobileFindDescriptor);
+            }
+            return (0, mablscriptFind_1.humanizeFindOneDescriptor)(findDescriptor.findTarget);
+        case domUtil_1.FindType.FIND_EMAIL:
+            return humanizeFindEmail(findDescriptor);
+        case domUtil_1.FindType.FIND_COOKIE:
+            return humanizeFindCookie(findDescriptor);
+        case domUtil_1.FindType.FIND_TAB:
+            return humanizeFindTab(findDescriptor);
+        default:
+            return 'element';
+    }
+}
+function humanizeCustomFind(findDescriptor) {
+    if (!isCustomFindDescriptor(findDescriptor)) {
+        return 'element';
+    }
+    const type = findDescriptor.findType.replace('find_', '');
+    let tagText;
+    const foundElementSelectors = findDescriptor.foundElementSelectors;
+    const tagName = getTagNameFromFoundSelectors(foundElementSelectors);
+    if (tagName) {
+        tagText = `${type} ${tagName.toLowerCase()} element`;
+    }
+    else {
+        const s = findDescriptor.findType === domUtil_1.FindType.FIND_ALL ? 's' : '';
+        tagText = `${type} element${s}`;
+    }
+    return `${tagText} ${humanizeQuery(findDescriptor)}`;
+}
+function humanizeQuery(findDescriptor) {
+    const primarySelectors = findDescriptor.primarySelectors;
+    if ((0, domUtil_1.isCssSelector)(primarySelectors)) {
+        const compactQuery = primarySelectors.css_query.replace(/\s+/g, ' ').trim();
+        return `matching css query "${compactQuery}"`;
+    }
+    else if ((0, domUtil_1.isXPathSelector)(primarySelectors)) {
+        const compactQuery = primarySelectors.xpath.replace(/\s+/g, ' ').trim();
+        return `matching xpath "${compactQuery}"`;
+    }
+    return 'matching "<unrecognized query>"';
+}
+function humanizeFindEmail(findDescriptor) {
+    if (!isEmailFindDescriptor(findDescriptor)) {
+        return 'email';
+    }
+    return (0, mablscriptFind_1.humanizeEmailSelector)(findDescriptor.findTarget.selector);
+}
+function humanizeFindCookie(findDescriptor) {
+    if (!isCookieFindDescriptor(findDescriptor)) {
+        return 'cookie';
+    }
+    return (0, mablscriptFind_1.humanizeCookieSelector)(findDescriptor.findTarget);
+}
+function humanizeFindTab(findDescriptor) {
+    if (!isTabFindDescriptor(findDescriptor)) {
+        return 'tab';
+    }
+    if (findDescriptor.findTarget === 'initial') {
+        return 'the initial tab';
+    }
+    return (0, mablscriptFind_1.humanizeTabSelector)(findDescriptor.findTarget);
+}
+function getTagNameFromFoundSelectors(foundElementSelectors) {
+    if (!foundElementSelectors) {
+        return undefined;
+    }
+    if (typeof foundElementSelectors === 'object' &&
+        'tag_name' in foundElementSelectors) {
+        return foundElementSelectors.tag_name;
+    }
+    return undefined;
+}
+function isCustomFindDescriptor(descriptor) {
+    return ((descriptor.findType === domUtil_1.FindType.FIND_FIRST ||
+        descriptor.findType === domUtil_1.FindType.FIND_LAST ||
+        descriptor.findType === domUtil_1.FindType.FIND_ALL) &&
+        'primarySelectors' in descriptor);
+}
+function isEmailFindDescriptor(descriptor) {
+    return descriptor.findType === domUtil_1.FindType.FIND_EMAIL;
+}
+function isCookieFindDescriptor(descriptor) {
+    return descriptor.findType === domUtil_1.FindType.FIND_COOKIE;
+}
+function isTabFindDescriptor(descriptor) {
+    return descriptor.findType === domUtil_1.FindType.FIND_TAB;
+}

package/mablscript/actions/AwaitDownloadAction.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwaitDownloadAction = void 0;
 const MablAction_1 = require("../MablAction");
 class AwaitDownloadAction extends MablAction_1.MablAction {
-    constructor(name, args) {
-        super(name, 'await_download', args);
+    constructor(_name, args) {
+        super(AwaitDownloadAction.actionCode, AwaitDownloadAction.actionCode, args);
     }
     toMablscript() {
         return 'await_download()';
     }
 }
 exports.AwaitDownloadAction = AwaitDownloadAction;
-AwaitDownloadAction.mablScriptStepNames = ['await_download'];
+AwaitDownloadAction.actionCode = 'await_download';
+AwaitDownloadAction.mablScriptStepNames = [AwaitDownloadAction.actionCode];

package/mablscript/actions/AwaitPDFDownloadAction.js

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AwaitPDFDownloadAction = void 0;
-const AwaitDownloadAction_1 = require("./AwaitDownloadAction");
+const MablAction_1 = require("../MablAction");
 const domUtil_1 = require("../../domUtil");
-class AwaitPDFDownloadAction extends AwaitDownloadAction_1.AwaitDownloadAction {
-    constructor(name, args) {
-        super(name, args);
+class AwaitPDFDownloadAction extends MablAction_1.MablAction {
+    constructor(_name, args) {
+        super(AwaitPDFDownloadAction.actionCode, AwaitPDFDownloadAction.actionCode, args);
         this.pdfUUID = this.getActionArgs()[0].uuid;
     }
     toMablscript() {
@@ -16,4 +16,5 @@ class AwaitPDFDownloadAction extends AwaitDownloadAction_1.AwaitDownloadAction {
     }
 }
 exports.AwaitPDFDownloadAction = AwaitPDFDownloadAction;
-AwaitPDFDownloadAction.mablScriptStepNames = ['await_pdf'];
+AwaitPDFDownloadAction.actionCode = 'await_pdf';
+AwaitPDFDownloadAction.mablScriptStepNames = [AwaitPDFDownloadAction.actionCode];

package/mablscript/actions/ConditionAction.js

@@ -40,7 +40,8 @@ class ConditionAction extends MablAction_1.MablAction {
         if (!(0, ConditionDescriptor_1.isComparisonType)(conditionAttribute)) {
             throw new Error(`Invalid equality condition. Invalid comparison type: ${conditionAttribute}`);
         }
-        if (options) {
+        if (options &&
+            Object.values(options).some((value) => value !== undefined)) {
             this.hasOptionsAtInstantiation = true;
         }
         return {

package/mablscript/actions/ExtractAction.js

@@ -21,30 +21,25 @@ class ExtractAction extends MablAction_1.MablAction {
         else {
             this.extractionAttribute = this.getActionArgs()[0];
         }
-        if (this.name === ExtractDescriptor_1.ExtractType.EXTRACT_ATTRIBUTE && this.args.length > 1) {
-            const extractionOptions = this.args[1];
+        const actionArgs = this.getActionArgs();
+        if (this.name === ExtractDescriptor_1.ExtractType.EXTRACT_ATTRIBUTE && actionArgs.length > 1) {
+            const extractionOptions = actionArgs[1];
             const metaExtractionType = extractionOptions.extraction_type;
             if (metaExtractionType?.toLowerCase() === exports.CSS_EXTRACTION_VALUE) {
-                this.extractionType = ExtractDescriptor_1.ExtractType.EXTRACT_CSS_PROPERTIES.toString();
+                this.name = ExtractDescriptor_1.ExtractType.EXTRACT_CSS_PROPERTIES;
             }
-            else {
-                this.extractionType = this.name;
-            }
-        }
-        else {
-            this.extractionType = this.name;
         }
-        this.extractDescriptor = this.getExtractDescriptor();
-    }
-    getExtractDescriptor() {
+        this.extractionType = ExtractDescriptor_1.ExtractType.fromString(this.name);
         if (!this.extractionAttribute) {
             throw new Error(`Attribute name is required for extract attribute action.`);
         }
         if (typeof this.extractionAttribute !== 'string') {
             throw new Error(`Invalid attribute provided for extract attribute extractor: ${this.extractionAttribute}`);
         }
+    }
+    toDescriptor() {
         return {
-            extractType: ExtractDescriptor_1.ExtractType.fromString(this.extractionType),
+            extractType: this.extractionType,
             attributeName: this.extractionAttribute,
         };
     }

package/mablscript/actions/FindAction.js

@@ -112,6 +112,26 @@ class FindAction extends MablAction_1.MablAction {
     }
     static findActionFromStepArgs(stepArgs, suppliedFindType) {
         let findType;
+        if (stepArgs.find) {
+            findType = stepArgs.find.findType || 'find_one';
+            const findTarget = stepArgs.find.findTarget;
+            const findOptions = stepArgs.find.findOptions;
+            if (findType === 'find_one' && findTarget.selector) {
+                if (findTarget.auxiliaryDescriptors?.length) {
+                    const ancestors = findTarget.auxiliaryDescriptors.map((descriptor) => descriptor.selector);
+                    return new FindAction(findType, [
+                        [findTarget, ...ancestors],
+                        findOptions,
+                    ]);
+                }
+                return new FindAction(findType, [findTarget, findOptions]);
+            }
+            return new FindAction(findType, [
+                findTarget,
+                stepArgs.find.foundElementSelectors,
+                findOptions,
+            ]);
+        }
         if (stepArgs.selector) {
             if (suppliedFindType) {
                 findType = suppliedFindType;

package/mablscript/actions/GetVariableValue.js

@@ -11,13 +11,23 @@ class GetVariableValue extends MablAction_1.MablAction {
         if (typeof arg !== 'string') {
             throw new Error('Expected string argument');
         }
-        this.variable = MablSymbol_1.MablSymbol.fromString(arg);
+        const legacyPatternMatches = arg.match(MablSymbol_1.SINGLE_VARIABLE_PATTERN_REGEX);
+        if (legacyPatternMatches) {
+            this.variable = new MablSymbol_1.MablSymbol(legacyPatternMatches[1]);
+        }
+        else {
+            this.variable = new MablSymbol_1.MablSymbol(arg);
+        }
+    }
+    static buildAction(variable) {
+        const variableName = typeof variable === 'string' ? variable : variable.name;
+        return new GetVariableValue(GetVariableValue.actionCode, [variableName]);
     }
     toMablscript() {
         return `get_variable_value(${this.subVariable(this.variable.toString())})`;
     }
     toDescriptor() {
-        return (0, GetVariableDescriptor_1.newGetVariableDescriptor)(this.variable);
+        return { kind: GetVariableDescriptor_1.GET_VARIABLE_VALUE, variable: this.variable.name };
     }
     generateFindMablscript() {
         return `get_variable_value(${this.variable.name})`;
@@ -27,5 +37,6 @@ class GetVariableValue extends MablAction_1.MablAction {
     }
 }
 exports.GetVariableValue = GetVariableValue;
-GetVariableValue.mablScriptStepNames = ['get_variable_value'];
-GetVariableValue.yamlMablScriptNames = ['GetVariableValueAs'];
+GetVariableValue.actionCode = 'get_variable_value';
+GetVariableValue.mablScriptStepNames = [GetVariableValue.actionCode];
+GetVariableValue.yamlMablScriptNames = [GetVariableDescriptor_1.GET_VARIABLE_VALUE];

package/mablscript/actions/JavaScriptAction.js

@@ -109,58 +109,44 @@ class JavaScriptAction extends MablAction_1.MablAction {
         }
         throw new Error(`Invalid javascript action descriptor: ${JSON.stringify(descriptor)}`);
     }
-    toYaml() {
-        return JavaScriptAction.toYamlFromJavaScriptDescriptor(this.javaScript);
-    }
-    static toYamlFromJavaScriptDescriptor(javaScript) {
-        const actionYaml = {};
-        if ((0, SnippetsDescriptor_1.isReusableSnippetDescriptor)(javaScript)) {
-            actionYaml.snippetId = javaScript.snippetId;
-            actionYaml.snippetInvariantId = javaScript.snippetInvariantId;
-            actionYaml.parameterOverrides = javaScript.parameterOverrides;
-        }
-        else if ((0, SnippetsDescriptor_1.isInlineSnippetDescriptor)(javaScript)) {
-            actionYaml.snippet = { ...actionYaml, ...javaScript.inlineSnippet };
-            actionYaml.parameterOverrides = javaScript.parameterOverrides;
-        }
-        else if ((0, SnippetsDescriptor_1.isLegacyReusableSnippetDescriptor)(javaScript)) {
-            actionYaml.snippetId = javaScript.snippetInvariantId;
-        }
-        else if ((0, SnippetsDescriptor_1.isLegacyInlineJavaScriptDescriptor)(javaScript)) {
-            actionYaml.code = javaScript.encodedJS;
-        }
-        else {
-            throw new Error(`Cannot export action to yaml: ${JSON.stringify(javaScript)}`);
-        }
-        return actionYaml;
-    }
     static fromYaml(formatted) {
+        const jsDescriptor = formatted.javaScript ?? formatted;
         let snippetOptions;
-        if (formatted.parameterOverrides) {
+        if (jsDescriptor.parameterOverrides) {
             snippetOptions = {
-                parameter_overrides: formatted.parameterOverrides,
+                parameter_overrides: jsDescriptor.parameterOverrides,
             };
         }
         const args = [];
-        if (formatted.code) {
-            args.push(formatted.code);
+        if (jsDescriptor.code) {
+            args.push(jsDescriptor.code);
+        }
+        else if (jsDescriptor.encodedJS) {
+            args.push(jsDescriptor.encodedJS);
         }
-        else if (formatted.body) {
-            delete formatted.parameterOverrides;
-            args.push(formatted);
+        else if (jsDescriptor.body) {
+            args.push(jsDescriptor.body);
         }
-        else if (formatted.snippet) {
-            args.push(formatted.snippet);
+        else if (jsDescriptor.inlineSnippet) {
+            args.push(jsDescriptor.inlineSnippet);
+        }
+        else if (jsDescriptor.snippet) {
+            args.push(jsDescriptor.snippet);
+        }
+        else if (jsDescriptor.snippetInvariantId && jsDescriptor.snippetId) {
+            args.push({
+                id: jsDescriptor.snippetId,
+                invariant_id: jsDescriptor.snippetInvariantId,
+            });
         }
-        else if (formatted.snippetInvariantId && formatted.snippetId) {
+        else if (jsDescriptor.snippetInvariantId) {
             args.push({
-                id: formatted.snippetId,
-                invariant_id: formatted.snippetInvariantId,
+                id: jsDescriptor.snippetInvariantId,
             });
         }
-        else if (formatted.snippetId) {
+        else if (jsDescriptor.snippetId) {
             args.push({
-                id: formatted.snippetId,
+                id: jsDescriptor.snippetId,
             });
         }
         else {

package/mablscript/diffing/diffingUtil.js

@@ -62,7 +62,10 @@ function convertFlowToStepList(flow, flowConfig) {
             flow.flow_type === mablApi_1.FlowTypeEnum.Mobile)) {
         return parseFlowIntoStepList(flow);
     }
-    const evaluateFlowStep = new EvaluateFlowStep_1.EvaluateFlowStep(EvaluateFlowStep_1.EvaluateFlowStep.mablScriptStepNames[0], [{ invariant_id: flow?.invariant_id }, flowConfig], []);
+    const evaluateFlowStep = new EvaluateFlowStep_1.EvaluateFlowStep({
+        flow: { invariant_id: flow?.invariant_id ?? '' },
+        config: flowConfig,
+    });
     if (flow.description) {
         evaluateFlowStep.setDescription(flow.description);
     }
@@ -91,12 +94,9 @@ function convertStepListToFlow(steps, flowType = mablApi_1.FlowTypeEnum.Mablscri
         return annotations;
     }, {});
     const flow = {
-        json_steps: flowType === mablApi_1.FlowTypeEnum.Mobile
+        json_steps: flowType === mablApi_1.FlowTypeEnum.Mablscript || flowType === mablApi_1.FlowTypeEnum.Mobile
             ? { steps: steps.map((step) => step.getFormattedStep(true)) }
             : undefined,
-        script: flowType === mablApi_1.FlowTypeEnum.Mablscript
-            ? addTrailingNewline((0, importer_1.mablscriptTheLoadedSteps)(steps))
-            : undefined,
         script_description: steps.map(getStepDescription).join('\n'),
         step_annotations: stepAnnotations,
     };