run_action_column = async ({ col, req, ...rest }) => {
  const run_action_step = async (action_name, colcfg) => {
    let state_action = getState().actions[action_name];
    let configuration;
    let goRun;
    if (state_action) {
      configuration = colcfg;
      goRun = () =>
        state_action.run({
          configuration,
          user: req.user,
          req,
          ...rest,
        });
    } else {
      const trigger = await Trigger.findOne({ name: action_name });

      if (
        trigger?.action === "Multi-step action" ||
        trigger?.action === "Workflow"
      ) {
        goRun = () =>
          trigger.runWithoutRow({ req, interactive: true, ...rest });
      } else if (trigger) {
        state_action = getState().actions[trigger.action];
        goRun = () =>
          state_action.run({
            configuration: trigger.configuration,
            trigger_id: trigger.id,
            user: req.user,
            req,
            ...rest,
          });
      }
    }
    if (!goRun)
      throw new Error("Runnable action not found: " + text(action_name));

    return await goRun();
  };
  if (col.action_name === "Multi-step action") {
    let result = {};
    let step_count = 0;
    let MAX_STEPS = 200;
    for (
      let i = 0;
      i < col.step_action_names.length && step_count < MAX_STEPS;
      i++
    ) {
      step_count += 1;

      const action_name = col.step_action_names?.[i];
      if (!action_name) continue;
      const only_if = col.step_only_ifs?.[i];
      const config = col.configuration.steps?.[i] || {};
      if (only_if && rest.row) {
        if (
          !eval_expression(
            only_if,
            rest.row,
            req?.user,
            "Multistep action only if formula"
          )
        )
          continue;
      }
      const stepres = await run_action_step(action_name, config);
      if (stepres?.goto_step) {
        i = +stepres.goto_step - 2;
        delete stepres.goto_step;
      }
      if (stepres?.clear_return_values) result = {};
      if (stepres?.set_fields && rest?.row) {
        Object.entries(stepres?.set_fields).forEach(([k, v]) => {
          rest.row[k] = v;
        });
      }
      try {
        mergeActionResults(result, stepres);
      } catch (error) {
        console.error(error);
      }
      if (result.error || result.halt_steps) break;
    }
    return result;
  } else return await run_action_step(col.action_name, col.configuration);
}
Run Action Column
@param {object} col
@param {object} req
@param {...*} rest
@returns {Promise<*>}