@mablhq/mabl-cli 2.72.4 → 2.72.12

package/mablscript/steps/CreateVariableStep.js

@@ -9,188 +9,161 @@ const FindAction_1 = require("../actions/FindAction");
 const GenerateEmailAddressAction_1 = require("../actions/GenerateEmailAddressAction");
 const GenerateRandomStringAction_1 = require("../actions/GenerateRandomStringAction");
 const JavaScriptAction_1 = require("../actions/JavaScriptAction");
-const MablStep_1 = require("../MablStep");
+const MablStepV2_1 = require("../MablStepV2");
 const CreateVariableStepDescriptor_1 = require("../types/CreateVariableStepDescriptor");
-class CreateVariableStep extends MablStep_1.MablStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'as');
-        this.variableName = this.getActionArgs()[0];
-        this.generationType = this.calculateGenerationType();
+class CreateVariableStep extends MablStepV2_1.MablStepV2 {
+    constructor(descriptor) {
+        super(CreateVariableStep.stepName, descriptor, CreateVariableStep.actionCode);
+        this.variableName = descriptor.name;
+        this.generationType = descriptor.generator.type;
+        this.actions = this.buildActions(descriptor);
     }
     getStepName() {
         return CreateVariableStep.stepName;
     }
-    calculateGenerationType() {
-        if (this.actions.length === 2 && this.actions[0] instanceof FindAction_1.FindAction) {
-            if (this.actions[0].findDescriptor.findType === domUtil_1.FindType.FIND_COOKIE) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE;
-            }
-            if (this.actions[1] instanceof ExtractAction_1.ExtractAction) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE;
-            }
-            else if (this.actions[1] instanceof CountAction_1.CountAction) {
-                return CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT;
-            }
-        }
-        else if (this.actions.length === 1 &&
-            this.actions[0] instanceof GenerateEmailAddressAction_1.GenerateEmailAddressAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.EMAIL;
-        }
-        else if (this.actions.length === 1 &&
-            this.actions[0] instanceof JavaScriptAction_1.JavaScriptAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT;
-        }
-        else if (this.actions.length === 1 &&
-            this.actions[0] instanceof GenerateRandomStringAction_1.GenerateRandomStringAction) {
-            return CreateVariableStepDescriptor_1.VariableGenerator.PATTERN;
-        }
-        throw new Error('Unsupported variable generation type');
-    }
     toStepDescriptor() {
-        let step;
-        switch (this.generationType) {
-            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                const cookieFindAction = this.actions[0];
-                const cookieFind = cookieFindAction.toDescriptor();
-                step = {
-                    name: this.variableName,
-                    generator: {
-                        type: CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE,
-                        cookieSelector: cookieFind.findTarget,
-                        attribute: this.actions[1].extractionAttribute,
-                    },
-                    find: cookieFind,
-                    descriptorToActionMap: new Map().set(cookieFind, cookieFindAction),
-                    actionCode: this.actionCode,
-                };
-                break;
+        return CreateVariableStep.buildStepDescriptor(this.variableName, this.generationType, this.actions);
+    }
+    static buildStepDescriptor(variableName, generationType, actions) {
+        switch (generationType) {
             case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                const findAction = this.actions[0];
+                const findAction = actions[0];
+                const extractAction = actions[1];
                 const find = findAction.toDescriptor();
-                step = {
-                    name: this.variableName,
+                return {
+                    name: variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE,
-                        attribute: this.actions[1].extractionAttribute,
+                        attribute: extractAction.extractionAttribute,
                         find,
                     },
                     find,
-                    descriptorToActionMap: new Map().set(find, findAction),
-                    actionCode: this.actionCode,
+                    descriptorToActionMap: new Map([[find, findAction]]),
+                    actionCode: CreateVariableStep.actionCode,
+                };
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                const countFindAction = actions[0];
+                const countFind = countFindAction.toDescriptor();
+                return {
+                    find: countFind,
+                    name: variableName,
+                    generator: {
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT,
+                        find: countFind,
+                    },
+                    descriptorToActionMap: new Map([[countFind, countFindAction]]),
+                    actionCode: CreateVariableStep.actionCode,
                 };
-                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
-                step = {
-                    name: this.variableName,
+                return {
+                    name: variableName,
                     generator: { type: CreateVariableStepDescriptor_1.VariableGenerator.EMAIL },
-                    actionCode: this.actionCode,
+                    actionCode: CreateVariableStep.actionCode,
                 };
-                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
-                step = {
-                    name: this.variableName,
+                const jsAction = actions[0];
+                return {
+                    name: variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
-                        javaScript: this.actions[0].javaScript,
+                        javaScript: jsAction.toDescriptor().javaScript,
                     },
-                    actionCode: this.actionCode,
+                    actionCode: CreateVariableStep.actionCode,
                 };
-                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
-                step = {
-                    name: this.variableName,
+                const patternAction = actions[0];
+                return {
+                    name: variableName,
                     generator: {
                         type: CreateVariableStepDescriptor_1.VariableGenerator.PATTERN,
-                        pattern: this.actions[0]
-                            .generateString,
+                        pattern: patternAction.generateString,
                     },
-                    actionCode: this.actionCode,
+                    actionCode: CreateVariableStep.actionCode,
                 };
-                break;
-            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                const countFindAction = this.actions[0];
-                const countFind = countFindAction.toDescriptor();
-                step = {
-                    find: countFind,
-                    name: this.variableName,
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                const cookieFindAction = actions[0];
+                const cookieExtractAction = actions[1];
+                const cookieFind = cookieFindAction.toDescriptor();
+                return {
+                    name: variableName,
                     generator: {
-                        type: CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT,
-                        find: countFind,
+                        type: CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE,
+                        cookieSelector: cookieFind.findTarget,
+                        attribute: cookieExtractAction.extractionAttribute,
                     },
-                    descriptorToActionMap: new Map().set(countFind, countFindAction),
-                    actionCode: this.actionCode,
+                    find: cookieFind,
+                    descriptorToActionMap: new Map([[cookieFind, cookieFindAction]]),
+                    actionCode: CreateVariableStep.actionCode,
                 };
-                break;
+            default:
+                throw new Error(`Unsupported variable generation type: ${generationType}`);
         }
-        return step;
     }
-    getFormattedStep() {
-        const step = this.toStepDescriptor();
-        const stepName = this.getStepName();
-        const formatted = {
-            [stepName]: {},
-        };
-        if (this.annotationsOnStep()) {
-            formatted[stepName].annotation = this.annotation;
-        }
-        if (this.description) {
-            formatted[stepName].description = this.description;
-        }
-        switch (step.generator.type) {
+    buildActions(descriptor) {
+        const actions = [];
+        switch (descriptor.generator.type) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                if ('find' in descriptor) {
+                    const attrGenerator = descriptor.generator;
+                    actions.push(FindAction_1.FindAction.findActionFromStepArgs(descriptor));
+                    actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [attrGenerator.attribute]));
+                }
+                break;
             case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                formatted[stepName] = {
-                    ...formatted[stepName],
-                    generator: step.generator,
-                    name: this.variableName,
-                    selector: step.generator.find.findTarget,
-                };
+                if ('find' in descriptor) {
+                    const findDescriptor = descriptor.find;
+                    actions.push(new FindAction_1.FindAction('find_all', [
+                        findDescriptor.findTarget,
+                        findDescriptor.foundElementSelectors,
+                        findDescriptor.findOptions,
+                    ]));
+                    actions.push(new CountAction_1.CountAction('count', []));
+                }
                 break;
-            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                formatted[stepName] = {
-                    ...formatted[stepName],
-                    generator: step.generator,
-                    name: this.variableName,
-                    selector: step.generator.find.findTarget.selector,
-                    selectorAncestors: (step.generator.find.findTarget.auxiliaryDescriptors ?? []).map((descriptor) => descriptor.selector),
-                };
+            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
+                actions.push(new GenerateEmailAddressAction_1.GenerateEmailAddressAction('generate_email_address', []));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
-                formatted[stepName] = {
-                    ...formatted[stepName],
-                    generator: {
-                        type: CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT,
-                        javaScript: this.actions[0].toYaml(),
-                    },
-                    name: this.variableName,
-                };
+                const jsGenerator = descriptor.generator;
+                actions.push(JavaScriptAction_1.JavaScriptAction.fromDescriptor({
+                    javaScript: jsGenerator.javaScript,
+                }));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
+                const patternGenerator = descriptor.generator;
+                actions.push(new GenerateRandomStringAction_1.GenerateRandomStringAction('generate_random_string', [
+                    patternGenerator.pattern,
+                ]));
+                break;
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                if ('find' in descriptor) {
+                    const cookieGenerator = descriptor.generator;
+                    actions.push(new FindAction_1.FindAction('find_cookie', [cookieGenerator.cookieSelector]));
+                    actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [cookieGenerator.attribute]));
+                }
                 break;
             default:
-                formatted[stepName] = {
-                    ...formatted[stepName],
-                    generator: step.generator,
-                    name: this.variableName,
-                };
-        }
-        if (this.stepId()) {
-            formatted[stepName].id = this.stepId();
+                throw new Error(`Unsupported variable generation type: ${descriptor.generator.type}`);
         }
-        return formatted;
+        return actions;
     }
     static fromYaml(_stepName, stepArgs) {
         const variableName = stepArgs.name;
-        const generator = stepArgs.generator;
+        const generator = stepArgs.generator ?? {};
         const generationType = generator.type;
         const actions = [];
         switch (generationType) {
             case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
-                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs));
+                const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+                actions.push(findAction);
                 const extractArgs = generator.metadata
                     ? [generator.attribute, generator.metadata]
                     : [generator.attribute];
                 actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractArgs));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
-                actions.push(FindAction_1.FindAction.findActionFromStepArgs(stepArgs, domUtil_1.FindType.FIND_ALL));
+                const countFindAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs, domUtil_1.FindType.FIND_ALL);
+                actions.push(countFindAction);
                 actions.push(new CountAction_1.CountAction('count', []));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
@@ -205,29 +178,88 @@ class CreateVariableStep extends MablStep_1.MablStep {
                 ]));
                 break;
             case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
-                actions.push(new FindAction_1.FindAction('find_cookie', [generator.cookieSelector]));
-                const extractCookieArgs = [generator.attribute];
-                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', extractCookieArgs));
+                const cookieFindAction = new FindAction_1.FindAction('find_cookie', [
+                    generator.cookieSelector,
+                ]);
+                actions.push(cookieFindAction);
+                actions.push(new ExtractAction_1.ExtractAction('extract_attribute', [generator.attribute]));
                 break;
+            default:
+                throw new Error(`Unsupported variable generation type: ${generationType}`);
         }
-        const step = new CreateVariableStep('as', [variableName], actions);
+        const stepDescriptor = CreateVariableStep.buildStepDescriptor(variableName, generationType, actions);
+        const step = new CreateVariableStep(stepDescriptor);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, actions) {
+        const variableName = args[0];
+        const generationType = CreateVariableStep.calculateGenerationType(actions);
+        const stepDescriptor = CreateVariableStep.buildStepDescriptor(variableName, generationType, actions);
+        const step = new CreateVariableStep(stepDescriptor);
+        return step;
+    }
+    static calculateGenerationType(actions) {
+        if (actions.length === 2 && actions[0] instanceof FindAction_1.FindAction) {
+            if (actions[0].findDescriptor.findType === domUtil_1.FindType.FIND_COOKIE) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE;
+            }
+            if (actions[1] instanceof ExtractAction_1.ExtractAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE;
+            }
+            else if (actions[1] instanceof CountAction_1.CountAction) {
+                return CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT;
+            }
+        }
+        else if (actions.length === 1 &&
+            actions[0] instanceof GenerateEmailAddressAction_1.GenerateEmailAddressAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.EMAIL;
+        }
+        else if (actions.length === 1 && actions[0] instanceof JavaScriptAction_1.JavaScriptAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT;
+        }
+        else if (actions.length === 1 &&
+            actions[0] instanceof GenerateRandomStringAction_1.GenerateRandomStringAction) {
+            return CreateVariableStepDescriptor_1.VariableGenerator.PATTERN;
+        }
+        throw new Error('Unsupported variable generation type');
+    }
     toMablscript() {
         return `${this.actions.reduce((mablscript, action) => `${mablscript}${action.toMablscript()}.`, '')}as("${this.variableName}")`;
     }
     getInputVariables() {
-        return this.actions[0].getInputVariables();
+        return this.actions.length > 0 ? this.actions[0].getInputVariables() : [];
     }
     getOutputVariables() {
         return [this.variableName];
     }
+    stepDescription() {
+        switch (this.generationType) {
+            case CreateVariableStepDescriptor_1.VariableGenerator.EMAIL:
+                return `Generate email address for variable "${this.variableName}"`;
+            case CreateVariableStepDescriptor_1.VariableGenerator.JAVASCRIPT:
+                return `Execute JavaScript to create variable "${this.variableName}"`;
+            case CreateVariableStepDescriptor_1.VariableGenerator.PATTERN:
+                return `Generate random string for variable "${this.variableName}"`;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ATTRIBUTE:
+                return `Extract attribute value to variable "${this.variableName}"`;
+            case CreateVariableStepDescriptor_1.VariableGenerator.COOKIE_ATTRIBUTE:
+                return `Extract cookie attribute to variable "${this.variableName}"`;
+            case CreateVariableStepDescriptor_1.VariableGenerator.ELEMENT_COUNT:
+                return `Count elements and store in variable "${this.variableName}"`;
+            default:
+                return `Create variable "${this.variableName}"`;
+        }
+    }
 }
 exports.CreateVariableStep = CreateVariableStep;
 CreateVariableStep.stepName = 'CreateVariable';
-CreateVariableStep.mablScriptStepNames = ['as'];
-CreateVariableStep.yamlMablScriptNames = ['CreateVariable', 'GenerateEmailAddress'];
+CreateVariableStep.actionCode = 'as';
+CreateVariableStep.mablScriptStepNames = [CreateVariableStep.actionCode];
+CreateVariableStep.yamlMablScriptNames = [
+    CreateVariableStep.stepName,
+    'GenerateEmailAddress',
+];
 function isCreateVariableStep(value) {
     return (value?.getStepName &&
         value.getStepName() === CreateVariableStep.stepName &&

package/mablscript/steps/DatabaseQueryStep.js

@@ -4,19 +4,31 @@ exports.DatabaseQueryVariableSource = exports.DatabaseQueryStep = void 0;
 exports.isDatabaseQueryStep = isDatabaseQueryStep;
 const AbstractAssertionsAndVariablesStep_1 = require("./AbstractAssertionsAndVariablesStep");
 class DatabaseQueryStep extends AbstractAssertionsAndVariablesStep_1.AbstractAssertionsAndVariablesStep {
-    constructor(name, args, actions) {
-        super(name, args, actions, DatabaseQueryStep.mablScriptStepNames[0], DatabaseQueryStep.stepName, args[0]);
+    constructor(descriptor) {
+        super(DatabaseQueryStep.stepName, descriptor, DatabaseQueryStep.actionCode);
     }
     static fromYaml(_stepName, stepArgs) {
         const formatted = stepArgs;
-        const step = new DatabaseQueryStep(DatabaseQueryStep.stepName, [formatted], []);
+        const step = new DatabaseQueryStep(formatted);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(args, _actions) {
+        if (args.length !== 1) {
+            throw new Error(`DatabaseQueryStep fromLegacyMablscript expects 1 argument, got ${args.length}`);
+        }
+        const step = new DatabaseQueryStep(args[0]);
+        step.actions = _actions;
+        return step;
+    }
+    stepDescription() {
+        return `Database query execution`;
+    }
 }
 exports.DatabaseQueryStep = DatabaseQueryStep;
 DatabaseQueryStep.stepName = 'DatabaseQuery';
-DatabaseQueryStep.mablScriptStepNames = ['database_query'];
+DatabaseQueryStep.actionCode = 'database_query';
+DatabaseQueryStep.mablScriptStepNames = [DatabaseQueryStep.actionCode];
 DatabaseQueryStep.yamlMablScriptNames = [DatabaseQueryStep.stepName];
 var DatabaseQueryVariableSource;
 (function (DatabaseQueryVariableSource) {

package/mablscript/steps/DoubleClickStep.js

@@ -3,62 +3,61 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DoubleClickStep = void 0;
 const FindAction_1 = require("../actions/FindAction");
 const domUtil_1 = require("../../domUtil");
+const ActionsUtils_1 = require("./ActionsUtils");
 const MablStepWithFindAction_1 = require("../MablStepWithFindAction");
 class DoubleClickStep extends MablStepWithFindAction_1.MablStepWithFindAction {
-    constructor(name, args, actions) {
-        super(name, args, actions, 'double_click');
-        this.validate();
-        this.findAction = this.actions[0];
-    }
-    validate() {
-        if (this.actions.length !== 1 && !(this.actions[0] instanceof FindAction_1.FindAction)) {
-            throw new Error('Double click steps should have exactly on sub action and it should be a find');
-        }
+    constructor(descriptor, findAction) {
+        super(DoubleClickStep.stepName, descriptor, DoubleClickStep.actionCode, findAction);
     }
     getStepName() {
-        return 'DoubleClick';
+        return DoubleClickStep.stepName;
     }
     toStepDescriptor() {
-        const find = this.findAction.toDescriptor();
-        switch (find.findType) {
-            case domUtil_1.FindType.FIND_FIRST:
-            case domUtil_1.FindType.FIND_LAST:
-            case domUtil_1.FindType.FIND_ANY:
-            case domUtil_1.FindType.FIND_ALL:
-            case domUtil_1.FindType.FIND_ONE:
-                return {
-                    find,
-                    descriptorToActionMap: new Map().set(find, this.findAction),
-                    actionCode: this.actionCode,
-                };
-            default:
-                throw new Error(`Error generating step descriptor for ${this.getStepName()}: Unexpected find type ${find.findType}`);
-        }
-    }
-    getFormattedStep(_fullLocatorsOn) {
-        const step = {
-            DoubleClick: {
-                ...super.annotationsAsYml(),
-                ...this.findAction.toYaml(),
-            },
-        };
-        if (this.stepId()) {
-            step.DoubleClick.id = this.stepId();
-        }
-        return step;
+        return buildStepDescriptor(this.findAction);
     }
     static fromYaml(_stepName, stepArgs) {
-        const step = new DoubleClickStep('double_click', [], [FindAction_1.FindAction.findActionFromStepArgs(stepArgs)]);
+        const findAction = FindAction_1.FindAction.findActionFromStepArgs(stepArgs);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new DoubleClickStep(stepDescriptor, findAction);
         step.setStepId(stepArgs.id);
         return step;
     }
+    static fromLegacyMablscript(_args, actions) {
+        const findAction = ActionsUtils_1.ActionsUtils.validateSingleFindAction(actions);
+        const stepDescriptor = buildStepDescriptor(findAction);
+        const step = new DoubleClickStep(stepDescriptor, findAction);
+        step.actions = actions;
+        return step;
+    }
     toMablscript() {
         return `${this.findAction.toMablscript()}.double_click()`;
     }
     getInputVariables() {
         return this.findAction.getInputVariables();
     }
+    stepDescription() {
+        const elementDescription = this.humanizeFind();
+        return `Double click on ${elementDescription}`;
+    }
 }
 exports.DoubleClickStep = DoubleClickStep;
-DoubleClickStep.mablScriptStepNames = ['double_click'];
-DoubleClickStep.yamlMablScriptNames = ['DoubleClick'];
+DoubleClickStep.stepName = 'DoubleClick';
+DoubleClickStep.actionCode = 'double_click';
+DoubleClickStep.mablScriptStepNames = [DoubleClickStep.actionCode];
+DoubleClickStep.yamlMablScriptNames = [DoubleClickStep.stepName];
+function buildStepDescriptor(findAction) {
+    const find = findAction.toDescriptor();
+    switch (find.findType) {
+        case domUtil_1.FindType.FIND_FIRST:
+        case domUtil_1.FindType.FIND_LAST:
+        case domUtil_1.FindType.FIND_ANY:
+        case domUtil_1.FindType.FIND_ONE:
+            return {
+                find,
+                descriptorToActionMap: new Map().set(find, findAction),
+                actionCode: DoubleClickStep.actionCode,
+            };
+        default:
+            throw new Error(`Error generating step descriptor for ${DoubleClickStep.stepName}: Unexpected find type ${find.findType}`);
+    }
+}