@saltcorn/server 1.1.0-beta.9 → 1.1.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) => {
@@ -326,6 +344,11 @@ router.get(
   isAdmin,
   error_catcher(async (req, res) => {
     const form = await triggerForm(req);
+    if (req.query.table) {
+      const table = Table.findOne({ name: req.query.table });
+      if (table) form.values.table_id = table.id;
+    }
+
     send_events_page({
       res,
       req,
@@ -467,6 +490,388 @@ 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}`
+  );
+
+  nodeLines.unshift(`  _Start@{ shape: circle, label: "Start" }`);
+  const linkLines = [];
+  let step_ix = 0;
+  for (const step of steps) {
+    if (step.initial_step) linkLines.push(`  _Start --> ${step.name}`);
+    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;
+  }
+  const fc =
+    "flowchart TD\n" + nodeLines.join("\n") + "\n" + linkLines.join("\n");
+  return fc;
+}
+
+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 (
+    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}${
+          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;
+  const actionExplainers = {};
+
+  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;
+
+    if (action.description) actionExplainers[name] = action.description;
+
+    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",
+      "Output",
+      "WaitUntil",
+      "WaitNextTick",
+      "UserForm",
+    ],
+    forWorkflow: true,
+  });
+  const triggers = Trigger.find({
+    when_trigger: { or: ["API call", "Never"] },
+  });
+  triggers.forEach((tr) => {
+    if (tr.description) actionExplainers[tr.name] = tr.description;
+  });
+  actionExplainers.SetContext = "Set variables in the context";
+  actionExplainers.TableQuery = "Query a table into a variable in the context";
+  actionExplainers.Output =
+    "Display a message to the user. Pause workflow until the message is read.";
+  actionExplainers.WaitUntil = "Pause until a time in the future";
+  actionExplainers.WaitNextTick =
+    "Pause until the next scheduler invocation (at most 5 minutes)";
+  actionExplainers.UserForm =
+    "Ask a user one or more questions, pause until they are answered";
+
+  actionConfigFields.push({
+    label: "Form header",
+    sublabel: "Text shown to the user at the top of the form",
+    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: "Output text",
+    name: "output_text",
+    sublabel:
+      "Message shown to the user. Can contain HTML tags and use interpolations {{ }} to access the context",
+    type: "String",
+    fieldview: "textarea",
+    showIf: { wf_action_name: "Output" },
+  });
+  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: [
+      {
+        input_type: "section_header",
+        label: req.__("Step settings"),
+      },
+      {
+        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",
+      },
+      {
+        input_type: "section_header",
+        label: req.__("Action"),
+      },
+      {
+        name: "wf_action_name",
+        label: req.__("Action"),
+        type: "String",
+        required: true,
+        attributes: {
+          options: actionsNotRequiringRow,
+          explainers: actionExplainers,
+        },
+      },
+      {
+        input_type: "section_header",
+        label: req.__("Action settings"),
+      },
+      ...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 +984,35 @@ 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) === "dark"
+                ? ",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 +1158,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 +1268,7 @@ router.get(
         table,
         row,
         req,
+        interactive: true,
         ...(row || {}),
         Table,
         user: req.user,
@@ -848,7 +1287,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 +1354,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 (!step_id) {
+      const steps = await WorkflowStep.find({ trigger_id });
+      const stepNames = new Set(steps.map((s) => s.name));
+      let name_ix = steps.length + 1;
+      while (stepNames.has(`step${name_ix}`)) name_ix += 1;
+      form.values.wf_step_name = `step${name_ix}`;
+    }
+    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,
+    };
+    try {
+      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}`);
+        }
+      }
+    } catch (e) {
+      const emsg =
+        e.message ===
+        'duplicate key value violates unique constraint "workflow_steps_name_uniq"'
+          ? `A step with the name ${wf_step_name} already exists`
+          : e.message;
+      if (req.xhr) res.json({ error: emsg });
+      else {
+        req.flash("error", emsg);
+        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 || run.wait_info.output)
+                  return a(
+                    { href: `/actions/fill-workflow-form/${run.id}` },
+                    run.wait_info.output ? "Show " : "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,
+                  run.status === "Error"
+                    ? tr(th("Error message"), td(run.error))
+                    : 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, req) => {
+  const form = new Form({
+    action: `/actions/fill-workflow-form/${run.id}`,
+    submitLabel: run.wait_info.output ? req.__("OK") : req.__("Submit"),
+    blurb: run.wait_info.output || step.configuration?.form_header || "",
+    formStyle: run.wait_info.output || req.xhr ? "vert" : undefined,
+    fields: await run.userFormFields(step),
+  });
+  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);
+    if (req.xhr) form.xhrSubmit = true;
+    const title = run.wait_info.output ? "Workflow output" : "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);
+    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);
+      const runres = await run.run({
+        user: req.user,
+        trace: trigger.configuration?.save_traces,
+        interactive: true,
+      });
+      if (req.xhr) {
+        const retDirs = await run.popReturnDirectives();
+
+        if (runres?.popup) retDirs.popup = runres.popup;
+        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
+
+help file to explain steps, and context
+
+workflow actions: ForLoop, EndForLoop, ReadFile, WriteFile, APIResponse
+
+Error handlers
+other triggers can be steps
+interactive workflows for not logged in
+show end node in diagram
+actions can declare which variables they inject into scope
+
+show unconnected steps
+why is code not initialising
+drag and drop edges
+
+*/