@saltcorn/server 1.1.0-beta.13 → 1.1.0-beta.14

package/locales/en.json

@@ -1498,6 +1498,17 @@
 	"Pulling the capacitor-builder docker image...": "Pulling the capacitor-builder docker image...",
 	"Pull done with code %s": "Pull done with code %s",
 	"Default locale": "Default locale",
+	"Next step": "Next step",
+	"Step name": "Step name",
+	"Step saved": "Step saved",
+	"Initial step": "Initial step",
 	"Confirm leaving unsaved": "Confirm leaving unsaved",
-	"Ask the user to confirm if they close a tab with unsaved changes": "Ask the user to confirm if they close a tab with unsaved changes"
+	"Ask the user to confirm if they close a tab with unsaved changes": "Ask the user to confirm if they close a tab with unsaved changes",
+	"Workflow runs": "Workflow runs",
+	"Workflow run": "Workflow run",
+	"Share to enabled": "Share to enabled",
+	"Enable the share to feature": "Enable the share to feature",
+	"Allocate new row": "Allocate new row",
+	"If the view is run without existing row, allocate a new row on load. Defaults must be set on all required fields.": "If the view is run without existing row, allocate a new row on load. Defaults must be set on all required fields.",
+	"Step traces": "Step traces"
 }

package/locales/pl.json

@@ -57,7 +57,7 @@
   "If you did not request this, please ignore this email.": "Jeżeli nie żądałeś tego, nie klikaj w poniższy link.",
   "Your password will not change until you access the link above and set a new one.": "Twoje hasło nie ulegnie zmianie dopóki nie klikniesz w powyższy link i nie ustawisz nowego hasła.",
   "Change my password": "Zmień moje hasło",
-  "Must be admin": "Musi być adminem",
+  "Must be admin": "Musisz być adminem",
   "Site identity": "Tożsamość strony",
   "Authentication": "Uwierzytelnianie",
   "Development": "Development",
@@ -1491,5 +1491,22 @@
 	"Login and signup views should be accessible by public users": "Widoki logowania i rejestracji powinny być dostępne dla użytkowników publicznych",
 	"Shared: %s": "Udostępnione: %s",
 	"Sharing not enabled": "Udostępnianie nie jest włączone",
-	"You must be logged in to share": "Musisz być zalogowany, aby udostępniać"
+	"You must be logged in to share": "Musisz być zalogowany, aby udostępniać",
+	"Fluid layout": "Układ elastyczny",
+	"Request fluid layout from theme for a wider display for this page": "Poproś o elastyczny układ z motywu, aby zapewnić szerszy widok dla tej strony",
+	"Location of view to create new row": "Lokalizacja widoku do utworzenia nowego wiersza",
+	"Capacitor builder": "Capacitor builder",
+	"Pulling the capacitor-builder docker image...": "Pobieranie obrazu Docker capacitor-builder...",
+	"Pull done with code %s": "Pobieranie zakończone z kodem %s",
+	"Default locale": "Domyślny język/region",
+	"Next step": "Następny krok",
+	"Step name": "Nazwa kroku",
+	"Step saved": "Krok zapisany",
+	"Initial step": "Początkowy krok",
+	"Confirm leaving unsaved": "Potwierdzenie opuszczenia bez zapisania",
+	"Ask the user to confirm if they close a tab with unsaved changes": "Poproś użytkownika o potwierdzenie, czy chce zamknąć kartę z niezapisanymi zmianami",
+	"Workflow runs": "Przepływ pracy jest uruchomiony",
+	"Workflow run": "Uruchomienie przepływu pracy",
+	"Share to enabled": "Udostępnij włączone",
+	"Enable the share to feature": "Włącz udostępnianie funkcji"
 }

package/markup/admin.js

@@ -310,6 +310,7 @@ const send_events_page = (args) => {
       { text: "Custom", href: "/eventlog/custom" },
       { text: "Settings", href: "/eventlog/settings" },
       { text: "Event log", href: "/eventlog" },
+      { text: "Workflow runs", href: "/actions/runs" },
       ...(isRoot ? [{ text: "Crash log", href: "/crashlog" }] : []),
     ],
     ...args,

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@saltcorn/server",
-  "version": "1.1.0-beta.13",
+  "version": "1.1.0-beta.14",
   "description": "Server app for Saltcorn, open-source no-code platform",
   "homepage": "https://saltcorn.com",
   "main": "index.js",
   "license": "MIT",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.451.0",
-    "@saltcorn/base-plugin": "1.1.0-beta.13",
-    "@saltcorn/builder": "1.1.0-beta.13",
-    "@saltcorn/data": "1.1.0-beta.13",
-    "@saltcorn/admin-models": "1.1.0-beta.13",
-    "@saltcorn/filemanager": "1.1.0-beta.13",
-    "@saltcorn/markup": "1.1.0-beta.13",
-    "@saltcorn/plugins-loader": "1.1.0-beta.13",
-    "@saltcorn/sbadmin2": "1.1.0-beta.13",
+    "@saltcorn/base-plugin": "1.1.0-beta.14",
+    "@saltcorn/builder": "1.1.0-beta.14",
+    "@saltcorn/data": "1.1.0-beta.14",
+    "@saltcorn/admin-models": "1.1.0-beta.14",
+    "@saltcorn/filemanager": "1.1.0-beta.14",
+    "@saltcorn/markup": "1.1.0-beta.14",
+    "@saltcorn/plugins-loader": "1.1.0-beta.14",
+    "@saltcorn/sbadmin2": "1.1.0-beta.14",
     "@socket.io/cluster-adapter": "^0.2.1",
     "@socket.io/sticky": "^1.0.1",
     "adm-zip": "0.5.10",

package/public/saltcorn-common.js

@@ -40,6 +40,19 @@ $(window).resize(() => {
   setScreenInfoCookie();
 });
 
+function get_current_state_url(e) {
+  const localizer = e ? $(e).closest("[data-sc-local-state]") : [];
+  let $modal = $("#scmodal");
+  if (localizer.length) {
+    const localState = localizer.attr("data-sc-local-state") || "";
+    return localState;
+  } else if ($modal.length === 0 || !$modal.hasClass("show"))
+    return getIsNode()
+      ? window.location.href
+      : parent.saltcorn.mobileApp.navigation.currentUrl();
+  else return $modal.prop("data-modal-state");
+}
+
 //avoids hiding in overflow:hidden
 function init_bs5_dropdowns() {
   $("body").on(
@@ -704,7 +717,7 @@ function doMobileTransforms() {
     href: [
       {
         web: "javascript:history.back()",
-        mobile: "javascript:parent.goBack()",
+        mobile: "javascript:parent.saltcorn.mobileApp.navigation.goBack()",
       },
       {
         web: "javascript:ajax_modal",
@@ -714,7 +727,7 @@ function doMobileTransforms() {
     onclick: [
       {
         web: "history.back()",
-        mobile: "parent.goBack()",
+        mobile: "parent.saltcorn.mobileApp.navigation.goBack()",
       },
       {
         web: "ajax_modal",
@@ -823,48 +836,46 @@ function doMobileTransforms() {
   });
 
   $("[mobile-img-path]").each(async function () {
-    if (parent.loadEncodedFile) {
-      const fileId = $(this).attr("mobile-img-path");
-      const base64Encoded = await parent.loadEncodedFile(fileId);
-      this.src = base64Encoded;
-    }
+    const fileId = $(this).attr("mobile-img-path");
+    const base64Encoded =
+      await parent.saltcorn.mobileApp.common.loadEncodedFile(fileId);
+    this.src = base64Encoded;
   });
 
   $("[mobile-bg-img-path]").each(async function () {
-    if (parent.loadEncodedFile) {
-      const fileId = $(this).attr("mobile-bg-img-path");
-      if (fileId) {
-        const base64Encoded = await parent.loadEncodedFile(fileId);
-        this.style.backgroundImage = `url("${base64Encoded}")`;
-      }
+    const fileId = $(this).attr("mobile-bg-img-path");
+    if (fileId) {
+      const base64Encoded =
+        await parent.saltcorn.mobileApp.common.loadEncodedFile(fileId);
+      this.style.backgroundImage = `url("${base64Encoded}")`;
     }
   });
 
   $("img:not([mobile-img-path]):not([mobile-bg-img-path])").each(
     async function () {
-      if (parent.loadEncodedFile) {
-        const jThis = $(this);
-        const src = jThis.attr("src");
-        if (src?.includes("/files/serve/")) {
-          const tokens = src.split("/files/serve/");
-          if (tokens.length > 1) {
-            const fileId = tokens[1];
-            const base64Encoded = await parent.loadEncodedFile(fileId);
-            this.src = base64Encoded;
-          }
-        } else if (src?.includes("/files/resize/")) {
-          const tokens = src.split("/files/resize/");
-          if (tokens.length > 1) {
-            const idAndDims = tokens[1].split("/");
-            const width = idAndDims[0];
-            const height = idAndDims.length > 2 ? idAndDims[1] : undefined;
-            const fileId = idAndDims[idAndDims.length - 1];
-            const style = { width: `${width || 50}px` };
-            if (height > 0) style.height = `${height}px`;
-            const base64Encoded = await parent.loadEncodedFile(fileId);
-            this.src = base64Encoded;
-            jThis.css(style);
-          }
+      const jThis = $(this);
+      const src = jThis.attr("src");
+      if (src?.includes("/files/serve/")) {
+        const tokens = src.split("/files/serve/");
+        if (tokens.length > 1) {
+          const fileId = tokens[1];
+          const base64Encoded =
+            await parent.saltcorn.mobileApp.common.loadEncodedFile(fileId);
+          this.src = base64Encoded;
+        }
+      } else if (src?.includes("/files/resize/")) {
+        const tokens = src.split("/files/resize/");
+        if (tokens.length > 1) {
+          const idAndDims = tokens[1].split("/");
+          const width = idAndDims[0];
+          const height = idAndDims.length > 2 ? idAndDims[1] : undefined;
+          const fileId = idAndDims[idAndDims.length - 1];
+          const style = { width: `${width || 50}px` };
+          if (height > 0) style.height = `${height}px`;
+          const base64Encoded =
+            await parent.saltcorn.mobileApp.common.loadEncodedFile(fileId);
+          this.src = base64Encoded;
+          jThis.css(style);
         }
       }
     }
@@ -1569,14 +1580,15 @@ async function common_done(res, viewnameOrElem, isWeb = true) {
     });
   }
   if (res.eval_js) await handle(res.eval_js, eval_it);
+  /// TODO got and resume_workflow - use localStorage
   if (res.goto) {
     if (!isWeb) {
       const next = new URL(res.goto, "http://localhost");
       const pathname = next.pathname;
       if (pathname.startsWith("/view/") || pathname.startsWith("/page/")) {
         const route = `get${pathname}${next.search ? "?" + next.search : ""}`;
-        await parent.handleRoute(route);
-      } else parent.cordova.InAppBrowser.open(res.goto, "_system");
+        await parent.saltcorn.mobileApp.navigation.handleRoute(route);
+      } else parent.cordova.InAppBrowser.open(res.goto, "_system"); // TODO
     } else if (res.target === "_blank") window.open(res.goto, "_blank").focus();
     else {
       const prev = new URL(window.location.href);
@@ -1591,6 +1603,9 @@ async function common_done(res, viewnameOrElem, isWeb = true) {
         location.reload();
     }
   }
+  if (res.resume_workflow) {
+    ajax_post_json(`/actions/resume-workflow/${res.resume_workflow}`, {});
+  }
   if (res.reload_page) {
     (isWeb ? location : parent).reload(); //TODO notify to cookie if reload or goto
   }

package/public/saltcorn.js

@@ -84,17 +84,6 @@ function removeQueryStringParameter(uri1, key) {
   return uri + hash;
 }
 
-function get_current_state_url(e) {
-  const localizer = e ? $(e).closest("[data-sc-local-state]") : [];
-  let $modal = $("#scmodal");
-  if (localizer.length) {
-    const localState = localizer.attr("data-sc-local-state") || "";
-    return localState;
-  } else if ($modal.length === 0 || !$modal.hasClass("show"))
-    return window.location.href;
-  else return $modal.prop("data-modal-state");
-}
-
 function select_id(id, e) {
   pjax_to(updateQueryStringParameter(get_current_state_url(e), "id", id), e);
 }
@@ -423,6 +412,27 @@ function saveAndContinueAsync(e) {
   });
 }
 
+function saveAndContinueIfValid(e, k, event) {
+  //wait for applyShowIf
+  setTimeout(() => {
+    if (
+      event &&
+      event.target &&
+      event.target.classList &&
+      event.target.classList.contains("no-form-change")
+    )
+      return;
+    var form = $(e).closest("form");
+
+    if (form[0].checkValidity?.() === false) {
+      form[0].reportValidity();
+      return;
+    }
+
+    saveAndContinue(e, k, event);
+  });
+}
+
 function saveAndContinue(e, k, event) {
   if (
     event &&
@@ -432,6 +442,7 @@ function saveAndContinue(e, k, event) {
   )
     return;
   var form = $(e).closest("form");
+
   let focusedEl = null;
   if (!event || !event.srcElement) {
     const el = form.find("select[sc-received-focus]")[0];

package/routes/actions.js

@@ -17,6 +17,9 @@ const Trigger = require("@saltcorn/data/models/trigger");
 const FieldRepeat = require("@saltcorn/data/models/fieldrepeat");
 const { getTriggerList } = require("./common_lists");
 const TagEntry = require("@saltcorn/data/models/tag_entry");
+const WorkflowStep = require("@saltcorn/data/models/workflow_step");
+const WorkflowRun = require("@saltcorn/data/models/workflow_run");
+const WorkflowTrace = require("@saltcorn/data/models/workflow_trace");
 const Tag = require("@saltcorn/data/models/tag");
 const db = require("@saltcorn/data/db");
 
@@ -29,7 +32,13 @@ const db = require("@saltcorn/data/db");
  */
 const router = new Router();
 module.exports = router;
-const { renderForm, link } = require("@saltcorn/markup");
+const {
+  renderForm,
+  link,
+  mkTable,
+  localeDateTime,
+  post_delete_btn,
+} = require("@saltcorn/markup");
 const Form = require("@saltcorn/data/models/form");
 const {
   div,
@@ -45,8 +54,13 @@ const {
   td,
   h6,
   pre,
+  th,
   text,
   i,
+  ul,
+  li,
+  h2,
+  h4,
 } = require("@saltcorn/markup/tags");
 const Table = require("@saltcorn/data/models/table");
 const { getActionConfigFields } = require("@saltcorn/data/plugin-helper");
@@ -154,11 +168,15 @@ const triggerForm = async (req, trigger) => {
     .filter(([k, v]) => v.hasChannel)
     .map(([k, v]) => k);
 
-  const allActions = Trigger.action_options({ notRequireRow: false });
+  const allActions = Trigger.action_options({
+    notRequireRow: false,
+    workflow: true,
+  });
   const table_triggers = ["Insert", "Update", "Delete", "Validate"];
   const action_options = {};
   const actionsNotRequiringRow = Trigger.action_options({
     notRequireRow: true,
+    workflow: true,
   });
 
   Trigger.when_options.forEach((t) => {
@@ -467,6 +485,354 @@ router.post(
   })
 );
 
+function genWorkflowDiagram(steps) {
+  const stepNames = steps.map((s) => s.name);
+  const nodeLines = steps
+    .map(
+      (s) => `  ${s.name}["\`**${s.name}**
+  ${s.action_name}\`"]:::wfstep${s.id}`
+    )
+    .join("\n");
+  const linkLines = [];
+  let step_ix = 0;
+  for (const step of steps) {
+    if (step.action_name === "ForLoop") {
+      linkLines.push(
+        `  ${step.name} --> ${step.configuration.for_loop_step_name}`
+      );
+    } else if (stepNames.includes(step.next_step)) {
+      linkLines.push(`  ${step.name} --> ${step.next_step}`);
+    } else if (step.next_step) {
+      for (const otherStep of stepNames)
+        if (step.next_step.includes(otherStep))
+          linkLines.push(`  ${step.name} --> ${otherStep}`);
+    }
+    if (step.action_name === "EndForLoop") {
+      // TODO this is not correct. improve.
+      let forStep;
+      for (let i = step_ix; i >= 0; i -= 1) {
+        if (steps[i].action_name === "ForLoop") {
+          forStep = steps[i];
+          break;
+        }
+      }
+      if (forStep) linkLines.push(`  ${step.name} --> ${forStep.name}`);
+    }
+    step_ix += 1;
+  }
+  return "flowchart TD\n" + nodeLines + "\n" + linkLines.join("\n");
+}
+
+const getWorkflowConfig = async (req, id, table, trigger) => {
+  let steps = await WorkflowStep.find(
+    { trigger_id: trigger.id },
+    { orderBy: "id" }
+  );
+  const initial_step = steps.find((step) => step.initial_step);
+  if (initial_step)
+    steps = [initial_step, ...steps.filter((s) => !s.initial_step)];
+  const trigCfgForm = new Form({
+    action: addOnDoneRedirect(`/actions/configure/${id}`, req),
+    onChange: "saveAndContinue(this)",
+    noSubmitButton: true,
+    formStyle: "vert",
+    fields: [
+      {
+        name: "save_traces",
+        label: "Save step traces for each run",
+        type: "Bool",
+      },
+    ],
+  });
+  trigCfgForm.values = trigger.configuration;
+  return (
+    /*ul(
+      steps.map((step) =>
+        li(
+          a(
+            {
+              href: `/actions/stepedit/${trigger.id}/${step.id}`,
+            },
+            step.name
+          )
+        )
+      )
+    ) +*/
+    pre({ class: "mermaid" }, genWorkflowDiagram(steps)) +
+    script(
+      { defer: "defer" },
+      `function tryAddWFNodes() {
+  const ns = $("g.node");
+  if(!ns.length) setTimeout(tryAddWFNodes, 200)
+  else {
+    $("g.node").on("click", (e)=>{
+       const $e = $(e.target || e).closest("g.node")
+       const cls = $e.attr('class')
+       if(!cls || !cls.includes("wfstep")) return;
+       const id = cls.split(" ").find(c=>c.startsWith("wfstep")).
+          substr(6);
+       location.href = '/actions/stepedit/${trigger.id}/'+id;
+      //console.log($e.attr('class'), id)
+     })
+  }
+}
+window.addEventListener('DOMContentLoaded',tryAddWFNodes)`
+    ) +
+    a(
+      {
+        href: `/actions/stepedit/${trigger.id}?name=step${steps.length + 1}${
+          initial_step ? "" : "&initial_step=true"
+        }`,
+        class: "btn btn-primary",
+      },
+      i({ class: "fas fa-plus me-2" }),
+      "Add step"
+    ) +
+    a(
+      {
+        href: `/actions/runs/?trigger=${trigger.id}`,
+        class: "d-block",
+      },
+      "Show runs »"
+    ) +
+    renderForm(trigCfgForm, req.csrfToken())
+  );
+};
+
+const jsIdentifierValidator = (s) => {
+  if (!s) return "An identifier is required";
+  if (s.includes(" ")) return "Spaces not allowd";
+  let badc = "'#:/\\@()[]{}\"!%^&*-+*~<>,.?|"
+    .split("")
+    .find((c) => s.includes(c));
+
+  if (badc) return `Character ${badc} not allowed`;
+};
+
+const getWorkflowStepForm = async (trigger, req, step_id) => {
+  const table = trigger.table_id ? Table.findOne(trigger.table_id) : null;
+  let stateActions = getState().actions;
+  const stateActionKeys = Object.entries(stateActions)
+    .filter(([k, v]) => !v.disableInWorkflow)
+    .map(([k, v]) => k);
+
+  const actionConfigFields = [];
+  for (const [name, action] of Object.entries(stateActions)) {
+    if (!stateActionKeys.includes(name)) continue;
+    try {
+      const cfgFields = await getActionConfigFields(action, table, {
+        mode: "workflow",
+      });
+
+      for (const field of cfgFields) {
+        const cfgFld = {
+          ...field,
+          showIf: {
+            wf_action_name: name,
+            ...(field.showIf || {}),
+          },
+        };
+        if (cfgFld.input_type === "code") cfgFld.input_type = "textarea";
+        actionConfigFields.push(cfgFld);
+      }
+    } catch {}
+  }
+  const actionsNotRequiringRow = Trigger.action_options({
+    notRequireRow: true,
+    noMultiStep: true,
+    builtInLabel: "Workflow Actions",
+    builtIns: [
+      "SetContext",
+      "TableQuery",
+      "WaitUntil",
+      "UserForm",
+      "WaitNextTick",
+    ],
+    forWorkflow: true,
+  });
+
+  actionConfigFields.push({
+    label: "Form header",
+    name: "form_header",
+    type: "String",
+    showIf: { wf_action_name: "UserForm" },
+  });
+  actionConfigFields.push({
+    label: "User ID",
+    name: "user_id_expression",
+    type: "String",
+    sublabel: "Optional. If blank assigned to user starting the workflow",
+    showIf: { wf_action_name: "UserForm" },
+  });
+  actionConfigFields.push({
+    label: "Resume at",
+    name: "resume_at",
+    sublabel:
+      "JavaScript expression for the time to resume. <code>moment</code> is in scope.",
+    type: "String",
+    showIf: { wf_action_name: "WaitUntil" },
+  });
+  actionConfigFields.push({
+    label: "Context values",
+    name: "ctx_values",
+    sublabel:
+      "JavaScript object expression for the variables to set. Example <code>{x: 5, y:y+1}</code> will set x to 5 and increment existing context variable y",
+    type: "String",
+    fieldview: "textarea",
+    class: "validate-expression",
+    default: "{}",
+    showIf: { wf_action_name: "SetContext" },
+  });
+
+  actionConfigFields.push({
+    label: "Table",
+    name: "query_table",
+    type: "String",
+    required: true,
+    attributes: { options: (await Table.find()).map((t) => t.name) },
+    showIf: { wf_action_name: "TableQuery" },
+  });
+  actionConfigFields.push({
+    label: "Query",
+    name: "query_object",
+    sublabel: "Where object, example <code>{manager: 1}</code>",
+    type: "String",
+    required: true,
+    class: "validate-expression",
+    default: "{}",
+    showIf: { wf_action_name: "TableQuery" },
+  });
+  actionConfigFields.push({
+    label: "Variable",
+    name: "query_variable",
+    sublabel: "Context variable to write to query results to",
+    type: "String",
+    required: true,
+    validator: jsIdentifierValidator,
+    showIf: { wf_action_name: "TableQuery" },
+  });
+  actionConfigFields.push(
+    new FieldRepeat({
+      name: "user_form_questions",
+      showIf: { wf_action_name: "UserForm" },
+      fields: [
+        {
+          label: "Label",
+          name: "label",
+          type: "String",
+          sublabel:
+            "The text that will shown to the user above the input elements",
+        },
+        {
+          label: "Variable name",
+          name: "var_name",
+          type: "String",
+          sublabel:
+            "The answer will be set in the context with this variable name",
+          validator: jsIdentifierValidator,
+        },
+        {
+          label: "Input Type",
+          name: "qtype",
+          type: "String",
+          required: true,
+          attributes: {
+            options: [
+              "Yes/No",
+              "Checkbox",
+              "Free text",
+              "Multiple choice",
+              //"Multiple checks",
+              "Integer",
+              "Float",
+              //"File upload",
+            ],
+          },
+        },
+        {
+          label: "Options",
+          name: "options",
+          type: "String",
+          sublabel: "Comma separated list of multiple choice options",
+          showIf: { qtype: ["Multiple choice", "Multiple checks"] },
+        },
+      ],
+    })
+  );
+
+  const form = new Form({
+    action: addOnDoneRedirect(`/actions/stepedit/${trigger.id}`, req),
+    onChange: "saveAndContinueIfValid(this)",
+    submitLabel: req.__("Done"),
+    additionalButtons: step_id
+      ? [
+          {
+            label: req.__("Delete"),
+            class: "btn btn-outline-danger",
+            onclick: `ajax_post('/actions/delete-step/${+step_id}')`,
+            afterSave: true,
+          },
+        ]
+      : undefined,
+    fields: [
+      {
+        name: "wf_step_name",
+        label: req.__("Step name"),
+        type: "String",
+        required: true,
+        sublabel: "An identifier by which this step can be referred to.",
+        validator: jsIdentifierValidator,
+      },
+      {
+        name: "wf_initial_step",
+        label: req.__("Initial step"),
+        sublabel: "Is this the first step in the workflow?",
+        type: "Bool",
+      },
+      {
+        name: "wf_only_if",
+        label: req.__("Only if..."),
+        sublabel:
+          "Optional JavaScript expression based on the run context. If given, the chosen action will only be executed if evaluates to true",
+        type: "String",
+      },
+      {
+        name: "wf_next_step",
+        label: req.__("Next step"),
+        type: "String",
+        class: "validate-expression",
+        sublabel:
+          "Name of next step. Can be a JavaScript expression based on the run context. Blank if final step",
+      },
+      {
+        name: "wf_action_name",
+        label: req.__("Action"),
+        type: "String",
+        required: true,
+        attributes: {
+          options: actionsNotRequiringRow,
+        },
+      },
+      ...actionConfigFields,
+    ],
+  });
+  form.hidden("wf_step_id");
+  if (step_id) {
+    const step = await WorkflowStep.findOne({ id: step_id });
+    if (!step) throw new Error("Step not found");
+    form.values = {
+      wf_step_id: step.id,
+      wf_step_name: step.name,
+      wf_initial_step: step.initial_step,
+      wf_only_if: step.only_if,
+      wf_action_name: step.action_name,
+      wf_next_step: step.next_step,
+      ...step.configuration,
+    };
+  }
+  return form;
+};
+
 const getMultiStepForm = async (req, id, table) => {
   let stateActions = getState().actions;
   const stateActionKeys = Object.entries(stateActions)
@@ -579,7 +945,33 @@ router.get(
         { href: `/actions/testrun/${id}`, class: "ms-2" },
         req.__("Test run") + "&nbsp;&raquo;"
       );
-    if (trigger.action === "Multi-step action") {
+    if (trigger.action === "Workflow") {
+      const wfCfg = await getWorkflowConfig(req, id, table, trigger);
+      send_events_page({
+        res,
+        req,
+        active_sub: "Triggers",
+        sub2_page: "Configure",
+        page_title: req.__(`%s configuration`, trigger.name),
+        headers: [
+          {
+            script: `/static_assets/${db.connectObj.version_tag}/mermaid.min.js`,
+          },
+          {
+            headerTag: `<script type="module">mermaid.initialize({securityLevel: 'loose'${
+              getState().getLightDarkMode(req.user) ? ",theme: 'dark'," : ""
+            }});</script>`,
+          },
+        ],
+        contents: {
+          type: "card",
+          titleAjaxIndicator: true,
+          title: req.__("Configure trigger %s", trigger.name),
+          subtitle,
+          contents: wfCfg,
+        },
+      });
+    } else if (trigger.action === "Multi-step action") {
       const form = await getMultiStepForm(req, id, table);
       form.values = trigger.configuration;
       send_events_page({
@@ -725,6 +1117,11 @@ router.post(
     let form;
     if (trigger.action === "Multi-step action") {
       form = await getMultiStepForm(req, id, table);
+    } else if (trigger.action === "Workflow") {
+      form = new Form({
+        action: `/actions/configure/${id}`,
+        fields: [{ name: "save_traces", label: "Save traces", type: "Bool" }],
+      });
     } else {
       const cfgFields = await getActionConfigFields(action, table, {
         mode: "trigger",
@@ -830,6 +1227,7 @@ router.get(
         table,
         row,
         req,
+        interactive: true,
         ...(row || {}),
         Table,
         user: req.user,
@@ -848,7 +1246,13 @@ router.get(
           ? script(domReady(`common_done(${JSON.stringify(runres)})`))
           : ""
       );
-      res.redirect(`/actions/`);
+      if (trigger.action === "Workflow")
+        res.redirect(
+          runres?.__wf_run_id
+            ? `/actions/run/${runres?.__wf_run_id}`
+            : `/actions/runs/?trigger=${trigger.id}`
+        );
+      else res.redirect(`/actions/`);
     } else {
       send_events_page({
         res,
@@ -909,3 +1313,490 @@ router.post(
     res.redirect(`/actions`);
   })
 );
+
+/**
+ * @name post/clone/:id
+ * @function
+ * @memberof module:routes/actions~actionsRouter
+ * @function
+ */
+router.get(
+  "/stepedit/:trigger_id/:step_id?",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { trigger_id, step_id } = req.params;
+    const { initial_step, name } = req.query;
+    const trigger = await Trigger.findOne({ id: trigger_id });
+    const form = await getWorkflowStepForm(trigger, req, step_id);
+
+    if (initial_step) form.values.wf_initial_step = true;
+    if (name) form.values.wf_step_name = name;
+    send_events_page({
+      res,
+      req,
+      active_sub: "Triggers",
+      sub2_page: "Configure",
+      page_title: req.__(`%s configuration`, trigger.name),
+      contents: {
+        type: "card",
+        titleAjaxIndicator: true,
+        title: req.__(
+          "Configure trigger %s",
+          a({ href: `/actions/configure/${trigger.id}` }, trigger.name)
+        ),
+        contents: renderForm(form, req.csrfToken()),
+      },
+    });
+  })
+);
+
+router.post(
+  "/stepedit/:trigger_id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { trigger_id } = req.params;
+    const trigger = await Trigger.findOne({ id: trigger_id });
+    const form = await getWorkflowStepForm(trigger, req);
+    form.validate(req.body);
+    if (form.hasErrors) {
+      if (req.xhr) {
+        res.json({ error: form.errorSummary });
+      } else
+        send_events_page({
+          res,
+          req,
+          active_sub: "Triggers",
+          sub2_page: "Configure",
+          page_title: req.__(`%s configuration`, trigger.name),
+          contents: {
+            type: "card",
+            titleAjaxIndicator: true,
+            title: req.__(
+              "Configure trigger %s",
+              a({ href: `/actions/configure/${trigger.id}` }, trigger.name)
+            ),
+            contents: renderForm(form, req.csrfToken()),
+          },
+        });
+      return;
+    }
+    const {
+      wf_step_name,
+      wf_action_name,
+      wf_next_step,
+      wf_initial_step,
+      wf_only_if,
+      wf_step_id,
+      ...configuration
+    } = form.values;
+    Object.entries(configuration).forEach(([k, v]) => {
+      if (v === null) delete configuration[k];
+    });
+    const step = {
+      name: wf_step_name,
+      action_name: wf_action_name,
+      next_step: wf_next_step,
+      only_if: wf_only_if,
+      initial_step: wf_initial_step,
+      trigger_id,
+      configuration,
+    };
+
+    if (wf_step_id && wf_step_id !== "undefined") {
+      const wfStep = new WorkflowStep({ id: wf_step_id, ...step });
+
+      await wfStep.update(step);
+      if (req.xhr) res.json({ success: "ok" });
+      else {
+        req.flash("success", req.__("Step saved"));
+        res.redirect(`/actions/configure/${step.trigger_id}`);
+      }
+    } else {
+      //insert
+      const id = await WorkflowStep.create(step);
+      if (req.xhr) res.json({ success: "ok", set_fields: { wf_step_id: id } });
+      else {
+        req.flash("success", req.__("Step saved"));
+        res.redirect(`/actions/configure/${step.trigger_id}`);
+      }
+    }
+  })
+);
+
+router.post(
+  "/delete-step/:step_id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { step_id } = req.params;
+    const step = await WorkflowStep.findOne({ id: step_id });
+    await step.delete();
+    res.json({ goto: `/actions/configure/${step.trigger_id}` });
+  })
+);
+
+router.get(
+  "/runs",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const trNames = {};
+    const { _page, trigger } = req.query;
+    for (const trig of await Trigger.find({ action: "Workflow" }))
+      trNames[trig.id] = trig.name;
+    const q = {};
+    const selOpts = { orderBy: "started_at", orderDesc: true, limit: 20 };
+    if (_page) selOpts.offset = 20 * (parseInt(_page) - 1);
+    if (trigger) q.trigger_id = trigger;
+    const runs = await WorkflowRun.find(q, selOpts);
+    const count = await WorkflowRun.count(q);
+
+    const wfTable = mkTable(
+      [
+        { label: "Trigger", key: (run) => trNames[run.trigger_id] },
+        { label: "Started", key: (run) => localeDateTime(run.started_at) },
+        { label: "Status", key: "status" },
+        {
+          label: "",
+          key: (run) => {
+            switch (run.status) {
+              case "Running":
+                return run.current_step;
+              case "Error":
+                return run.error;
+              case "Waiting":
+                if (run.wait_info?.form)
+                  return a(
+                    { href: `/actions/fill-workflow-form/${run.id}` },
+                    "Fill ",
+                    run.current_step
+                  );
+                return run.current_step;
+              default:
+                return "";
+            }
+          },
+        },
+      ],
+      runs,
+      {
+        onRowSelect: (row) => `location.href='/actions/run/${row.id}'`,
+        pagination: {
+          current_page: parseInt(_page) || 1,
+          pages: Math.ceil(count / 20),
+          get_page_link: (n) => `gopage(${n}, 20)`,
+        },
+      }
+    );
+    send_events_page({
+      res,
+      req,
+      active_sub: "Workflow runs",
+      page_title: req.__(`Workflow runs`),
+      contents: {
+        type: "card",
+        titleAjaxIndicator: true,
+        title: req.__("Workflow runs"),
+        contents: wfTable,
+      },
+    });
+  })
+);
+
+router.get(
+  "/run/:id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const run = await WorkflowRun.findOne({ id });
+    const trigger = await Trigger.findOne({ id: run.trigger_id });
+    const traces = await WorkflowTrace.find(
+      { run_id: run.id },
+      { orderBy: "id" }
+    );
+    const traces_accordion_items = div(
+      { class: "accordion" },
+      traces.map((trace, ix) =>
+        div(
+          { class: "accordion-item" },
+
+          h2(
+            { class: "accordion-header", id: `trhead${ix}` },
+            button(
+              {
+                class: ["accordion-button", "collapsed"],
+                type: "button",
+
+                "data-bs-toggle": "collapse",
+                "data-bs-target": `#trtab${ix}`,
+                "aria-expanded": "false",
+                "aria-controls": `trtab${ix}`,
+              },
+              `${ix + 1}: ${trace.step_name_run}`
+            )
+          ),
+          div(
+            {
+              class: ["accordion-collapse", "collapse"],
+              id: `trtab${ix}`,
+              "aria-labelledby": `trhead${ix}`,
+            },
+            div(
+              { class: ["accordion-body"] },
+              table(
+                { class: "table table-condensed w-unset" },
+                tbody(
+                  tr(
+                    th("Started at"),
+                    td(localeDateTime(trace.step_started_at))
+                  ),
+                  tr(th("Elapsed"), td(trace.elapsed, "s")),
+                  tr(th("Run by user"), td(trace.user_id)),
+                  tr(th("Status"), td(trace.status)),
+                  trace.status === "Waiting"
+                    ? tr(th("Waiting for"), td(JSON.stringify(trace.wait_info)))
+                    : null,
+                  tr(
+                    th("Context"),
+                    td(pre(text(JSON.stringify(trace.context, null, 2))))
+                  )
+                )
+              )
+            )
+          )
+        )
+      )
+    );
+
+    send_events_page({
+      res,
+      req,
+      active_sub: "Workflow runs",
+      page_title: req.__(`Workflow runs`),
+      sub2_page: trigger.name,
+      contents: {
+        above: [
+          {
+            type: "card",
+            titleAjaxIndicator: true,
+            title: req.__("Workflow run"),
+            contents:
+              table(
+                { class: "table table-condensed w-unset" },
+                tbody(
+                  tr(th("Run ID"), td(run.id)),
+                  tr(
+                    th("Trigger"),
+                    td(
+                      a(
+                        { href: `/actions/configure/${trigger.id}` },
+                        trigger.name
+                      )
+                    )
+                  ),
+                  tr(th("Started at"), td(localeDateTime(run.started_at))),
+                  tr(th("Started by user"), td(run.started_by)),
+                  tr(th("Status"), td(run.status)),
+                  run.status === "Waiting"
+                    ? tr(th("Waiting for"), td(JSON.stringify(run.wait_info)))
+                    : null,
+                  tr(
+                    th("Context"),
+                    td(pre(text(JSON.stringify(run.context, null, 2))))
+                  )
+                )
+              ) + post_delete_btn("/actions/delete-run/" + run.id, req),
+          },
+          ...(traces.length
+            ? [
+                {
+                  type: "card",
+                  title: req.__("Step traces"),
+                  contents: traces_accordion_items,
+                },
+              ]
+            : []),
+        ],
+      },
+    });
+  })
+);
+
+router.post(
+  "/delete-run/:id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const run = await WorkflowRun.findOne({ id });
+    await run.delete();
+    res.redirect("/actions/runs");
+  })
+);
+
+const getWorkflowStepUserForm = async (run, trigger, step, user) => {
+  const qTypeToField = (q) => {
+    switch (q.qtype) {
+      case "Yes/No":
+        return {
+          type: "String",
+          attributes: { options: "Yes,No" },
+          fieldview: "radio_group",
+        };
+      case "Checkbox":
+        return { type: "Bool" };
+      case "Free text":
+        return { type: "String" };
+      case "Multiple choice":
+        return {
+          type: "String",
+          attributes: { options: q.options },
+          fieldview: "radio_group",
+        };
+      case "Integer":
+        return { type: "Integer" };
+      case "Float":
+        return { type: "Float" };
+      default:
+        return {};
+    }
+  };
+
+  const form = new Form({
+    action: `/actions/fill-workflow-form/${run.id}`,
+    blurb: step.configuration?.form_header || "",
+    fields: (step.configuration.user_form_questions || []).map((q) => ({
+      label: q.label,
+      name: q.var_name,
+      ...qTypeToField(q),
+    })),
+  });
+  return form;
+};
+
+router.get(
+  "/fill-workflow-form/:id",
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const run = await WorkflowRun.findOne({ id });
+
+    if (!run.user_allowed_to_fill_form(req.user)) {
+      if (req.xhr) res.json({ error: "Not authorized" });
+      else {
+        req.flash("danger", req.__("Not authorized"));
+        res.redirect("/");
+      }
+      return;
+    }
+
+    const trigger = await Trigger.findOne({ id: run.trigger_id });
+    const step = await WorkflowStep.findOne({
+      trigger_id: trigger.id,
+      name: run.current_step,
+    });
+
+    const form = await getWorkflowStepUserForm(run, trigger, step, req.user);
+    if (req.xhr) form.xhrSubmit = true;
+    const title = "Fill form";
+    res.sendWrap(title, renderForm(form, req.csrfToken()));
+  })
+);
+
+router.post(
+  "/fill-workflow-form/:id",
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const run = await WorkflowRun.findOne({ id });
+    if (!run.user_allowed_to_fill_form(req.user)) {
+      if (req.xhr) res.json({ error: "Not authorized" });
+      else {
+        req.flash("danger", req.__("Not authorized"));
+        res.redirect("/");
+      }
+      return;
+    }
+
+    const trigger = await Trigger.findOne({ id: run.trigger_id });
+    const step = await WorkflowStep.findOne({
+      trigger_id: trigger.id,
+      name: run.current_step,
+    });
+
+    const form = await getWorkflowStepUserForm(run, trigger, step, req.user);
+    form.validate(req.body);
+    if (form.hasErrors) {
+      const title = "Fill form";
+      res.sendWrap(title, renderForm(form, req.csrfToken()));
+    } else {
+      await run.provide_form_input(form.values);
+      await run.run({
+        user: req.user,
+        trace: trigger.configuration?.save_traces,
+      });
+      if (req.xhr) {
+        const retDirs = await run.popReturnDirectives();
+        res.json({ success: "ok", ...retDirs });
+      } else {
+        if (run.context.goto) res.redirect(run.context.goto);
+        else res.redirect("/");
+      }
+    }
+  })
+);
+
+router.post(
+  "/resume-workflow/:id",
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const run = await WorkflowRun.findOne({ id });
+    //TODO session if not logged in
+    if (run.started_by !== req.user?.id) {
+      if (req.xhr) res.json({ error: "Not authorized" });
+      else {
+        req.flash("danger", req.__("Not authorized"));
+        res.redirect("/");
+      }
+      return;
+    }
+    const trigger = await Trigger.findOne({ id: run.trigger_id });
+    const runResult = await run.run({
+      user: req.user,
+      interactive: true,
+      trace: trigger.configuration?.save_traces,
+    });
+    if (req.xhr) {
+      if (
+        runResult &&
+        typeof runResult === "object" &&
+        Object.keys(runResult).length
+      ) {
+        res.json({ success: "ok", ...runResult });
+        return;
+      }
+      const retDirs = await run.popReturnDirectives();
+      res.json({ success: "ok", ...retDirs });
+    } else {
+      if (run.context.goto) res.redirect(run.context.goto);
+      else res.redirect("/");
+    }
+  })
+);
+
+/* 
+
+WORKFLOWS TODO
+
+delete is not always working?
+help file to explain steps, and context
+
+workflow actions: ForLoop, EndForLoop, Output, ReadFile, WriteFile, APIResponse
+
+interactive workflows for not logged in
+
+show unconnected steps
+why is code not initialising
+drag and drop edges
+
+*/

package/routes/eventlog.js

@@ -81,6 +81,31 @@ const logSettingsForm = async (req) => {
       input_type: "date",
       attributes: { minDate: new Date(), maxDate: hoursFuture(24 * 7 * 2) },
     },
+    {
+      input_type: "section_header",
+      label: req.__("Delete old workflow runs with status after days"),
+    },
+    {
+      name: "delete_finished_workflows_days",
+      label: req.__("Finished"),
+      type: "Integer",
+    },
+    {
+      name: "delete_error_workflows_days",
+      label: req.__("Error"),
+      type: "Integer",
+    },
+    {
+      name: "delete_waiting_workflows_days",
+      label: req.__("Waiting"),
+      type: "Integer",
+    },
+
+    {
+      name: "delete_running_workflows_days",
+      label: req.__("Running"),
+      type: "Integer",
+    },
     {
       input_type: "section_header",
       label: req.__("Which events should be logged?"),
@@ -143,6 +168,10 @@ router.get(
       "next_weekly_event",
       {}
     );
+    ["error", "finished", "running", "waiting"].forEach((k) => {
+      let cfgk = `delete_${k}_workflows_days`;
+      form.values[cfgk] = getState().getConfig(cfgk);
+    });
 
     send_events_page({
       res,
@@ -348,6 +377,13 @@ router.post(
           delete form.values[k];
         }
       }
+      for (const status of ["error", "finished", "running", "waiting"]) {
+        let k = `delete_${status}_workflows_days`;
+        if (form.values[k]) {
+          await getState().setConfig(k, form.values[k]);
+          delete form.values[k];
+        }
+      }
 
       await getState().setConfig("event_log_settings", form.values);
 

package/routes/fields.js

@@ -301,6 +301,10 @@ const fieldFlow = (req) =>
       if (context.id) {
         const field = await Field.findOne({ id: context.id });
         try {
+          if (fldRow.label && field.label != fldRow.label) {
+            fldRow.name = Field.labelToName(fldRow.label);
+          }
+
           await field.update(fldRow);
         } catch (e) {
           return {

package/routes/tables.js

@@ -757,6 +757,8 @@ router.get(
     const triggers = table.id ? Trigger.find({ table_id: table.id }) : [];
     triggers.sort(comparingCaseInsensitive("name"));
     let fieldCard;
+    const nPrimaryKeys = fields.filter((f) => f.primary_key).length;
+
     if (fields.length === 0) {
       fieldCard = [
         h4(req.__(`No fields defined in %s table`, table.name)),
@@ -818,6 +820,19 @@ router.get(
         { hover: true }
       );
       fieldCard = [
+        nPrimaryKeys > 1 &&
+          div(
+            { class: "alert alert-danger", role: "alert" },
+            i({ class: "fas fa-exclamation-triangle" }),
+            "This table has composite primary keys which is not supported in Saltcorn. A procedure to introduce a single autoincrementing primary key is available.",
+            post_btn(
+              `/table/repair-composite-primary/${table.id}`,
+              "Add autoincrementing primary key",
+              req.csrfToken(),
+              { btnClass: "btn-danger" }
+            )
+          ),
+
         tableHtml,
         inbound_refs.length > 0
           ? req.__("Inbound keys: ") +
@@ -1111,7 +1126,7 @@ router.post(
     const v = req.body;
     if (typeof v.id === "undefined" && typeof v.external === "undefined") {
       // insert
-      v.name = v.name.trim()
+      v.name = v.name.trim();
       const { name, ...rest } = v;
       const alltables = await Table.find({});
       const existing_tables = [
@@ -2074,3 +2089,20 @@ router.post(
     respondWorkflow(table, workflow, wfres, req, res);
   })
 );
+
+router.post(
+  "/repair-composite-primary/:id",
+  isAdmin,
+  error_catcher(async (req, res) => {
+    const { id } = req.params;
+
+    const table = Table.findOne({ id });
+    if (!table) {
+      req.flash("error", `Table not found`);
+      res.redirect(`/table`);
+      return;
+    }
+    await table.repairCompositePrimary();
+    res.redirect(`/table/${table.id}`);
+  })
+);