Generalize workflow system.

Author: apognu

api/handle_workflows.go

@@ -0,0 +1,27 @@
+package api
+
+import (
+	"net/http"
+
+	"github.com/checkmarble/marble-backend/dto"
+	"github.com/checkmarble/marble-backend/pure_utils"
+	"github.com/checkmarble/marble-backend/usecases"
+	"github.com/gin-gonic/gin"
+)
+
+func handleListWorkflowsForScenario(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		scenarioId := c.Param("scenarioId")
+
+		uc := usecasesWithCreds(ctx, uc)
+		scenarioUsecase := uc.NewScenarioUsecase()
+
+		rules, err := scenarioUsecase.ListWorkflowsForScenario(ctx, scenarioId)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusOK, pure_utils.Map(rules, dto.AdaptWorkflow))
+	}
+}

api/routes.go

@@ -287,4 +287,6 @@ func addRoutes(r *gin.Engine, conf Configuration, uc usecases.Usecases, auth uti
 	router.DELETE("/webhooks/:webhook_id", tom, handleDeleteWebhook(uc))
 
 	router.GET("/rule-snoozes/:rule_snooze_id", tom, handleGetSnoozesById(uc))
+
+	router.GET("/workflows/:scenarioId", tom, handleListWorkflowsForScenario(uc))
 }

dto/workflows.go

@@ -0,0 +1,63 @@
+package dto
+
+import (
+	"encoding/json"
+
+	"github.com/checkmarble/marble-backend/models"
+	"github.com/checkmarble/marble-backend/pure_utils"
+)
+
+type WorkflowRuleDto struct {
+	Id   string `json:"id"`
+	Name string `json:"name"`
+}
+
+type WorkflowConditionDto struct {
+	Id       string         `json:"id"`
+	Function string         `json:"function"`
+	Params   json.Marshaler `json:"params"`
+}
+
+type WorkflowActionDto struct {
+	Id     string         `json:"id"`
+	Action string         `json:"action"`
+	Params json.Marshaler `json:"params"`
+}
+
+type WorkflowDto struct {
+	WorkflowRuleDto
+
+	Conditions []WorkflowConditionDto `json:"conditions"`
+	Actions    []WorkflowActionDto    `json:"actions"`
+}
+
+func AdaptWorkflow(m models.Workflow) WorkflowDto {
+	return WorkflowDto{
+		WorkflowRuleDto: AdaptWorkflowRule(m.WorkflowRule),
+		Conditions:      pure_utils.Map(m.Conditions, AdaptWorkflowCondition),
+		Actions:         pure_utils.Map(m.Actions, AdaptWorkflowAction),
+	}
+}
+
+func AdaptWorkflowRule(m models.WorkflowRule) WorkflowRuleDto {
+	return WorkflowRuleDto{
+		Id:   m.Id,
+		Name: m.Name,
+	}
+}
+
+func AdaptWorkflowCondition(m models.WorkflowCondition) WorkflowConditionDto {
+	return WorkflowConditionDto{
+		Id:       m.Id,
+		Function: m.Function,
+		Params:   m.Params,
+	}
+}
+
+func AdaptWorkflowAction(m models.WorkflowAction) WorkflowActionDto {
+	return WorkflowActionDto{
+		Id:     m.Id,
+		Action: string(m.Action),
+		Params: m.Params,
+	}
+}

integration_test/scenario_flow_test.go

@@ -15,7 +15,6 @@ import (
 
 	"github.com/checkmarble/marble-backend/models"
 	"github.com/checkmarble/marble-backend/models/ast"
-	"github.com/checkmarble/marble-backend/pure_utils"
 	"github.com/checkmarble/marble-backend/usecases"
 	"github.com/checkmarble/marble-backend/usecases/payload_parser"
 	"github.com/checkmarble/marble-backend/usecases/scenarios"
@@ -407,15 +406,30 @@ func setupScenarioAndPublish(
 	}
 	fmt.Printf("Updated scenario iteration %+v\n", scenarioIteration)
 
-	workflowType := models.WorkflowAddToCaseIfPossible
-	_, err = scenarioUsecase.UpdateScenario(ctx, models.UpdateScenarioInput{
-		Id:                         scenarioId,
-		DecisionToCaseOutcomes:     []models.Outcome{models.Decline, models.Review},
-		DecisionToCaseInboxId:      pure_utils.NullFrom(inboxId),
-		DecisionToCaseWorkflowType: &workflowType,
+	rule, err := scenarioUsecase.CreateWorkflowRule(ctx, organizationId, models.WorkflowRule{
+		ScenarioId: scenarioId,
+		Name:       "First rule",
 	})
 	if err != nil {
-		assert.FailNow(t, "Failed to create workflow on scenario", err)
+		assert.FailNow(t, "Could not create workflow rule", err)
+	}
+
+	_, err = scenarioUsecase.CreateWorkflowCondition(ctx, organizationId, models.WorkflowCondition{
+		RuleId:   rule.Id,
+		Function: "if_outcome_in",
+		Params:   []byte(`["decline", "review"]`),
+	})
+	if err != nil {
+		assert.FailNow(t, "Could not create workflow condition", err)
+	}
+
+	_, err = scenarioUsecase.CreateWorkflowAction(ctx, organizationId, models.WorkflowAction{
+		RuleId: rule.Id,
+		Action: models.WorkflowAddToCaseIfPossible,
+		Params: fmt.Appendf(nil, `{"inbox_id": "%s"}`, inboxId),
+	})
+	if err != nil {
+		assert.FailNow(t, "Could not create workflow action", err)
 	}
 
 	return scenarioId, scenarioIterationId

models/scenarios.go

@@ -22,6 +22,17 @@ var ValidWorkflowTypes = []WorkflowType{
 	WorkflowAddToCaseIfPossible,
 }
 
+func WorkflowTypeFromString(s string) WorkflowType {
+	switch s {
+	case "ADD_TO_CASE_IF_POSSIBLE":
+		return WorkflowAddToCaseIfPossible
+	case "CREATE_CASE":
+		return WorkflowCreateCase
+	default:
+		return WorkflowDisabled
+	}
+}
+
 type Scenario struct {
 	Id                         string
 	CreatedAt                  time.Time

models/workflows.go

@@ -0,0 +1,77 @@
+package models
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/checkmarble/marble-backend/models/ast"
+	"github.com/cockroachdb/errors"
+	"github.com/google/uuid"
+)
+
+type Workflow struct {
+	WorkflowRule
+
+	Conditions []WorkflowCondition
+	Actions    []WorkflowAction
+}
+
+type WorkflowRule struct {
+	Id         string
+	ScenarioId string
+	Name       string
+	Priority   int
+
+	CreatedAt time.Time
+	UpdatedAt *time.Time
+}
+
+type WorkflowCondition struct {
+	Id       string
+	RuleId   string
+	Function string
+	Params   json.RawMessage
+
+	CreatedAt time.Time
+	UpdatedAt *time.Time
+}
+
+type WorkflowAction struct {
+	Id     string
+	RuleId string
+	Action WorkflowType
+	Params json.RawMessage
+
+	CreatedAt time.Time
+	UpdatedAt *time.Time
+}
+
+func ParseWorkflowAction[T any](action WorkflowAction) (WorkflowActionSpec[T], error) {
+	out := WorkflowActionSpec[T]{Action: action.Action}
+
+	switch action.Action {
+	case WorkflowCreateCase, WorkflowAddToCaseIfPossible:
+		if err := json.Unmarshal(action.Params, &out.Params); err != nil {
+			return out, errors.Wrap(err, "could not unmarshal workflow action parameters")
+		}
+
+		return out, nil
+	default:
+		return WorkflowActionSpec[T]{Action: WorkflowDisabled}, nil
+	}
+}
+
+type WorkflowActionSpec[T any] struct {
+	Action WorkflowType
+	Params T
+}
+
+type WorkflowCaseParams struct {
+	InboxId       *uuid.UUID `json:"inbox_id"`
+	TitleTemplate *ast.Node  `json:"title_template"`
+}
+
+type WorkflowExecution struct {
+	AddedToCase bool
+	WebhookIds  []string
+}

repositories/dbmodels/db_scenario_workflows.go

@@ -0,0 +1,111 @@
+package dbmodels
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/checkmarble/marble-backend/models"
+	"github.com/checkmarble/marble-backend/pure_utils"
+	"github.com/checkmarble/marble-backend/utils"
+)
+
+type DbWorkflowRule struct {
+	Id         string `db:"id"`
+	ScenarioId string `db:"scenario_id"`
+	Name       string `db:"name"`
+	Priority   int    `db:"priority"`
+
+	CreatedAt time.Time  `db:"created_at"`
+	UpdatedAt *time.Time `db:"updated_at"`
+}
+
+type DbWorkflowRuleWithConditions struct {
+	DbWorkflowRule
+
+	Conditions []DbWorkflowCondition `db:"conditions"`
+	Actions    []DbWorkflowAction    `db:"actions"`
+}
+
+type DbWorkflowCondition struct {
+	Id       string          `db:"id"`
+	RuleId   string          `db:"rule_id"`
+	Function string          `db:"function"`
+	Params   json.RawMessage `db:"params"`
+
+	CreatedAt time.Time  `db:"created_at"`
+	UpdatedAt *time.Time `db:"updated_at"`
+}
+
+type DbWorkflowAction struct {
+	Id     string          `db:"id"`
+	RuleId string          `db:"rule_id"`
+	Action string          `db:"action"`
+	Params json.RawMessage `db:"params"`
+
+	CreatedAt time.Time  `db:"created_at"`
+	UpdatedAt *time.Time `db:"updated_at"`
+}
+
+const TABLE_WORKFLOW_RULES = "scenario_workflow_rules"
+const TABLE_WORKFLOW_CONDITIONS = "scenario_workflow_conditions"
+const TABLE_WORKFLOW_ACTIONS = "scenario_workflow_actions"
+
+var WorkflowRuleColumns = utils.ColumnList[DbWorkflowRule]()
+var WorkflowConditionColumns = utils.ColumnList[DbWorkflowCondition]()
+var WorkflowActionColumns = utils.ColumnList[DbWorkflowAction]()
+
+func AdaptWorkflowRule(db DbWorkflowRule) (models.WorkflowRule, error) {
+	return models.WorkflowRule{
+		Id:         db.Id,
+		ScenarioId: db.ScenarioId,
+		Name:       db.Name,
+		Priority:   db.Priority,
+		CreatedAt:  db.CreatedAt,
+		UpdatedAt:  db.UpdatedAt,
+	}, nil
+}
+
+func AdaptWorkflowCondition(db DbWorkflowCondition) (models.WorkflowCondition, error) {
+	return models.WorkflowCondition{
+		Id:        db.Id,
+		RuleId:    db.RuleId,
+		Function:  db.Function,
+		Params:    db.Params,
+		CreatedAt: db.CreatedAt,
+		UpdatedAt: db.UpdatedAt,
+	}, nil
+}
+
+func AdaptWorkflowAction(db DbWorkflowAction) (models.WorkflowAction, error) {
+	return models.WorkflowAction{
+		Id:        db.Id,
+		RuleId:    db.RuleId,
+		Action:    models.WorkflowTypeFromString(db.Action),
+		Params:    db.Params,
+		CreatedAt: db.CreatedAt,
+		UpdatedAt: db.UpdatedAt,
+	}, nil
+}
+
+func AdaptWorkflowRuleWithConditions(db DbWorkflowRuleWithConditions) (models.Workflow, error) {
+	rule, err := AdaptWorkflowRule(db.DbWorkflowRule)
+	if err != nil {
+		return models.Workflow{}, err
+	}
+
+	conditions, err := pure_utils.MapErr(db.Conditions, AdaptWorkflowCondition)
+	if err != nil {
+		return models.Workflow{}, err
+	}
+
+	actions, err := pure_utils.MapErr(db.Actions, AdaptWorkflowAction)
+	if err != nil {
+		return models.Workflow{}, err
+	}
+
+	return models.Workflow{
+		WorkflowRule: rule,
+		Conditions:   conditions,
+		Actions:      actions,
+	}, nil
+}

repositories/migrations/20250620211400_create_workflows.sql

@@ -0,0 +1,45 @@
+-- +goose Up
+
+create table scenario_workflow_rules (
+    id uuid primary key default gen_random_uuid(),
+    scenario_id uuid not null,
+    name text not null,
+    priority int,
+    created_at timestamp with time zone default now(),
+    updated_at timestamp with time zone,
+
+    constraint fk_scenario
+        foreign key (scenario_id) references scenarios (id)
+        on delete cascade
+);
+
+create table scenario_workflow_conditions (
+    id uuid primary key default gen_random_uuid(),
+    rule_id uuid not null,
+    function text not null,
+    params jsonb,
+    created_at timestamp with time zone default now(),
+    updated_at timestamp with time zone,
+
+    constraint fk_rule
+        foreign key (rule_id) references scenario_workflow_rules (id)
+        on delete cascade
+);
+
+create table scenario_workflow_actions (
+    id uuid primary key default gen_random_uuid(),
+    rule_id uuid not null,
+    action text not null,
+    params jsonb,
+    created_at timestamp with time zone default now(),
+    updated_at timestamp with time zone,
+
+    constraint fk_rule
+        foreign key (rule_id) references scenario_workflow_rules (id)
+        on delete cascade
+);
+
+-- +goose Down
+
+drop table scenario_workflow_conditions;
+drop table scenario_workflow_rules;