Generalize workflow system.

Author: apognu

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,61 @@
+package models
+
+import (
+	"encoding/json"
+	"time"
+
+	"github.com/checkmarble/marble-backend/models/ast"
+	"github.com/google/uuid"
+)
+
+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
+}
+
+type WorkflowRuleWithConditions struct {
+	WorkflowRule
+
+	Conditions []WorkflowCondition
+	Actions    []WorkflowAction
+}
+
+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,110 @@
+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,
+		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.WorkflowRuleWithConditions, error) {
+	rule, err := AdaptWorkflowRule(db.DbWorkflowRule)
+	if err != nil {
+		return models.WorkflowRuleWithConditions{}, err
+	}
+
+	conditions, err := pure_utils.MapErr(db.Conditions, AdaptWorkflowCondition)
+	if err != nil {
+		return models.WorkflowRuleWithConditions{}, err
+	}
+
+	actions, err := pure_utils.MapErr(db.Actions, AdaptWorkflowAction)
+	if err != nil {
+		return models.WorkflowRuleWithConditions{}, err
+	}
+
+	return models.WorkflowRuleWithConditions{
+		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;