@saltcorn/data 1.1.0-beta.8 → 1.1.0

package/dist/base-plugin/actions.js

@@ -20,7 +20,7 @@ const { get_async_expression_function, recalculate_for_stored, eval_expression,
 const { div, code, a, span } = require("@saltcorn/markup/tags");
 const { sleep, getSessionId, urlStringToObject, dollarizeObject, objectToQueryString, interpolate, } = require("../utils");
 const db = require("../db");
-const { isNode, isWeb, ppVal } = require("../utils");
+const { isNode, isWeb, ppVal, getFetchProxyOptions } = require("../utils");
 const { available_languages } = require("../models/config");
 //action use cases: field modify, like/rate (insert join), notify, send row to webhook
 // todo add translation
@@ -143,6 +143,7 @@ module.exports = {
     blocks: {
         disableInBuilder: true,
         disableInList: true,
+        disableInWorkflow: true,
         description: "Build action with drag and drop steps similar to Scratch",
         configFields: [
             {
@@ -212,34 +213,115 @@ module.exports = {
      */
     webhook: {
         description: "Make an outbound HTTP POST request",
-        configFields: [
-            {
-                name: "url",
-                label: "URL",
-                type: "String",
-                sublabel: "Trigger will call specified URL",
-            },
-            {
-                name: "body",
-                label: "JSON body",
-                sublabel: "Leave blank to use row from table",
-                type: "String",
-                fieldview: "textarea", // I think that textarea is better
-            },
-        ],
+        configFields: async ({ table, mode }) => {
+            let field_opts = [];
+            if (table) {
+                field_opts = table.fields
+                    .filter((f) => f.type && ["String", "HTML", "JSON"].includes(f.type.name))
+                    .map((f) => f.name);
+            }
+            return [
+                {
+                    name: "url",
+                    label: "URL",
+                    type: "String",
+                    sublabel: "Trigger will call specified URL",
+                },
+                {
+                    name: "method",
+                    label: "HTTP Method",
+                    type: "String",
+                    required: true,
+                    attributes: { options: "POST,GET,PUT,DELETE,PATCH" },
+                },
+                {
+                    name: "body",
+                    label: "JSON body",
+                    sublabel: "Leave blank to use row from table",
+                    type: "String",
+                    fieldview: "textarea",
+                    showIf: { method: ["POST", "PUT", "DELETE", "PATCH"] },
+                },
+                {
+                    name: "authorization",
+                    label: "Authorization header",
+                    type: "String",
+                    sublabel: "For example <code>Bearer xxxx</code>",
+                },
+                ...(field_opts.length
+                    ? [
+                        {
+                            name: "response_field",
+                            label: "Response into field",
+                            type: "String",
+                            attributes: { options: field_opts },
+                        },
+                    ]
+                    : []),
+                ...(mode === "workflow"
+                    ? [
+                        {
+                            name: "response_var",
+                            label: "Response variable",
+                            sublabel: "Variable in the context to fill with the response",
+                            type: "String",
+                        },
+                    ]
+                    : []),
+            ];
+        },
         /**
          * @param {object} opts
          * @param {string} opts.url
          * @param {object} opts.body
          * @returns {Promise<object>}
          */
-        run: async ({ row, user, configuration: { url, body } }) => {
+        run: async ({ row, user, table, configuration: { url, body, authorization, response_field, response_var, method, }, }) => {
             let url1 = interpolate(url, row, user);
-            return await fetch(url1, {
-                method: "post",
-                body: body || JSON.stringify(row),
+            const fetchOpts = {
+                method: (method || "post").toLowerCase(),
                 headers: { "Content-Type": "application/json" },
-            });
+                ...getFetchProxyOptions(),
+            };
+            if (method !== "GET") {
+                let postBody;
+                if (body && table) {
+                    const f = get_async_expression_function(body, table.fields, {
+                        row: row || {},
+                        user,
+                    });
+                    postBody = JSON.stringify(await f(row, user));
+                }
+                else if (body)
+                    postBody = body;
+                else
+                    postBody = JSON.stringify(row);
+                fetchOpts.body = postBody;
+            }
+            if (authorization)
+                fetchOpts.headers.Authorization = interpolate(authorization, row, user);
+            const response = await fetch(url1, fetchOpts);
+            const contentType = response.headers.get("content-type");
+            const isJSON = contentType && contentType.indexOf("application/json") !== -1;
+            if (response_var) {
+                const parsedResponse = isJSON
+                    ? await response.json()
+                    : await response.text();
+                return { [response_var]: parsedResponse };
+            }
+            else if (table && row && response_field) {
+                const field = table.getField(response_field);
+                const parsedResponse = isJSON
+                    ? await response.json()
+                    : await response.text();
+                const saveResponse = isJSON &&
+                    (field?.type?.name === "String" || field?.type?.sql_name === "text")
+                    ? JSON.stringify(parsedResponse)
+                    : parsedResponse;
+                await table.updateRow({ [response_field]: saveResponse }, row[table.pk_name]);
+            }
+            else
+                return;
         },
     },
     /**
@@ -317,7 +399,50 @@ module.exports = {
          * @returns {Promise<object[]>}
          */
         description: "Send an email, based on a chosen view for this table",
-        configFields: async ({ table }) => {
+        configFields: async ({ table, mode }) => {
+            if (mode === "workflow") {
+                return [
+                    {
+                        name: "to_email",
+                        label: "To",
+                        sublabel: "To addresses, comma separated, <code>{{ }}</code> interpolations usable",
+                        type: "String",
+                    },
+                    {
+                        name: "cc_email",
+                        label: "cc",
+                        sublabel: "cc addresses, comma separated, <code>{{ }}</code> interpolations usable",
+                        type: "String",
+                    },
+                    {
+                        name: "subject",
+                        label: "Subject",
+                        sublabel: "Subject of email, <code>{{ }}</code> interpolations usable",
+                        type: "String",
+                        required: true,
+                    },
+                    {
+                        name: "body",
+                        label: "Body",
+                        type: "String",
+                        fieldview: "textarea",
+                        required: true,
+                    },
+                    /*    {
+                      name: "attachment_paths",
+                      label: "Attachments",
+                      sublabel:
+                        "Comma-separated list of files to attach. <code>{{ }}</code> interpolations usable",
+                      type: "String",
+                    },*/
+                    {
+                        name: "confirm_field",
+                        label: "Send confirmation variable",
+                        type: "String",
+                        sublabel: "Bool variable set in context indicate successful sending of email message",
+                    },
+                ];
+            }
             if (!table)
                 return [];
             const views = await View.find_table_views_where(table, ({ viewtemplate }) => viewtemplate?.runMany || viewtemplate?.renderRows);
@@ -448,7 +573,24 @@ module.exports = {
          * @param {object} opts.user
          * @returns {Promise<object>}
          */
-        run: async ({ row, table, configuration: { body_type, body_field, viewname, subject, subject_formula, to_email, to_email_field, to_email_fixed, cc_email, only_if, attachment_path, disable_notify, confirm_field, }, user, }) => {
+        run: async ({ row, table, configuration: { body_type, body_field, viewname, subject, subject_formula, to_email, to_email_field, to_email_fixed, cc_email, only_if, attachment_path, disable_notify, confirm_field, body, }, user, mode, }) => {
+            const from = getState().getConfig("email_from");
+            if (mode === "workflow") {
+                const email = {
+                    from,
+                    to: interpolate(to_email, row, user),
+                    cc: interpolate(cc_email, row, user),
+                    subject: interpolate(subject, row, user),
+                    html: interpolate(body, row, user),
+                    //          attachments,
+                };
+                const sendres = await getMailTransport().sendMail(email);
+                getState().log(5, `send_email result: ${JSON.stringify(sendres)}`);
+                if (confirm_field)
+                    return { [confirm_field]: sendres.accepted.length > 0 };
+                else
+                    return;
+            }
             let to_addr;
             let useRow = row;
             const fvs = [
@@ -510,7 +652,6 @@ module.exports = {
                 const view = await View.findOne({ name: viewname });
                 setBody.html = await viewToEmailHtml(view, { id: row[table.pk_name] });
             }
-            const from = getState().getConfig("email_from");
             const attachments = await loadAttachments(attachment_path, row, user ? user : { role_id: 100 });
             const the_subject = subject_formula
                 ? eval_expression(subject, useRow, user, "send_email subject formula")
@@ -577,6 +718,7 @@ module.exports = {
                 },
             ];
         },
+        disableInWorkflow: true,
         requireRow: true,
         /**
          * @param {object} opts
@@ -617,6 +759,7 @@ module.exports = {
          */
         description: "Duplicate the current row",
         configFields: () => [],
+        disableInWorkflow: true,
         requireRow: true,
         /**
          * @param {object} opts
@@ -709,7 +852,7 @@ module.exports = {
          * @returns {Promise<object[]>}
          */
         description: "insert a row into any table, using a formula expression",
-        configFields: async ({ table }) => {
+        configFields: async ({ mode }) => {
             const tables = await Table.find({}, { cached: true });
             return [
                 {
@@ -726,6 +869,16 @@ module.exports = {
                     type: "String",
                     fieldview: "textarea",
                 },
+                ...(mode === "workflow"
+                    ? [
+                        {
+                            name: "id_variable",
+                            label: "ID variable",
+                            sublabel: "Variable in the context to fill with the created ID value",
+                            type: "String",
+                        },
+                    ]
+                    : []),
             ];
         },
         /**
@@ -739,7 +892,7 @@ module.exports = {
          */
         run: async ({ row, table, configuration, user, referrer, ...rest }) => {
             const state = urlStringToObject(referrer);
-            const f = get_async_expression_function(configuration.row_expr, table?.fields || [], {
+            const f = get_async_expression_function(configuration.row_expr, table?.fields || Object.keys(row).map((k) => ({ name: k })), {
                 user,
                 console,
                 session_id: rest.req && getSessionId(rest.req),
@@ -750,6 +903,8 @@ module.exports = {
             const res = await table_for_insert.tryInsertRow(calcrow, user);
             if (res.error)
                 return res;
+            else if (configuration.id_variable)
+                return { [configuration.id_variable]: res.success };
             else
                 return true;
         },
@@ -761,11 +916,6 @@ module.exports = {
      * @subcategory actions
      */
     modify_row: {
-        /**
-         * @param {object} opts
-         * @param {*} opts.table
-         * @returns {Promise<object[]>}
-         */
         description: "Modify the triggering row",
         configFields: async ({ mode, when_trigger }) => {
             return [
@@ -776,7 +926,10 @@ module.exports = {
                     input_type: "code",
                     attributes: { mode: "application/javascript" },
                 },
-                ...(mode === "edit" || mode === "filter" || when_trigger === "Validate"
+                ...(mode === "edit" ||
+                    mode === "filter" ||
+                    when_trigger === "Validate" ||
+                    mode === "workflow"
                     ? [
                         {
                             name: "where",
@@ -788,22 +941,59 @@ module.exports = {
                                     ? ["Row"]
                                     : mode === "filter"
                                         ? ["Filter state"]
-                                        : ["Form", "Database"],
+                                        : mode === "workflow"
+                                            ? ["Database", "Active edit view"]
+                                            : ["Form", "Database"],
                             },
                         },
                     ]
                     : []),
+                ...(mode === "workflow"
+                    ? [
+                        {
+                            name: "select_table",
+                            label: "Table",
+                            type: "String",
+                            required: true,
+                            attributes: {
+                                options: (await Table.find()).map((t) => t.name),
+                                showIf: { where: "Database" },
+                            },
+                        },
+                        {
+                            name: "query",
+                            label: "Query object",
+                            type: "String",
+                            required: true,
+                            showIf: { where: "Database" },
+                        },
+                    ]
+                    : []),
             ];
         },
         requireRow: true,
-        run: async ({ row, table, configuration: { row_expr, where }, user, ...rest }) => {
-            const f = get_async_expression_function(row_expr, table.fields, {
+        run: async ({ row, table, configuration: { row_expr, where, select_table, query }, user, ...rest }) => {
+            const f = get_async_expression_function(row_expr, table?.fields || Object.keys(row).map((k) => ({ name: k })), {
                 row: row || {},
                 user,
             });
             const calcrow = await f(row, user);
-            if (where === "Form" || where === "Filter state" || where === "Row")
+            if (where === "Form" ||
+                where === "Filter state" ||
+                where === "Row" ||
+                where === "Active edit view")
                 return { set_fields: calcrow };
+            if (select_table && query) {
+                //get table
+                const table = Table.findOne(select_table);
+                // evaluate query
+                const q = eval_expression(query, row, user, "Query expression in modify_row step");
+                const rows = await table.getRows(q);
+                for (const row of rows) {
+                    await table.updateRow(calcrow, row[table.pk_name]);
+                }
+                return;
+            }
             const res = await table.tryUpdateRow(calcrow, row[table.pk_name], user);
             if (res.error)
                 return res;
@@ -822,11 +1012,15 @@ module.exports = {
         configFields: async ({ mode, when_trigger }) => {
             const tables = await Table.find({}, { cached: true });
             return [
-                {
-                    name: "delete_triggering_row",
-                    label: "Delete triggering row",
-                    type: "Bool",
-                },
+                ...(mode === "workflow"
+                    ? []
+                    : [
+                        {
+                            name: "delete_triggering_row",
+                            label: "Delete triggering row",
+                            type: "Bool",
+                        },
+                    ]),
                 {
                     name: "table_name",
                     label: "Table",
@@ -905,7 +1099,11 @@ module.exports = {
                 case "Popup modal":
                     return { popup: url1 };
                 case "Back":
-                    return { eval_js: isWeb(req) ? "history.back()" : "parent.goBack()" };
+                    return {
+                        eval_js: isWeb(req)
+                            ? "history.back()"
+                            : "parent.saltcorn.mobileApp.navigation.goBack()",
+                    };
                 case "Close tab":
                     return { eval_js: "window.close()" };
                 case "Close modal":
@@ -925,6 +1123,7 @@ module.exports = {
          * @returns {Promise<object[]>}
          */
         description: "Step control flow",
+        disableInWorkflow: true,
         configFields: [
             {
                 name: "control_action",
@@ -1115,6 +1314,7 @@ module.exports = {
                         topic: "JavaScript action code",
                     },
                     showIf: { run_where: "Server" },
+                    attributes: { secondColHoriz: true },
                 },
                 {
                     input_type: "section_header",
@@ -1124,6 +1324,7 @@ module.exports = {
                         topic: "JavaScript action code",
                     },
                     showIf: { run_where: "Client page" },
+                    attributes: { secondColHoriz: true },
                 },
                 {
                     name: "run_where",
@@ -1147,7 +1348,23 @@ module.exports = {
          * @returns {Promise<object[]>}
          */
         description: "Run arbitrary JavaScript code from a String field",
-        configFields: async ({ table }) => {
+        configFields: async ({ table, mode }) => {
+            if (mode === "workflow")
+                return [
+                    {
+                        name: "code_field",
+                        label: "Code field",
+                        sublabel: "String variable in context contains the JavaScript code to run",
+                        type: "String",
+                        required: true,
+                    },
+                    {
+                        name: "run_where",
+                        label: "Run where",
+                        input_type: "select",
+                        options: ["Server", "Client page"],
+                    },
+                ];
             const field_opts = table.fields
                 .filter((f) => f.type?.name === "String")
                 .map((f) => f.name);
@@ -1185,7 +1402,7 @@ module.exports = {
          * @type {base-plugin/actions~run_code}
          * @see base-plugin/actions~run_code
          **/
-        run: async ({ table, configuration: { code_field, run_where }, row, ...rest }) => {
+        run: async ({ table, configuration: { code_field, run_where }, row, mode, ...rest }) => {
             let code;
             if (code_field.includes(".")) {
                 const [ref, target] = code_field.split(".");
@@ -1232,6 +1449,7 @@ module.exports = {
                 ...fldOpts,
             ];
         },
+        disableInWorkflow: true,
         requireRow: true,
         run: async ({ row, table, configuration: { viewname, ...flds }, user }) => {
             const qs = Object.entries(flds)
@@ -1310,14 +1528,18 @@ module.exports = {
                     label: "Source table",
                     sublabel: "External table to sync from",
                     input_type: "select",
-                    options: tables.filter((t) => t.external || t.provider_name).map((t) => t.name),
+                    options: tables
+                        .filter((t) => t.external || t.provider_name)
+                        .map((t) => t.name),
                 },
                 {
                     name: "table_dest",
                     label: "Destination table",
                     sublabel: "Table to sync to",
                     input_type: "select",
-                    options: tables.filter((t) => !(t.external || t.provider_name)).map((t) => t.name),
+                    options: tables
+                        .filter((t) => !(t.external || t.provider_name))
+                        .map((t) => t.name),
                 },
                 {
                     name: "pk_field",